Urho Base class for animatable object, an animatable object can be set animation on it's attributes, or can be set an object animation to it. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Animatable, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Constructs a new instance of Urho.Animatable, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Return animation enabled. Or Set animation enabled. Return attribute animation. Return attribute animation speed. Return attribute animation wrap mode. Return object animation. Or Set object animation. Return object animation attribute. Register object factory. Remove object animation. Same as calling SetObjectAnimation with a null pointer. Set attribute animation. Set attribute animation speed. Set attribute animation wrap mode. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Animated model component. Constructs a new instance of Urho.AnimatedModel which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.AnimatedModel, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.AnimatedModel linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add an animation. Return animation LOD bias. Or Set animation LOD bias. Return all animation states. Apply all animation states to nodes. Apply attribute changes that can not be applied immediately. Called after scene load or a network update. Visualize the component as debug geometry. Return animation state by animation name. Return animation state by index. Return animation state by animation pointer. Return animation state by animation name hash. Return vertex morph weight by name. Return vertex morph weight by index. Return vertex morph weight by name hash. Return whether is the master (first) animated model. Return model attribute. Return all morph vertex buffers. Return number of animation states. Return number of vertex morphs. Register object factory. Drawable must be registered first. Remove all animations. Remove an animation by animation name. Remove an animation by index. Remove an animation by animation pointer. Remove an animation by AnimationState pointer. Remove an animation by animation name hash. Reset all vertex morphs to zero. Set model. Set vertex morph weight by name. Set vertex morph weight by index. Set vertex morph weight by name hash. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Recalculates the bone bounding box. Return whether a geometry update is necessary, and if it can happen in a worker thread. Return whether to update animation when not visible. Or Set whether to update animation and the bounding box when not visible. Recommended to enable for physically controlled models like ragdolls. Skeletal animation resource. Constructs a new instance of Urho.Animation which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Animation, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Animation linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add a trigger point. Add a trigger point. Add a trigger point. Add a trigger point. Add a trigger point. Add a trigger point. Add a trigger point. Add a trigger point. Add a trigger point. Add a trigger point. Add a trigger point. Add a trigger point. Return animation name. Or Set animation name. Return animation name hash. Create and return a track by name. If track by same name already exists, returns the existing. Return animation track by name. Return animation track by name hash. Return a trigger point by index. Return animation length. Or Set animation length. Return number of animation tracks. Return number of animation trigger points. Or Resize trigger point vector. Register object factory. Remove all tracks. This is unsafe if the animation is currently used in playback. Remove all trigger points. Remove a track by name. Return true if was found and removed successfully. This is unsafe if the animation is currently used in playback. Remove a trigger point by index. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Animation blending mode Additive blending based on difference from bind pose Lerp blending (default) Component that drives an AnimatedModel's animations. Constructs a new instance of Urho.AnimationController which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.AnimationController, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.AnimationController linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Fade animation to target weight. Return true on success. Fade other animations on the same layer to target weight. Return true on success. Find an animation state by animation name. Find an animation state by animation name hash Return animation autofade time. Return animation blending mode. Return animation fade target weight. Return animation fade time. Return animation blending layer. Return animation length. Return whether animation auto-removes on completion, or false if no such animation. Return animation speed. Return animation start bone, or null if no such animation. Return animation start bone name, or empty string if no such animation. Return animation time position. Return animation weight. Return whether an animation is at its end. Will return false if the animation is not active at all. Return whether an animation is fading in. Return whether an animation is fading out. Return animation looping. Return whether an animation is active. Note that non-looping animations that are being clamped at the end also return true. Return whether an animation is active. Note that non-looping animations that are being clamped at the end also return true. Handle enabled/disabled state change. Play an animation and set full target weight. Name must be the full resource name. Return true on success. Play an animation, set full target weight and fade out all other animations on the same layer. Name must be the full resource name. Return true on success. Register object factory. Set animation autofade at end (non-looped animations only.) Zero time disables. Return true on success. Set animation blending mode. Return true on success. Set animation blending layer priority. Return true on success. Set animation looping. Return true on success. Set whether an animation auto-removes on completion. Set animation speed. Return true on success. Set animation start bone. Return true on success. Set animation time position. Return true on success. Set animation weight. Return true on success. Stop an animation. Zero fadetime is instant. Return true on success. Stop all animations. Zero fadetime is instant. Stop all animations on a specific layer. Zero fadetime is instant. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Update the animations. Is called from HandleScenePostUpdate(). Animation instance. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.AnimationState, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Modify time position. %Animation triggers will be fired. Modify blending weight. Return animation. Apply the animation at the current time position. Return blending mode. Or Set blending mode. Return whether weight is nonzero. Return per-bone blending weight by name. Return per-bone blending weight by track index. Return per-bone blending weight by name. Return track index by bone name, or M_MAX_UNSIGNED if not found. Return track index with matching bone node, or M_MAX_UNSIGNED if not found. Return track index by bone name hash, or M_MAX_UNSIGNED if not found. Return blending layer. Or Set blending layer. Return animation length. Determines whether the animation looped. Return animated model this state belongs to (model mode.) Return root scene node this state controls (node hierarchy mode.) Set per-bone blending weight by name. Set per-bone blending weight by track index. Default is 1.0 (full), is multiplied with the state's blending weight when applying the animation. Optionally recurses to child bones. Set per-bone blending weight by name hash. Return start bone. Or Set start bone. Not supported in node animation mode. Resets any assigned per-bone weights. Return time position. Or Set time position. Does not fire animation triggers. Return blending weight. Or Set blending weight. Event arguments for the Node's AnimationTrigger event Base class for creating applications which initialize the Urho3D engine and run a main loop until exited. This is the base class that your application should subclass and provide at implementations for the  and  methods.  You can use await asynchronous methods from the  methods. Access to various subsystems in Urho is available through the various properties in this class: An application is tied to a  which should be passed on the initial constructor. This shows a minimal application: { if (args.Key == Key.Esc) Engine.Exit(); }); } }]]> Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Application, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Returns the Audio subsystem. See the  class description for more information on how to use the Audio subsystem. Returns the Console subsystem Last created application. Returns the application’s engine. Show an error message (last log message if empty), terminate the main loop, and set failure exit code. Returns the FileSystem subsystem. Returns the Graphics subsystem. Determines if the Current property has been set. if it has been set, otherwise. Returns the Input subsystem. Method to be invoked on the main thread. Invoke actions in the Main Thread (the next Update call) Determines if the application has been closed, and we are shutting down. True means Urho3D is somewhere between E_BEGINFRAME and E_ENDFRAME in Engine::RunFrame() Returns the Log subsystem. Returns the Network subsystem. This method is invoked on every application update. The application options in use The value is either the one that was passed to the constructor, or the default. Simple way of obtaining the platform on which the program is running from cross platform code. Use this to easily find out from your cross platform code on which platform you are executing. Returns the Profiler subsystem. Returns the Renderer subsystem. Returns the ResourceCache subsystem. Initialize the engine and run the main loop, then return the application exit code. Catch out-of-memory exceptions while running. Method invoked to setup your application.  You can setup the engine parameters here, but you should postpone the resource loading until the  method is invoked. On error, you can invoke the  method to terminate execution. Method invoked to start your application, this is where you would typically create your scene. Event raised when your application has started. This event is invoked after the  virtual method is invoked on your application. Method invoked to terminate your application. Returns the Time subsystem. Dispatch to OnUpdate Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Returns the UI subsystem. Frame update event This event is raised when the frame has been updated. Returns the WorkQueue subsystem. Application options, see full description at: http://urho3d.github.io/documentation/1.4/_running.html This contains the list of options that can be configured at application startup, these settings control how the engine is initialized. The options set with this selector are passed to the Urho game engine on startup. You can use the convenience  or  static values as options to use as either defaults for landscape or portrait. This is usually the “Data” directory, but can be null if your application only requires the built-in assets. Initializes the application options with a directory pointing to the assets folders (Usually the “Data” directory) Constructs a new instance of  Any additional options from the Urho engine that might not be encompassed by one of the strongly typed properties here. Determines whether the “CoreData” is always part of the resources looked up by Urho. The default value for this property is . By default, the  will set Urho’s internal resource paths to the “CoreData”, plus any directories specified in    If you set this flag to , then “CoreData” directory will not be included. With this option Urho will not start the render loop when Run is called. The state of the delayed start Use this option if you want to prevent the main loop from running immediately.   In that case, you will want to manually run the loop by calling the  method on a loop at your convenience. Pointer to an NSView or a Win32 handle to use as a surface. The current handle to the native window This is a platform specific pointer to a native handle.   On Windows, this is a handle to a window (HWND), and on Cocoa it is a pointer to an NSView (if you are using the Xamarin.Mac API, this will be the Handle of the ).  This instructs UrhoSharp to use that window or view as its rendering target.   This is used in scenarios where you want to embed the engine into another application. Desktop only option. Enable HighDPI mode (iOS or macOS only). Default value is True. Determines whether we should limit the frames (defaults to true), the default is limit is 200 FPS for desktop, and 60 fps, despite of the flag settings. Disable sound output iOS only - orientation for the game This describes the allowed orientation modes for the display. Desktop only - provides a resizable window. Resource package files to use - default empty. Resource path(s) to use (default: Data, CoreData) The  property controls whether the CoreData directory is included or not. The paths must be directories, or “.pak” files relative to one of the directories listed in . Resource prefix path, it defaults to the value of the URHO3D_PREFIX_PATH environment variable, or if not set, the executable path. Resource paths are relative to the ResourcePrefixPaths. If using the URHO3D_PREFIX_PATH environment variable, the directories must be separated with a semicolon. Returns the command line version suitable to be sent to the Urho engine. Enable touch-emulation on desktop environments. Defaults to . Desktop only option. Desktop only option. Orientation type for the application Landscape orientation desired. Landscape or portrait orientation accepted. Portrati orientation desired. Event arguments for the Scene's AsyncLoadFinished event Event arguments for the Scene's AsyncLoadProgress event Abstract base class for invoking attribute accessors. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.AttributeAccessor, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Set the attribute. Set the attribute. Set the attribute. Set the attribute. Set the attribute. Set the attribute. Set the attribute. Set the attribute. Set the attribute. Set the attribute. Event arguments for the ObjectAnimation's AttributeAnimationAdded event Attribute animation instance. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.AttributeAnimationInfo, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Event arguments for the ObjectAnimation's AttributeAnimationRemoved event Event arguments for the Scene's AttributeAnimationUpdate event Autoremove is used by some components for automatic removal from the scene hierarchy upon completion of an action, for example sound or particle effect. Event arguments for the Renderer's BeginViewRender event Event arguments for the View's BeginViewUpdate event Single billboard. One billboard in the billboard set. Color Direction Enabled flag Position Rotation Two-dimensional size Sort distance UV Coordinates Billboard component. After creating a , you will configure the number of billboards by setting the .    Configure individual  objects by calling the  (or the unsafe version, ). After making changes to the individual billboard objects, call the  method to update the internals of the . Constructs a new instance of Urho.BillboardSet which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.BillboardSet, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.BillboardSet linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return animation LOD bias. Or Set animation LOD bias. Mark for bounding box and vertex buffer update. Call after modifying the billboards. Return how the billboards rotate in relation to the camera. Or Set how the billboards should rotate in relation to the camera. Default is to follow camera rotation on all axes (FC_ROTATE_XYZ.) Return whether billboards are fixed screen size. Or Set whether billboards have fixed size on screen (measured in pixels) regardless of distance to camera. Default false. The index of the billboard in the collection to fetch. Return billboard by index. Pointer to the billboard, or if the index is out of bounds. The index of the billboard in the collection to fetch. Returns a safe Billboard () by index, without exposing an unsafe pointer. A reference to the , or  if the index is out of bounds. Return material. Or Set material. Return material attribute. Return minimal angle between billboard normal and look-at direction. Or Set minimal angle between billboard normal and look-at direction. Return number of billboards. Or Set number of billboards. Register object factory. Controls whether billboards are relative to the scene node. Controls whether scene node scale affects billboards' size. Determines whether billboards are sorted. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return whether a geometry update is necessary, and if it can happen in a worker thread. Safe wrapper for a Billboard This wrapper ensures that values fetched from one of the  APIs retain the containing Billboard. Creates the billboard from an actual pointers and the container. Color. Enabled flag. Position. Rotation. Two-dimensional size. Sort distance. UV Coordinates. Blending mode. Bone in a skeleton Bones are important parts of the skeleton. Determines whether the bone is animated. Local space bounding box Supported collision types. Initial position. Initial rotation Initial scale. Bone name Offset matrix. Parent bone index. Radius Event arguments for the Node's BoneHierarchyCreated event Provides a safe accessor for the unmanaged Bone structure. This is only here to provide a safe mechanism to access Bone elements, as the Bone objects are transient. Creates a bone wrapper by keeping a reference to the object holding the actual storage for the bone. Determines whether the bone is animated. Local space bounding box Supported collision types. Initial position. Initial Rotation. Initial scale. Name Offset matrix. Parent bone index. Radius. 3D bounding box A 3D-space bounding box with two 3D-vector properties, one for the minimal value (, and one for the maximum value (. The frustum containing the vertices Constructs a bounding box from the vertices of a frustum This creates a bounding box that encompasses the frustum vertices. Rectangle to use as the reference for the bounding box. Constructs from a rectangle, setting the Z coordinate as zero. Array of vectors. Constructs from an array of vectors This constructs a bounding box that encompasses all the vectors provided. Minimum value. Maximum value. Construct from minimum and maximum floats (all dimensions same.) Minimum value. Maximum value. Construct from minimum and maximum vectors. Returns the center of the bounding box. The bounding box to clip this instance of the bounding box with. Clips the bounding box with the provided box and returns the new result The new clipped value.   The original bounding box remains unmodified. Return true if this bounding box is defined via a previous call to Define() or Merge(). Unused, used for structure field padding. Unused, used for structure field padding. Return the half-size of the bounding box. The box to test if it is inside this instance’s box. Test if another bounding box is inside, outside or intersects.  if the specified is outside the current bounding box, or  if the is fully contained within this bounding box, or  if the specified intersects this bounding box. If you are only interested on the Inside/Outside values and do not care about intersect, you can use the  method which performs fewer tests. The point to test. Test if a point is  inside, outside or intersects the bounding box.  if the specified  is outside the current bounding box or  if the specified  is inside this bounding box.  The box to test if it is inside this instance’s box. Test if another bounding box is inside or outside/intersects.  if the specified  is outside the current bounding box or  if the specified  intersects or is completelly inside this bounding box.   If you want more precise information use the  method which can distinguish between  and . Maximum vector The other bounding box to merge with this one. Merge another bounding box with this one. The result of merging two bounding boxes is a bounding box that bounds both boxes. The frustum containing the vertices. Merge the vertices of the provided frustum with the bounding box. Merges the frustum vertices with the bounding box, extending the bounding box if needed. Merges the point with the bounding box, extending the bounding box if needed. The result of merging two bounding boxes is a bounding box that bounds both boxes. Array of vectors. Merge the vertices  with the bounding box. Merges the vector point with the bounding box, extending the bounding box if needed. Minimum vector. The size of the bounding box, the Max minus the Min. Camera component. Constructs a new instance of Urho.Camera which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Camera, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Camera linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return aspect ratio. Or Set aspect ratio manually. Disables the auto aspect ratio -mode. Return auto aspect ratio flag. Or Set automatic aspect ratio based on viewport dimensions. Enabled by default. Return the custom clipping plane. Or Set custom clipping plane in world space. Return clipping plane attribute. Visualize the component as debug geometry. Get effective world transform for matrix and frustum calculations including reflection but excluding node scaling. Return far clip distance. Or Set far clip distance. Return fill mode. Or Set polygon fill mode to use when rendering a scene. Return vertical flipping mode. Or Set vertical flipping mode. Called internally by View to resolve OpenGL / Direct3D9 rendertarget sampling differences. Return vertical field of view in degrees. Or Set vertical field of view in degrees. Return frustum in world space. Return distance to position. In orthographic mode uses only Z coordinate. Return squared distance to position. In orthographic mode uses only Z coordinate. Return a scene node's LOD scaled distance. Return ray corresponding to normalized screen coordinates (0.0 - 1.0). Return frustum split by custom near and far clip distances. Return split frustum in view space. Return projection matrix converted to API-specific format for use as a shader parameter. Return half view size. Return LOD bias. Or Set LOD bias. Return near clip distance. Or Set near clip distance. Determines whether the camera is Orthographic or not. Return orthographic mode size. Or Set orthographic mode view uniform size. Returns an API-specific projection matrix The result value is specific to the host rendering library (D3D vs OpenGL) Return projection offset. Or Set projection offset. It needs to be calculated as (offset in pixels) / (viewport dimensions.) Return if projection parameters are valid for rendering and raycasting. Return the reflection plane. Or Set reflection plane in world space for reflection mode. Return reflection plane attribute. Register object factory. Return whether to reverse culling; affected by vertical flipping and reflection. Set aspect ratio without disabling the "auto aspect ratio" mode. Called internally by View. Set clipping plane attribute. Set orthographic mode view non-uniform size. Disables the auto aspect ratio -mode. Set orthographic size attribute without forcing the aspect ratio. Set reflection plane attribute. Return skew. Or Set skew Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return whether is using a custom clipping plane. Or Set whether to use a custom clip plane. Return whether is using reflection. Or Set reflection mode. Return view matrix. Return view mask. Or Set view mask. Will be and'ed with object's view mask to see if the object should be rendered. Return view override flags. Or Set view override flags. Return frustum in view space. Return zoom. Or Set zoom. Base class for collision shape geometry data. Represents a Color with transparency in Urho as four 32-bit floating point values. Individual channels should have values from zero to one. Initializes the color from a color source and copies all elements from it. Initializes the color by copying the red, green and blue components from the source and using the specified value for the alpha component. Initializes a  instance from the given red, green, blue and transparency values. The transparency (alpha) value. Blue component Opaque black color (RGB values are set to 0, 0, 0). Opaque blue color (RGB values are set to 0, 0, 1). Opaque cyan color (RGB values are set to 0, 1, 1). Green component Opaque grey color (RGB values are set to 0.5, 0.5, 0.5). Opaque green color (RGB values are set to 0, 1, 0). Opaque magenta color (RGB values are set to 1, 0, 1). Red component Opaque red color (RGB values are set to 1, 0, 0). Fully transparent color, has red, green, blue and alpha values set to zero. Opaque white color (RGB values are set to 1, 1, 1). Opaque yellow color (RGB values are set to 1, 1, 0). Depth or stencil compare mode. Base class for components. Components can be attached to scene nodes. Use the  is the base class for custom components, it is a low-level interface.   A simpler version to use is  which provides various convenience features.    The next section for details on how to connect to various events in the life cycle of a component.

Events

 You can catch the time where the component is attached to a  by overwriting the  method.   To receive  update messages, you should first set the  property to  on your constructor, and then override the  method. If you are interest in updates from the physics engine, you should connect directly to the  event for your world.  If you are interested in receiving the scene post-update, subscribe to the  event.

Serialization

 To implement serialization you would override the OnSerialize and OnDeserialize methods and store your component state on the provided serializer and deserializer objects. (nameof(MyRotation)); MyName = des.Deserialize(nameof(MyName)); } // called when the component is attached to some node public override void OnAttachedToNode() { var node = this.Node; } }]]> Constructs a new instance of Urho.Component which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Component, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Component linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add a replication state that is tracking this component. Clean up all references to a network connection that is about to be removed. Visualize the component as debug geometry. Controls whether the component is enabled or not, additionally, the node might not be enabled, see EnabledEffective for a computation that takes both into account. Return whether is effectively enabled, that is, both the component and its containing Node are enabled. Return component in the same scene node by type. If there are several, returns the first. Return ID. Mark for attribute check on the next network update. Return scene node. Object used to retrieve the stored information Overridable method to deserialize the component state Implement this method to have the Urho runtime initialize your object state from a previously saved state. You serialize the state into this object. Overridable method to serialize the component state You typically override this method in your application to save the state of your component.   Saving takes place by saving the state on the API surfaced by the serializer parameter. Handle enabled/disabled state change. Make sure to set the  property to true in order to receive update events Prepare network update by comparing attributes and marking replication states dirty as necessary. Remove from the scene node. If no other shared pointer references exist, causes immediate deletion. Return the scene the node belongs to. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Event arguments for the Scene's ComponentAdded event Event arguments for the Scene's ComponentEnabledChanged event Event arguments for the Scene's ComponentRemoved event Event arguments for the UrhoConsole's ConsoleCommand event Hardware constant buffer. Constructs a new instance of Urho.ConstantBuffer which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.ConstantBuffer, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.ConstantBuffer linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Apply to GPU. Return whether has unapplied data. Release the buffer. Set a generic parameter and mark buffer dirty. Set size and create GPU-side buffer. Return true on success. Set a Vector3 array parameter and mark buffer dirty. Return size. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Urho3D execution context. Provides access to subsystems, object factories and attributes, and event receivers. By default the empty constructors for nodes will create the objects in the current Context (Available in the ).    Construct. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Context, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Copy base class attributes to derived class. Create an object by type hash. Return pointer to it or null if no factory found. Return active event handler. Set by Object. Null outside event handling. Return active event sender. Null outside event handling. Return event receivers for a sender and event type, or null if they do not exist. Return event receivers for an event type, or null if they do not exist. Return subsystem by type. Return object type name from hash, or empty if unknown. Register a factory for an object type. Register a subsystem. Indicate that you are done with using SDL. Must be called after using RequireSDL(). Remove a subsystem. Name of the global variable to assign. The value to assign to the global variable. Sets an Urho global variable to an integer value. Name of the global variable to assign. The value to assign to the global variable. Sets an Urho global variable to an floating point value. Name of the global variable to assign. The value to assign to the global variable. Sets an Urho global variable to a string value. Name of the global variable to assign. The value to assign to the global variable. Sets an Urho global variable to an  value. Name of the global variable to assign. The value to assign to the global variable. Sets an Urho global variable to an  value. Name of the global variable to assign. The value to assign to the global variable. Sets an Urho global variable to an  value. Set global variable with the respective key and value Name of the global variable to assign. The value to assign to the global variable. Sets an Urho global variable to an  value. Name of the global variable to assign. The value to assign to the global variable. Sets an Urho global variable to a  value. Name of the global variable to assign. The value to assign to the global variable. Sets an Urho global variable to a  value. aName of the global variable to assign. The value to assign to the global variable. Sets an Urho global variable to a  value. Name of the global variable to assign. The value to assign to the global variable. Sets an Urho global variable to  value. Controls sent over the network Initializes the instance with Pitch, Yaw and Buttons state set to zero. Button state Checks if the specified button is down. Checks if the specified buttons are pressed in this frame, requires the previous frame control state. Mouse pitch Resets to the initial state (buttons, yaw and pitch are set to zero). Set or release buttons. Mouse yaw. Convex hull geometry data. Provides access to some of the names Core Asset that ship with every Urho application. This class provides convenient properties to access some of the various assets that ship with every Urho application: fonts, materials, models, techniques, textures and so on. Convenience method that returns the  Provides access to the fonts that are part of every CoreAssets package in Urho. Fonts can be defined as a TTF or SDF. Accesses the AnonymousPro font in CoreAssets. Provides access to the materials that are part of every CoreAssets package in Urho. You might want to take a look at Material.FromColor and Material.FromImage in order to construct a simple material. Accesses the Default Grey material in CoreAssets. Provides access to the models that are part of every CoreAssets package in Urho. Returns the box model from the resource cache (Models/Box.mdl) Returns the cone model from the resource cache (Models/Cone.mdl) Returns the cylinder model from the resource cache (Models/Cylinder.mdl) Returns the dome model from the resource cache (Models/Dome.mdl) Returns the plane model from the resource cache (Models/Plane.mdl) Returns the pyramid model from the resource cache (Models/Pyramid.mdl) Returns the sphere model from the resource cache (Models/Sphere.mdl) Returns the torus model from the resource cache (Models/Torus.mdl) Provides access to the render paths that are part of every CoreAssets package in Urho. Provides access to the techniques that are part of every CoreAssets package in Urho. Usually, name consists of a combination of features it uses: Basic - uses Basic shader, good for debug purposes Diff - displays a texture. It defines DIFFMAP and expects the texture in 'diffuse' texture unit (sDiffMap sampler). Normal - expects a normal map in 'normal' texture unit (sNormalMap sampler) Spec - expects a specular map in 'specular' texture unit. NoTexture - used by materials without textures. EnvCube - expects an environment map (cubic texture) in 'environment' texture unit. Unlit - materials with this technique won't be affected by any lights (self-illuminated). Emissive - similiar to Unlit, but it expects an emissive map in 'emissive' texture unit and will be affected by scene lights LightMap - expects a light map in 'emissive' texture unit. AO - expects an Ambient Occlusion map in 'emissive' texture unit. Translucent - materials with this technique will be affected by lights located behind the materials. VColor - will take Vertex Color (for example, defined via DefineColor) into account. Additive blending simply sums the values in the two layers. Blending with white gives white. Blending with black does not change the image. Multiply blend mode multiplies the numbers for each pixel of the top layer with the corresponding pixel for the bottom layer. The result is a darker picture. You can access built-in techniques via CoreAssets.Techniques: It allows to create different materials in code, for example the following snippet creates a material from a texture and a normal map using : Some of the basic techniques are explained in the following image Vertex color, no lights, alpha blending. Basic diffuse technique, defines DIFFMAP and expects a texture in 'diffuse' texture unit.. Same as Diffuse but with alpha blending. Diffuse map with alpha and additive blending. Diffuse map with alpha blending. Diffuse map with alpha blending. Can be translucent. Diffuse map with ambient occlusion. AO should be passed to 'emissive' texture unit. Diffuse map with ambient occlusion and Alpha blending. AO should be passed to 'emissive' texture unit. Diffuse and emissive maps. Diffuse and emissive maps with Alpha blending. Diffuse and environment maps. Diffuse and environment maps with Alpha blending. Diffuse and environment maps with Ambient Occlusion. Diffuse and environment maps with Alpha blending and Ambient Occlusion. Diffuse and light maps. Diffuse and light maps with Alpha blending. Diffuse map with blend mode 'multiply' Diffuse and normal maps. Diffuse and normal maps with Alpha blending. Diffuse and normal maps with Alpha blending. Can be translucent. Diffuse and normal maps with Ambient occlusion. Diffuse and normal maps with Ambient occlusion and Alpha blending. Diffuse, normal and emissive maps. Diffuse, normal and emissive maps with Alpha blending. Diffuse, normal and environment maps. Diffuse, normal and environment maps with Alpha blending. Diffuse, normal and specular maps. Diffuse, normal and specular maps with alpha. Diffuse, normal and specular maps with Ambient occlusion. Diffuse, normal and specular maps with Ambient occlusion and Alpha blending. Diffuse, normal, specular and emissive maps. Diffuse, normal, specular and emissive maps with Alpha blending. Diffuse map.. Diffuse map for Skybox. Diffuse map for Skydome. Diffuse map for Skyplane. Diffuse and specular maps. Diffuse and specular maps with Alpha blending. Diffuse map, not affected by any lighting (unlit). Diffuse map, not affected by any lighting (unlit) with Alpha blending. Diffuse map, uses Vertex Colors. Diffuse map, uses Vertex Colors and Alpha blending. Diffuse map, uses Vertex Colors and Alpha and Additive blendings. Diffuse map, uses Vertex Colors and Alpha and 'multiply' blendings. Diffuse map, uses Vertex Colors, Alpha blending and is not affected by any lights. Solid color. Solid color with Additive blending. Solid color with Additive and Alpha blending. Solid color with Alpha blending. Solid color with Ambient Occlusion. Solid color with Ambient Occlusion and Alpha blending. Solid color with Environment map. Solid color with Environment map and Alpha blending. Solid color with Environment map and Ambient Occlusion. Solid color with Environment map, Ambient Occlusion and Alpha blending. Solid color with blend mode 'multiply'. Solid color with Normal map. Solid color with Normal map and Alpha blending. Solid color (overlay). Solid color, not affected by any lighting. Solid color with alpha, not affected by any lighting Vertex color not affected by any lights. Vertex color. Vertex color with Additive blending. Vertex color with Additive and Alpha blending. Vertex color with 'multiply' blending. Provides access to the Physical Based Rendering techniques that are part of every CoreAssets package in Urho. Provides access to the textures that are part of every CoreAssets package in Urho. Component and child node creation mode for networking. Determines whether a  or  is local, that is, it only exists in the current process, or replicated, that is, that it gets replicated to other processes when using the  subsystem. The CreateMode translates into two different node and component ID ranges - replicated ID's range from 0x1 to 0xffffff, while local ID's range from 0x1000000 to 0xffffffff. This means there is a maximum of 16777215 replicated nodes or components in a scene. The node or component is local and will not be replicated when the program participates in a network game. The component will be replicated over the network. Cube map faces. Cubemap single image layout modes. Culling mode. Triangles can be discarded based on their apparent facing, a process known as Culling. Counterclockwise-facing culling. Clockwise-facing culling. Max culling mode. No culling. Custom geometry component. Constructs a new instance of Urho.CustomGeometry which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.CustomGeometry, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.CustomGeometry linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Begin defining a geometry. Clears existing vertices in that index. Clear all geometries. Update vertex buffer and calculate the bounding box. Call after finishing defining geometry. Define a vertex color. Set the primitive type, number of vertices and elements in a geometry, after which the vertices can be edited with GetVertex(). An alternative to BeginGeometry() / DefineVertex(). Define a vertex normal. Define a vertex tangent. Define a vertex UV coordinate. Define a vertex position. This begins a new vertex. Draw to occlusion buffer. Return true if did not run out of triangles. Determines whether vertex buffer dynamic mode is enabled. When setting the vertex buffer dynamic mode. A dynamic buffer should be faster to update frequently. Effective at the next Commit() call. Return the geometry for a specific LOD level. Return material by geometry index. Return number of vertices in a geometry. Return a vertex in a geometry for editing, or null if out of bounds. After the edits are finished, calling Commit() updates the vertex buffer. Return number of geometries. Or Set number of geometries. Return number of occlusion geometry triangles. Register object factory. Drawable must be registered first. Set material on all geometries. Set material on one geometry. Return true if successful. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Represents a vertex. This structure can be used in . Displays rendering stats and profiling information. Constructs a new instance of Urho.DebugHud which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.DebugHud, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.DebugHud linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Clear all application-specific stats. Return the UI style file. Or Set UI elements' style from an XML file. Return memory text. Return currently shown elements. Or Set elements to show. Return rendering mode text. Return profiler accumulation interval in seconds Or Set profiler accumulation interval in seconds. Return maximum profiler block depth. Or Set maximum profiler block depth, default unlimited. Return profiler text. Reset application-specific stats. Return true if it was erased successfully. Set application-specific stats. Return rendering stats text. Toggle elements. Toggle all elements. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Update. Called by HandlePostUpdate(). Return whether showing 3D geometry primitive/batch count only. Or Set whether to show 3D geometry primitive/batch count only. Default false. Debug geometry rendering component. Should be added only to the root scene node. Constructs a new instance of Urho.DebugRenderer which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.DebugRenderer, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.DebugRenderer linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add a circle. Add a cross. Add a cylinder Add a line with color already converted to unsigned. Add a line. Add a scene node represented as its coordinate axes. Add a quad on the XZ plane. Add a triangle with color already converted to unsigned. Add a triangle. Add a triangle mesh. Return the view frustum. Return whether has something to render. Check whether a bounding box is inside the view frustum. Set line antialiasing on/off. Default false. Return the projection transform. Register object factory. Update vertex buffer and render all debug lines. The viewport and rendertarget should be set before. Set the camera viewpoint. Call before rendering, or before adding geometry if you want to use culling. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return the view transform. Decal renderer component. Constructs a new instance of Urho.DecalSet which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.DecalSet, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.DecalSet linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add a decal at world coordinates, using a target drawable's geometry for reference. If the decal needs to move with the target, the decal component should be created to the target's node. Return true if successful. Apply attribute changes that can not be applied immediately. Called after scene load or a network update. Return material. Or Set material. The material should use a small negative depth bias to avoid Z-fighting. Return material attribute. Return maximum number of decal vertex indices. Or Set maximum number of decal vertex indices. Return maximum number of decal vertices. Or Set maximum number of decal vertices. Return number of decals. Retur number of vertex indices in the decals. Retur number of vertices in the decals. Handle enabled/disabled state change. Set whether to optimize GPU buffer sizes according to current amount of decals. Default false, which will size the buffers according to the maximum vertices/indices. When true, buffers will be reallocated whenever decals are added/removed, which can be worse for performance. Register object factory. Remove all decals. Remove n oldest decals. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return whether a geometry update is necessary, and if it can happen in a worker thread. Deferred light volume pixels shader variations. Deferred light volume vertex shader variations. Base class for visible components. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Drawable, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Adds the specified light. Adds the specified vertex light. Return local space bounding box. May not be applicable or properly updated on all drawables. Return shadowcaster flag. Or Set shadowcaster flag. Return distance from camera. Return drawable flags. Visualize the component as debug geometry. Return draw distance. Or Set draw distance. Draw to occlusion buffer. Return true if did not run out of triangles. Return the first added per-pixel light. Return the geometry for a specific LOD level. Return whether has a base pass. Return whether is in view this frame from any viewport camera. Excludes shadow map cameras. Return whether is in view of a specific camera this frame. Pass in a null camera to allow any camera, including shadow map cameras. Return light mask. Or Set light mask. Is and'ed with light's and zone's light mask to see if the object should be lit. Sort and limit per-pixel lights to maximum allowed. Convert extra lights into vertex lights. Sort and limit per-vertex lights to maximum allowed. Return LOD bias. Or Set LOD bias. Return LOD scaled distance from camera. Mark for update and octree reinsertion. Update is automatically queued when the drawable's scene node moves or changes scale. Mark in view without specifying a camera. Used for shadow casters. Return maximum number of per-pixel lights. Or Set maximum number of per-pixel lights. Default 0 is unlimited. Return the maximum view-space depth. Return the minimum view-space depth. Return number of occlusion geometry triangles. Controls the occludee flag. Controls the occluder flag. Return octree octant. Handle enabled/disabled state change. Register object attributes. Drawable must be registered first. Set base pass flag for a batch. Set view-space depth bounds. Set new zone. Zone assignment may optionally be temporary, meaning it needs to be re-evaluated on the next frame. Return shadow draw distance. Or Set shadow draw distance. Return shadow mask. Or Set shadow mask. Is and'ed with light's light mask and zone's shadow mask to see if the object should be rendered to a shadow map. Return sorting value. Or Set sorting value. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return whether a geometry update is necessary, and if it can happen in a worker thread. Return view mask. Or Set view mask. Is and'ed with camera's view mask to see if the object should be rendered. Return world-space bounding box. Return current zone. Return whether current zone is inconclusive or dirty due to the drawable moving. Return zone mask. Or Set zone mask. Is and'ed with zone's zone mask to see if the object should belong to the zone. Drawable flags These are bit flags that are set on any subclass of  to quickly determine the kind of Drawable it is.   The kind of drawable is used by the  class to determine how to render a particular component. Mask, used to match any drawable. The drawable is a Geometry (, , , , , , ) The drawable is a 2D Geometry () The drawable is a Light ( The drawable is a zone () Event arguments for the Input's DropFile event Particle emitter shapes. Box emitter Sphere emitter Event arguments for the Renderer's EndViewRender event Event arguments for the View's EndViewUpdate event Urho3D engine. Creates the other subsystems. Before a Urho3D application can enter its main loop, the Engine subsystem object must be created and initialized by calling the  method. 

Main Loop Iteration

 The main loop iteration (also called a frame) is driven by the Engine. In contrast it is the program's (for example Urho3DPlayer) responsibility to continuously loop this iteration by calling . This function calls in turn the  subsystem's  and  functions, and sends various update events in between.  There are a number of events that are raised, these events can be monitored by calling one of the various SubscribeToXxx methods in the UrhoObject base class. The event order is: : signals the beginning of the new frame.  and  react to this to check for operating system window messages and arrived network packets. : application-wide logic update event. By default each update-enabled  reacts to this and triggers the scene update (more on this below). : application-wide logic post-update event. The  subsystem updates its logic here. :  updates its viewports here to prepare for rendering, and the  generates render commands necessary to render the user interface. : by default nothing hooks to this. This can be used to implement logic that requires the rendering views to be up-to-date, for example to do accurate raycasts. Scenes may not be modified at this point; especially scene objects may not be deleted or crashes may occur. EndFrame: signals the end of the frame. Before this, rendering the frame and measuring the next frame's timestep will have occurred. The update of each  causes further events to be sent: SceneUpdate: variable timestep scene update. This is a good place to implement any scene logic that does not need to happen at a fixed step. SceneSubsystemUpdate: update scene-wide subsystems. Currently only the  component listens to this, which causes it to step the physics simulation and send the following two events for each simulation step: PhysicsPreStep: called before the simulation iteration. Happens at a fixed rate (the physics FPS). If fixed timestep logic updates are needed, this is a good event to listen to. PhysicsPostStep: called after the simulation iteration. Happens at the same rate as PhysicsPreStep. SmoothingUpdate: update  components in network client scenes. ScenePostUpdate: variable timestep scene post-update.   and  update themselves as a response to this event. Variable timestep logic updates are preferable to fixed timestep, because they are only executed once per frame. In contrast, if the rendering framerate is low, several physics simulation steps will be performed on each frame to keep up the apparent passage of time, and if this also causes a lot of logic code to be executed for each step, the program may bog down further if the CPU can not handle the load. Note that the Engine’s minimum FPS, by default 10, sets a hard cap for the timestep to prevent spiraling down to a complete halt; if exceeded, animation and physics will instead appear to slow down.

Main Loop and the Application Activation State

 The application window's state (has input focus, minimized or not) can be queried from the  subsystem. It can also effect the main loop in the following ways: Rendering is always skipped when the window is minimized. To avoid spinning the CPU and GPU unnecessarily, it is possible to define a smaller maximum FPS when no input focus. See . It is also possible to automatically pause update events and audio when the window is minimized. Use  to control this behaviour. By default it is not enabled on desktop, and enabled on mobile devices (Android and iOS.) For singleplayer games this is recommended to avoid unwanted progression while away from the program. However in a multiplayer game this should not be used, as the missing scene updates would likely desync the client with the server. On mobile devices the window becoming minimized can mean that it will never become maximized again, in case the OS decides it needs to free memory and kills your program. Therefore you should listen for the InputFocus event from the  subsystem and immediately save your program state as applicable if the program loses input focus or is minimized. On mobile devices it is also unsafe to access or create any graphics resources while the window is minimized (as the graphics context may be destroyed during this time); doing so can crash the program. It is recommended to leave the pause-minimized feature on to ensure you do not have to check for this in your update code. Note that on iOS calling  is a no-op as there is no officially sanctioned way to manually exit your program. On Android it will cause the activity to manually exit.

Application Framework

The T:Urho.Application class provides a minimal framework to run your game with a main loop and a handful of methods that you can override to prepare and run your game.
 Constructs a new instance of Urho.Engine which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Engine, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Engine linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Get the timestep for the next frame and sleep for frame limiting if necessary. Return whether to exit automatically on exit request. Or Set whether to exit automatically on exit request (window close button.) Create the console and return it. May return null if engine configuration does not allow creation (headless mode.) Create the debug hud. Dump information of all memory allocations to the log. Supported in MSVC debug mode only. Dump profiling information to the log. Dump information of all resources to the log. Return whether exit has been requested. Return whether the engine has been created in headless mode. Return whether engine has been initialized. Return the maximum frames per second. Or Set maximum frames per second. The engine will sleep if FPS is higher than this. Return the maximum frames per second when the application does not have input focus. Or Set maximum frames per second when the application does not have input focus. Return the minimum frames per second. Or Set minimum frames per second. If FPS goes lower than this, time will appear to slow down. Get timestep of the next frame. Updated by ApplyFrameLimit(). Or Override timestep of the next frame. Should be called in between RunFrame() calls. Return whether to pause update events and audio when minimized. Or Set whether to pause update events and audio when minimized. Invoked after the  event has been raised. This can be used to implement logic that requires the rendering views to be up-to-date, for example to do accurate raycasts.  Scenes may not be modified at this point; especially scene objects may not be deleted or crashes may occur. Event raised after the  event is from the  method. The  subsystem updates its logic here. Render after frame update. Event raised after  event in preparation for rendering.  updates its viewports here to prepare for rendering, and the  generates render commands necessary to render the user interface. Run one frame. The handler to invoke when this event is raised. Subscribes to the PostRenderUpdate event raised by the Engine. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the PostUpdate event raised by the Engine. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the RenderUpdate event raised by the Engine. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Return how many frames to average for timestep smoothing. Or Set how many frames to average for timestep smoothing. Default is 2. 1 disables smoothing. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Application-wide logic update event, the first called from the  method. By default each update-enabled  reacts to this and triggers the scene update Sends the frame update events. This method is usually invoked from the  method and it rasises the , ,  and  events in that order. Helper functions to return elements from a VariantMap Tracking structure for event receivers. Begin event send. When receivers are removed during send, group has to be cleaned up afterward. End event send. Clean up if necessary. Event arguments for the Input's ExitRequested event Billboard camera facing modes. If this mode is used, the billboard will rotate facing camera with direction as axis, so it will create pseudo 3D effect. Fill mode. Shadow map focusing parameters Auto-size (reduce resolution when far away) flag. Focus flag. Minimum view size. Non-uniform focusing flag. Focus quantization. Font file type. Font hinting level (only used for FreeType fonts) Font file type. Event arguments for the Time's FrameEnded event Event arguments for the Time's FrameStarted event Convex constructed of 6 planes. Update the planes. Called internally. Frustum planes. Defines one or more vertex buffers, an index buffer and a draw range. Constructs a new instance of Urho.Geometry which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Geometry, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Geometry linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return buffers' combined hash value for state sorting. Draw. Return whether has empty draw range. Return ray hit distance or infinity if no hit. Requires raw data to be set. Optionally return hit normal and hit uv coordinates at intersect point. Return vertex buffer by index. Return the index buffer. Or Set the index buffer. Return number of indices. Return start index. Return whether or not the ray is inside geometry. Return LOD distance. Or Set the LOD distance. Return number of vertex buffers. Return primitive type. Set the draw range. Set the draw range. Set number of vertex buffer. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return all vertex buffers. Return number of used vertices. Return first used vertex. %Geometry type. Event arguments for the Input's GestureInput event Event arguments for the Input's GestureRecorded event Triangle mesh geometry data. Base class for GPU resources. Clear the data lost flag. Return whether data is lost due to context loss. Return the object pointer. Applicable only on Direct3D. Return the object name. Applicable only on OpenGL. Return the graphics subsystem associated with this GPU object. Return whether has pending data assigned while graphics context was lost. Mark the GPU resource destroyed on graphics context destruction. Recreate the GPU resource and restore data if applicable. Unconditionally release the GPU resource. Graphics subsystem. Manages the application window, rendering state and GPU resources. Graphics implements the low-level functionality: Creating the window and the rendering context. Setting the screen mode. Keeping track of GPU resources. Keeping track of rendering context state (current rendertarget, vertex and index buffers, textures, shaders and renderstates) Loading shaders. Performing primitive rendering operations. Handling disconnected GPUs. The screen resolution, fullscreen or windowed mode, vertical sync and hardware multisampling level are all set at once by calling .  When setting the initial screen mode, Graphics does a few checks: For Direct3D9, shader model 3.0 support is checked. For OpenGL, version 3.2 support is checked for first and used if available. As a fallback, version 2.0 with EXT_framebuffer_object, EXT_packed_depth_stencil and EXT_texture_filter_anisotropic extensions is checked for. The ARB_instanced_arrays extension is also checked for but not required; it will enable hardware instancing support when present. Are hardware shadow maps supported? Both AMD & NVIDIA style shadow maps can be used. If neither are available, no shadows will be rendered. Are light pre-pass and deferred rendering modes supported? These require sufficient multiple rendertarget support, and R32F texture format support. The actual rendering of 3D views is driven by the  class.

Dealing with GPU Disconnetion

On Direct3D9 and Android OpenGL ES 2.0 it is possible to lose the rendering context (and therefore GPU resources) due to the application window being minimized or sent to the background.  

Additionally, to work around possible GPU driver bugs the desktop OpenGL context will be voluntarily destroyed and recreated when changing screen mode or toggling between fullscreen and windowed. Therefore, on all graphics APIs one must be prepared for losing GPU resources.

Textures that have been loaded from a file, as well as vertex & index buffers that have shadowing enabled will restore their contents automatically, the rest have to be restored manually. On Direct3D9 non-dynamic (managed) textures and buffers will never be lost, as the runtime automatically backs them up to system memory.

Shader Parameters

You can set parameters for the shaders by calling one of the M:Urho.Graphics.SetShaderParameter methods in this class.  In addition to controlling the shader parameters for your own shaders, you can use this to set the parameters for the various built-in shaders.

Some of the parameters that you can set for the built-in shaders are:

VSP
  • AmbientStartColor
  • AmbientEndColor
  • BillboardRot
  • CameraPos
  • ClipPlane
  • NearClip
  • FarClip
  • DepthMode
  • DeltaTime
  • ElapsedTime
  • FrustumSize
  • GBufferOffsets
  • LightDir
  • LightPos
  • NormalOffsetScale
  • Model
  • View
  • ViewInv
  • ViewProj
  • UOffset
  • VOffset
  • Zone
  • LightMatrices
  • SkinMatrices
  • VertexLights
PSP

  • AmbientColor
  • CameraPosPS
  • DeltaTimePS
  • DepthReconstruct
  • ElapsedTimePS
  • FogColor
  • FogParams
  • GBufferInvSize
  • LightColor
  • LightDirPS
  • LightPosPS
  • NormalOffsetScalePS
  • MatDiffColor
  • MatEmissiveColor
  • MatEnvMapColor
  • MatSpecColor
  • NearClipPS
  • FarClipPS
  • ShadowCubeAdjust
  • ShadowDepthFade
  • ShadowIntensity
  • ShadowMapInvSize
  • ShadowSplits
  • LightMatricesPS
  • VSMShadowParams
  • Roughness
  • Metallic

    •      Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Graphics, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return the API-specific alpha texture format. Return whether alpha-to-coverage is enabled. Return graphics API name. Begin dumping shader variation names to an XML file for precaching. Begin frame rendering. Return true if device available and can render. Return blending mode. Or Set blending mode. Return whether window is borderless. Clean up too large scratch buffers. Clear any or all of rendertarget, depth buffer and stencil buffer. Clear remembered shader parameter source group. Clear remembered shader parameter sources. Clear remembered transform shader parameter sources. Close the window. Return whether color write is enabled. Or Set color write on/off. Return hardware culling mode. Or Set hardware culling mode. Returns the index of the display containing the center of the window on success or a negative error code on failure. Return or Set default texture anisotropy level. Called by Renderer before rendering. Return default texture filtering mode. Or Set default texture filtering mode. Return whether deferred rendering is supported. Return depth constant bias. Return depth slope scaled bias. Return depth-stencil surface. Or Set depth-stencil surface. Return the API-specific hardware depth-stencil texture format. Return depth compare mode. Or Set depth compare. Return whether depth write is enabled. Or Set depth write on/off. Return whether device is lost, and can not yet render. Controls whether the rendering output is dithered.  Default on OpenGL. No effect on Direct3D. Draw non-indexed geometry. Draw indexed geometry. Draw indexed geometry with vertex index offset. Draw indexed, instanced geometry. Draw indexed, instanced geometry with vertex index offset. Return dummy color texture format for shadow maps. 0 if not needed, may be nonzero on OS X to work around an Intel driver issue. End dumping shader variations names. End frame rendering and swap buffers. Return OS-specific external window handle. Null if not in use. Or Set external window handle. Only effective before setting the initial screen mode. On Windows it is necessary to set up OpenGL pixel format manually for the window. Return polygon fill mode. Or Set polygon fill mode. Return the API-specific single channel 16-bit float texture format. Return the API-specific single channel 32-bit float texture format. Return whether the GPU command buffer is flushed each frame. Not yet implemented on OpenGL. Or Set whether to flush the GPU command buffer to prevent multiple frames being queued and uneven frame timesteps. Not yet implemented on OpenGL. Free a CPU-side scratch buffer. Return whether window is fullscreen. Return the API-specific texture format from a textual description, for example "rgb". Return hardware format for a compressed image format, or 0 if unsupported. Return rendertarget by index. Return a shader variation by name and defines. Return texture by texture unit index. Return texture unit index by name. Return texture unit name by index. Return current vertex buffer by index. Return whether shadow map depth compare is done in hardware. Always true on OpenGL. Check whether a shader parameter exists on the currently set shaders. Check whether the current shader program uses a texture unit. Return window height. Return whether window is high DPI. Return 24-bit shadow map depth texture format, or 0 if not supported. Return graphics implementation, which holds the actual API-specific resources. Return index buffer. Or Set index buffer. Return whether rendering initialized. Return whether hardware instancing is supported. Return whether light pre-pass rendering is supported. Get or Set line antialiasing on/off. Return the API-specific linear depth texture format. Return the API-specific luminance alpha texture format. Return the API-specific luminance texture format. Return maximum number of supported bones for skinning. Maximize the Window. Returns true if window is maximized or runs in full screen mode. Minimize the Window. Return the current monitor index. Effective on in fullscreen Return the number of currently connected monitors. Return multisample mode (1 = no multisampling.) Check whether a shader parameter group needs update. Does not actually check whether parameters exist in the shaders. Return number of batches drawn this frame. Return number of primitives drawn this frame. Window was moved through user interaction.  Called by Input subsystem. React to window resize. Return allowed screen orientations. Or Set allowed screen orientations as a space-separated list of "LandscapeLeft", "LandscapeRight", "Portrait" and "PortraitUpsideDown". Affects currently only iOS platform. Return pixel shader. Return UV offset required for pixel perfect rendering. Precache shader variations from an XML file generated with BeginDumpShaders(). Raises window if it was minimized. Return the API-specific readable hardware depth format, or 0 if not supported. Return whether a readable hardware depth format is available. Return refresh rate when using vsync in fullscreen Return rendertarget width and height. Reserve a CPU-side scratch buffer. Reset depth-stencil surface. Reset specific rendertarget. Reset all rendertargets, depth-stencil surface and viewport. Return whether window is resizable. Resolve a multisampled cube texture on itself. Resolve a multisampled texture on itself. Resolve multisampled backbuffer to a texture rendertarget. The texture's size should match the viewport size. Return the API-specific RG 16-bit texture format. Return the API-specific RGBA 16-bit texture format. Return the API-specific RGBA 16-bit float texture format. Return the API-specific RGBA 32-bit float texture format. Return the API-specific RGBA texture format. Return the API-specific RGB texture format. Return the API-specific RG 16-bit float texture format. Return the API-specific RG 32-bit float texture format. Return scissor rectangle coordinates. Return whether scissor test is enabled. Return pointer to SDL window. Set blending and alpha-to-coverage modes. Alpha-to-coverage is not supported on Direct3D9. Set a custom clipping plane. The plane is specified in world space, but is dependent on the view and projection matrices. Set depth bias. Set depth-stencil surface. Set screen resolution only. Return true if successful. Set rendertarget. Set rendertarget. Set scissor test. Hashcode for one of the parameters to set (see  for a list of built-in shader parameter names) Boolean value to set Set shader boolean constant. Set shader integer constant. Hashcode for one of the parameters to set (see  for a list of built-in shader parameter names) Float value to set Set shader float constant. Hashcode for one of the parameters to set (see  for a list of built-in shader parameter names) Color value to set. Set shader color constant. Hashcode for one of the parameters to set (see  for a list of built-in shader parameter names) Matrix value to set. Set shader matrix constant. Hashcode for one of the parameters to set (see  for a list of built-in shader parameter names) Matrix value to set. Set shader matrix constant. Hashcode for one of the parameters to set (see  for a list of built-in shader parameter names) Vector value to set Set shader 2D vector constant. Hashcode for one of the parameters to set (see  for a list of built-in shader parameter names) Vector3 value to set. Set shader 3D vector constant. Hashcode for one of the parameters to set (see  for a list of built-in shader parameter names) Vector4 value to set. Set shader 4D vector constant. Hashcode for one of the parameters to set (see  for a list of built-in shader parameter names) Pointer to an array of floats to set Number of elements in the array. Set shader float constants. Set shaders. Set stencil test. Internal use. Set texture. Dirty texture parameters of all textures (when global settings change.) Set vertex buffer. Set viewport. Set window icon. Set window position. Set window position. Return or Set shader cache directory, Direct3D only. This can either be an absolute path or a path within the resource system. Return shadow map depth texture format, or 0 if not supported. Return window size in pixels. Return whether the main window is using sRGB conversion on write. Or Set whether the main window uses sRGB conversion on write. Return whether sRGB conversion on texture sampling is supported. Return whether sRGB conversion on rendertarget writing is supported. Return stencil compare bitmask. Return stencil operation to do if stencil test fails. Return stencil operation to do if stencil test passes. Return stencil reference value. Return whether stencil test is enabled. Return stencil compare mode. Return stencil write bitmask. Return stencil operation to do if depth compare fails. Take a screenshot. Return true if successful. Toggle between full screen and windowed mode. Return true if successful. Return whether triple buffering is enabled. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return whether a custom clipping plane is in use. Return vertex shader. Return the viewport coordinates. Return whether vertical sync is on. Return window width. Return window position. Return window title. Or Set window title. Heightfield geometry data. Hardware index buffer. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.IndexBuffer, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. The context that this object will be attached to. Constructs a new instance of Urho.IndexBuffer linked to a specific . Return whether is dynamic. Return number of indices. Return index size. Lock the buffer for write-only editing. Return data pointer if successful. Optionally discard data outside the range. Return whether is currently locked. Mark the buffer destroyed on graphics context destruction. May be a no-op depending on the API. Release the buffer. Set all data in the buffer. Set a data range in the buffer. Optionally discard data outside the range. Set buffer size and dynamic mode. Previous data will be lost. Return CPU memory shadow data. Return whether CPU memory shadowing is enabled. Shadowing is forced on if the graphics subsystem does not exist Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Unlock the buffer and apply changes to the GPU buffer. Input subsystem. Converts operating system window messages to input state and events. The Input subsystem provides keyboard, mouse, joystick and touch input both via a polled interface and events. This subsystem is also used for querying whether the application window has input focus or is minimized. The subsystem is always instantiated, even in headless mode, but is active only once the application window has been created. Once active, the subsystem takes over the operating system mouse cursor. It will be hidden by default, so the  should be used to render a software cursor if necessary. For editor-like applications the operating system cursor can be made visible by calling . You can subscribe to these events by using one of the SubscribeToXxx methods in UrhoObject: MouseButtonUp: a mouse button was released. MouseButtonDown: a mouse button was pressed. MouseMove: the mouse moved. MouseWheel: the mouse wheel moved. KeyUp: a key was released. KeyDown: a key was pressed. TextInput: a string of translated text input in UTF8 format. May contain a single character or several. JoystickConnected: a joystick was plugged in. JoystickDisconnected: a joystick was disconnected. JoystickButtonDown: a joystick button was pressed. JoystickButtonUp: a joystick button was released. JoystickAxisMove: a joystick axis was moved. JoystickHatMove: a joystick POV hat was moved. TouchBegin: a finger touched the screen. TouchEnd: a finger was lifted from the screen. TouchMove: a finger moved on the screen. GestureRecorded : recording a touch gesture is complete. GestureInput : a touch gesture was recognized. MultiGesture : a multi-finger pinch/rotation touch gesture is underway. DropFile : a file was drag-dropped on the application window. InputFocus : application input focus or window minimization state changed. MouseVisibleChanged : the visibility of the operating system mouse cursor was changed. ExitRequested : application exit was requested (eg. with the window close button.)

    Keyboard and Mouse Input

     Key events include both the symbolic keycode ("Key") that depends on the keyboard layout, the layout- and operating system-independent SDL scancode ("Scancode"), and the true operating system-specific raw keycode ("Raw"). The input polling API differentiates between the initiation of a key/mouse button press, and holding the key or button down.   and  return true only for one frame (the initiation) while  and  return true as long as the key or button is held down. To check whether keys are down or pressed by scancode, use  and . Functions also exist for converting keycodes to scancodes or vice versa, or getting key names. See for example  and . Mouse motion since the last frame can be accessed with . The cursor position within the window can be queried with .

    Mouse modes

     The operating system mouse cursor can be used in four modes which can be switched with : Absolute: is the default behaviour, allowing the toggling of operating system cursor visibility and allowing the cursor to escape the window when visible. When the operating system cursor is invisible in absolute mouse mode, the mouse is confined to the window. If the operating system and UI cursors are both invisible, interaction with the user interface will be limited (for example, drag move and drag end events will not trigger).    Setting this value to Absolute will call SetMouseGrabbed(false). Relative: sets the operating system cursor to invisible and confines the cursor to the window. The operating system cursor cannot be set to be visible in this mode via SetMouseVisible(), however changes are tracked and will be restored when another mouse mode is set. When the virtual cursor is also invisible, UI interaction will still function as normal (eg: drag events will trigger). Setting this will call SetMouseGrabbed(true). Wrap: grabs the mouse from the operating system and confines the operating system cursor to the window, wrapping the cursor when it is near the edges. Setting this will call SetMouseGrabbed(true). Free: does not grab/confine the mouse cursor even when it is hidden. This can be used for cases where the cursor should render using the operating system outside the window, and perform custom rendering (with SetMouseVisible(false)) inside.

    Joystick input

     Plugged in joysticks will begin sending input events automatically. Each joystick will be assigned a joystick ID which will be used in subsequent joystick events, as well as for retrieving the joystick state. Use  to retrieve the joystick state by ID. In case you do not have the ID, you can also use  which uses a zero-based index; see  for the number of currently connected joysticks. The ID, as well as the joystick name, can be looked up from the joystick state. If the joystick model is recognized by SDL as a game controller the buttons and axes mappings utilize known constants such as CONTROLLER_BUTTON_A or CONTROLLER_AXIS_LEFTX without having to guess them. Use  to distinguish between a game controller and an unrecognized joystick. On platforms that support the accelerometer, it will appear as a "virtual" joystick.

    Touch input

     On platforms where touch input is available, touch begin/end/move events will be sent, as well as multi-gesture events with pinch/rotation delta values when more than one finger is pressed down. The current finger touches can also be accessed via a polling API:  and  Touch gestures can be recorded using SDL's inbuilt $1 gesture recognition system. Use  to start recording. The following finger movements will be recorded until the finger is lifted, at which point the recording ends and the GestureRecorded event is sent with the hash ID of the new gesture. The current in-memory gesture(s) can be saved or loaded as binary data. Whenever a recognized gesture is entered by the user, the GestureInput event will be sent. In addition to the ID of the best matched gesture, it contains the center position and an error metric (lower = better) to help filter out false gestures. Note that all recorded (whether saved or not) and loaded gestures are held in-memory. Two additional functions are available to clear them:  to selectively clear a gesture by its ID and  to clear them all. Touch input can also emulate a virtual joystick by displaying on-screen buttons. See the function . Touch emulation can be used to test mobile applications on a desktop machine without a touch screen. See . When touch emulation is enabled, actual mouse events are no longer sent and the operating system mouse cursor is forced visible. The left mouse button acts as a moving finger, while the rest of the mouse buttons act as stationary fingers for multi-finger gestures. For example pressing down both left and right mouse buttons, then dragging the mouse with the buttons still pressed would emulate a two-finger pinch zoom-in gesture.

    Platform-specific details

     On platforms that support it (such as Android) an on-screen virtual keyboard can be shown or hidden. When shown, keypresses from the virtual keyboard will be sent as text input events just as if typed from an actual keyboard. Show or hide it by calling etScreenKeyboardVisible. The  subsystem can also automatically show the virtual keyboard when a line editing element is focused, and hide it when defocused. This behavior can be controlled by calling SetUseScreenKeyboard. On Windows the user must first touch the screen once before touch input is activated. Trying to record or load touch gestures will fail before that.     Constructs a new instance of Urho.Input which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Input, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Input linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Center the mouse position. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Controls whether input is enabled or disabled. The current input enabled status, defaults to . The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return joystick state by ID, or null if does not exist. Return joystick state by index, or null if does not exist. 0 = first connected joystick. Check if a key is held down. Return keycode from key name. Return keycode from scancode. Return name of key from keycode. Check if a key has been pressed on this frame. Check if a mouse button is held down. Check if a mouse button has been pressed on this frame. Check if a qualifier key is held down. Check if a qualifier key has been pressed on this frame. Check if a key is held down by scancode. Return scancode from keycode. Return scancode from key name. Return name of key from scancode. Check if a key has been pressed on this frame by scancode. Return active finger touch by index. Return whether application window has input focus. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return input coordinate scaling. Should return non-unity on High DPI display. Return whether a virtual joystick is visible. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return whether application window is minimized. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return whether the mouse is currently being grabbed by an operation. Return whether the mouse is locked to the window Return the mouse mode. Or Set the mouse mode.  See the  enumeration for detais on the meaning of the MouseMode. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return mouse movement since last frame. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return mouse wheel movement since last frame. Return horizontal mouse movement since last frame. Return vertical mouse movement since last frame. Return mouse position within window. Should only be used with a visible mouse cursor. Return whether the operating system mouse cursor is visible. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return number of connected joysticks. Return number of active finger touches. Return the currently held down qualifiers. Begin recording a touch gesture. Return true if successful. The E_GESTURERECORDED event (which contains the ID for the new gesture) will be sent when recording finishes. Remove all in-memory gestures. Remove an in-memory gesture by ID. Return true if was found. Remove screen joystick by instance ID. Return true if successful. This method should only be called in main thread. Reset the mouse grabbed to the last unsuppressed SetMouseGrabbed call Reset the last mouse mode that wasn't suppressed in SetMouseMode Reset last mouse visibility that was not suppressed in SetMouseVisible. Return whether on-screen keyboard is supported. Return whether on-screen keyboard is being shown; On platform that support it, setting this property displays the on-screen keyboard. Set whether the operating system mouse cursor is visible. When not visible (default), is kept centered to prevent leaving the window. Mouse visibility event can be suppressed-- this also recalls any unsuppressed SetMouseVisible which can be returned by ResetMouseVisible(). Set whether the virtual joystick is visible. The handler to invoke when this event is raised. Subscribes to the DropFile event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ExitRequested event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the GestureInput event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the GestureRecorded event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the InputFocus event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the JoystickAxisMove event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the JoystickButtonDown event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the JoystickButtonUp event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the JoystickConnected event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the JoystickDisconnected event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the JoystickHatMove event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the KeyDown event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the KeyUp event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the MouseButtonDown event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the MouseButtonUp event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the MouseModeChanged event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the MouseMoved event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the MouseVisibleChanged event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the MouseWheel event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the MultiGesture event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the TextInput event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the TouchBegin event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the TouchEnd event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the TouchMove event raised by the Input. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return whether fullscreen toggle is enabled. Or Set whether ALT-ENTER fullscreen toggle is enabled. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return whether touch emulation is enabled. Or Set touch emulation by mouse. Only available on desktop platforms. When enabled, actual mouse events are no longer sent and the mouse cursor is forced visible. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Poll for window messages. Called by HandleBeginFrame(). Event arguments for the Input's InputFocus event Event arguments for the Serializable's InterceptNetworkUpdate event Interpolation method. Bezier interpolation. Intersection test result. Rectangle with Int32 values. Represents a 2D vector using two single-precision inting-point numbers. The IntVector2 structure is suitable for interoperation with unmanaged code requiring two consecutive ints. The IntVector2 to copy components from. Constructs a new IntVector2 from the given IntVector2. The IntVector2 to copy components from. Constructs a new IntVector2 from the given Vector2. The x coordinate of the net IntVector2. The y coordinate of the net IntVector2. Constructs a new IntVector2. Right operand. This parameter is only read from. Add the Vector passed as parameter to this instance. Right operand. This parameter is only read from. Add the Vector passed as parameter to this instance. Left operand. Right operand. Adds two vectors. Result of operation. Left operand. Right operand. Result of operation. Adds two vectors. First input Vector Second input Vector Third input Vector First Barycentric Coordinate Second Barycentric Coordinate Interpolate 3 Vectors using Barycentric coordinates a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise First input Vector. Second input Vector. Third input Vector. First Barycentric Coordinate. Second Barycentric Coordinate. Output Vector. a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise Interpolate 3 Vectors using Barycentric coordinates Input vector Minimum vector Maximum vector Clamp a vector to the given minimum and maximum vectors The clamped vector Input vector Minimum vector Maximum vector The clamped vector Clamp a vector to the given minimum and maximum vectors First operand Second operand Calculate the component-wise maximum of two vectors The component-wise maximum First operand Second operand The component-wise maximum Calculate the component-wise maximum of two vectors First operand Second operand Calculate the component-wise minimum of two vectors The component-wise minimum First operand Second operand The component-wise minimum Calculate the component-wise minimum of two vectors Scalar operand. Divide this instance by a scalar. Left operand. Right operand. Divides a vector by a scalar. Result of the operation. Left operand. Right operand. Divides a vector by the components of a vector (scale). Result of the operation. Left operand. Right operand. Result of the operation. Divides a vector by a scalar. Left operand. Right operand. Result of the operation. Divide a vector by the components of a vector (scale). First operand Second operand Calculate the dot (scalar) product of two vectors The dot product of the two inputs First operand Second operand The dot product of the two inputs Calculate the dot (scalar) product of two vectors The object to compare to. Indicates whether this instance and a specified object are equal. True if the instances are equal; false otherwise. A vector to compare with this vector. Indicates whether the current vector is equal to another vector. true if the current vector is equal to the vector parameter; otherwise, false. Returns the hashcode for this instance. A System.Int32 containing the unique hashcode for this instance. Determines if the vector is zero. True if the X and Y properties are zero, false otherwise. Gets the length (magnitude) of the vector. Gets an approximation of the vector length (magnitude). This property uses an approximation of the square root function to calculate vector magnitude, with an upper error bound of 0.001. Gets the square of the vector length (magnitude). This property avoids the costly square root operation required by the Length property. This makes it more suitable for comparisons. First input vector Second input vector The blend factor. a when blend=0, b when blend=1. Returns a new Vector that is the linear blend of the 2 given Vectors a when blend=0, b when blend=1, and a linear combination otherwise First input vector Second input vector The blend factor. a when blend=0, b when blend=1. a when blend=0, b when blend=1, and a linear combination otherwise Returns a new Vector that is the linear blend of the 2 given Vectors Left operand Right operand Returns the Vector3 with the minimum magnitude The minimum Vector3 Left operand Right operand Returns the Vector3 with the minimum magnitude The minimum Vector3 Scalar operand. Multiply this instance by a scalar. Left operand. Right operand. Multiplies a vector by a scalar. Result of the operation. Left operand. Right operand. Multiplies a vector by the components a vector (scale). Result of the operation. Left operand. Right operand. Result of the operation. Multiplies a vector by a scalar. Left operand. Right operand. Result of the operation. Multiplies a vector by the components of a vector (scale). Scales the IntVector2 to unit length. The input vector Scale a vector to unit length The normalized vector The input vector The normalized vector Scale a vector to unit length Scales the IntVector2 to approximately unit length. The input vector Scale a vector to approximately unit length The normalized vector The input vector The normalized vector Scale a vector to approximately unit length Defines an instance with all components set to 1. Left operand. Right operand. Adds the specified instances. Result of addition. Left operand Right operand Divides the specified instance by a scalar. Result of the division. Left operand. Right operand. Compares the specified instances for equality. True if both instances are equal; false otherwise. Left operand. Right operand. Compares the specified instances for inequality. True if both instances are not equal; false otherwise. Left operand. Right operand. Multiplies the specified instance by a scalar. Result of multiplication. Left operand. Right operand. Multiplies the specified instance by a scalar. Result of multiplication. Left operand. Right operand. Subtracts the specified instances. Result of subtraction. Operand. Negates the specified instance. Result of negation. Gets the perpendicular vector on the left side of this vector. Gets the perpendicular vector on the right side of this vector. The scaling of the individual components. Scales this instance by the given parameter. The scaling of the individual components. Scales this instance by the given parameter. The scale of the X component. The scale of the Y component. Scales the current IntVector2 by the given amounts. Defines the size of the IntVector2 struct in bytes. Right operand. This parameter is only read from. Subtract the Vector passed as parameter from this instance. Right operand. This parameter is only read from. Subtract the Vector passed as parameter from this instance. First operand Second operand Subtract one Vector from another Result of subtraction First operand Second operand Result of subtraction Subtract one Vector from another Returns a System.String that represents the current IntVector2. Defines a unit-length IntVector2 that points towards the X-axis. Defines a unit-length IntVector2 that points towards the Y-axis. The X component of the IntVector2. The Y component of the IntVector2. Defines a zero-length IntVector2. Event arguments for the Input's JoystickAxisMove event Event arguments for the Input's JoystickButtonDown event Event arguments for the Input's JoystickButtonUp event Event arguments for the Input's JoystickConnected event Event arguments for the Input's JoystickDisconnected event Event arguments for the Input's JoystickHatMove event Enumeration with the various key codes. Keypad 0 key. Keypad 1 key. Keypad 2 key. Keypad 3 key. Keypad 4 key. Keypad 5 key. Keypad 6 key. Keypad 7 key. Keypad 8 key. Keypad 9 key. Keypad division key. Keypad enter key. Keypad minus key. Keypad multiply key. Keypad period key Keypad plus key. Key 0 Key 1 Key 2 Key 3 Key 4 Key 5 Key 6 Key 7 Key 8 Key 9 Pagedown key Pageup key Pause key Printscreen key Spacebar key Event arguments for the Input's KeyDown event Event arguments for the Input's KeyUp event Hardcoded legacy vertex elements. Light component. Constructs a new instance of Urho.Light which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Light, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Light linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return spotlight aspect ratio. Or Set spotlight aspect ratio. Return brightness multiplier. Or Set light brightness multiplier. Both the color and specular intensity are multiplied with this to get final values for rendering. Return color. Or Set color. Return the color value of the temperature in Kelvin. Visualize the component as debug geometry. Return effective color, multiplied by brightness. Do not multiply the alpha so that can compare against the default black color to detect a light with no effect. Return effective specular intensity, multiplied by absolute value of brightness. Return fade start distance. Or Set fade out start distance. Return spotlight field of view. Or Set spotlight field of view. Return spotlight frustum. Return a divisor value based on intensity for calculating the sort value. View space. Return spotlight frustum in the specified view space. Return spotlight frustum in the specified view space. Return area tube light length. Works only with PBR shaders. Or Set tube area light length. Works only with PBR shaders. Return light queue. Called by View. Or Set light queue used for this light. Called by View. Return light type. Or Set light type. Return whether light has negative (darkening) color. Return number of shadow map cascade splits for a directional light, considering also graphics API limitations. Return vertex lighting mode. Or Set vertex lighting mode. Return area light mode radius. Works only with PBR shaders. Or Set area light radius. Greater than zero activates area light mode. Works only with PBR shaders. Return range attenuation texture. Or Set range attenuation texture. Return ramp texture attribute. Return range. Or Set range. Register object factory. Drawable must be registered first. Set sort value based on intensity and view distance. Set sort value based on overall intensity over a bounding box. Return shadow depth bias parameters. Or Set shadow depth bias parameters. Return directional light cascaded shadow parameters. Or Set directional light cascaded shadow parameters. Return shadow fade start distance. Or Set shadow fade out start distance. Only has effect if shadow distance is also non-zero. Controsl the shadow map focusing parameters Return shadow intensity. Or Set shadow intensity between 0.0 - 1.0. 0.0 (the default) gives fully dark shadows. Return maximum shadow extrusion distance for directional lights. Or Set maximum shadow extrusion for directional lights. The actual extrusion will be the smaller of this and camera far clip. Default 1000. Return shadow camera near/far clip distance ratio. Or Set shadow camera near/far clip distance ratio. Return shadow resolution. Or Set shadow resolution between 0.25 - 1.0. Determines the shadow map to use. Return spotlight attenuation texture. Or Set spotlight attenuation texture. Return shape texture attribute. Return specular intensity. Or Set specular intensity. Zero disables specular calculations. Return the temperature of the light in Kelvin. Or Set temperature of the light in Kelvin. Modulates the light color when "use physical values" is enabled. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return if light uses temperature and brightness in lumens. Or Set use physical light values. Light pixel shader variations. Light types. Directional light. Point light. Spot light. Light vertex shader variations. Asynchronous scene loading mode. Vertex/index buffer lock state. Helper base class for user-defined game logic components that hooks up to update events and forwards them to virtual functions similar to ScriptInstance class. Constructs a new instance of Urho.LogicComponent which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.LogicComponent, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.LogicComponent linked to a specific . Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Describes how to render 3D geometries. On the disk, they are XML data. Default and example materials exist in the bin/CoreData/Materials & bin/Data/Materials subdirectories, and techniques exist in the bin/CoreData/Techniques subdirectory. A material defines the textures, shader parameters, the culling, fill mode to use, and refers to one or several techniques. A technique defines the actual rendering passes, the shaders to use in each, and all other rendering states such as depth test, depth write, and blending. A material definition looks like this ]]> Several techniques can be defined for different quality levels and LOD distances. Technique quality levels are specified from 0 (low) to 2 (high). When rendering, the highest available technique that does not exceed the  material quality setting will be chosen, see . It is also possible for a technique to require Shader Model 3, in this case it will be skipped on SM2 hardware. The techniques for different LOD levels and quality settings must appear in a specific order: Material shader parameters can be floats or vectors up to 4 components, or matrices. Default culling mode is counterclockwise. The shadowcull element specifies the culling mode to use in the shadow pass. Note that material's depth bias settings do not apply in the shadow pass; during shadow rendering the light's depth bias is used instead.

    Material Textures

     Diffuse maps specify the surface color in the RGB channels. Optionally they can use the alpha channel for blending and alpha testing. They should preferably be compressed to DXT1 (no alpha or 1-bit alpha) or DXT5 (smooth alpha) format. Normal maps encode the tangent-space surface normal for normal mapping. There are two options for storing normals, which require choosing the correct material technique, as the pixel shader is different in each case: Store as RGB. In this case use the DiffNormal techniques. This is the default used by AssetImporter, to ensure no conversion of normal textures needs to happen. Store as xGxR, ie. Y-component in the green channel, and X-component in the alpha. In this case use the DiffNormalPacked techniques: Z will be reconstructed in the pixel shader. This encoding lends itself well to DXT5 compression. To convert normal maps to this format, you can use AMD's The Compressonator utility, see http://developer.amd.com/Resources/archive/ArchivedTools/gpu/compressonator/Pages/default.aspx Make sure the normal map is oriented correctly: an even surface should have the color value R 0.5 G 0.5 B 1.0. Models using a normal-mapped material need to have tangent vectors in their vertex data; the easiest way to ensure this is to use the switch -t (generate tangents) when using either AssetImporter or OgreImporter to import models to Urho3D format. If there are no tangents, the light attenuation on the normal-mapped material will behave in a completely erratic fashion. Specular maps encode the specular surface color as RGB. Note that deferred rendering is only able to use monochromatic specular intensity from the G channel, while forward and light pre-pass rendering use fully colored specular. DXT1 format should suit these textures well. Textures can have an accompanying XML file which specifies load-time parameters, such as addressing, mipmapping, and number of mip levels to skip on each quality level:
    ]]> The sRGB flag controls both whether the texture should be sampled with sRGB to linear conversion, and if used as a rendertarget, pixels should be converted back to sRGB when writing to it. To control whether the backbuffer should use sRGB conversion on write, use the property.

    Material Textures

     Using cube map textures requires an XML file to define the cube map face textures or layout. In this case the XML file is the texture resource name in material scripts or in LoadResource() calls. Individual face textures are defined in the XML like this: (see bin/Data/Textures/Skybox.xml for an example) ]]> Using a single image texture and a layout is used like this: ]]> For the layout definitions, see http://www.cgtextures.com/content.php?action=tutorial&name=cubemaps and http://en.wikibooks.org/wiki/Blender_3D:_Noob_to_Pro/Build_a_skybox Constructs a new instance of Urho.Material which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Material, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Material linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return alpha-to-coverage mode. Or Set alpha-to-coverage mode on all passes. Return last auxiliary view rendered frame number. Clone the material. Return normal culling mode. Or Set culling mode. Return depth bias. Or Set depth bias. Finish resource loading. Always called from the main thread. Return true if successful. Return polygon fill mode. Or Set polygon fill mode. Interacts with the camera's fill mode setting so that the "least filled" mode will be used. Color to be used as a MatDiffColor Creates a material using NoTexture or NoTextureAlpha  with the specified color as a shader parameter "MatDiffColor". Material that contains the image and has been configured with the CoreAssets.Techniques.Diff . This is a shortcut to creating a new mateiral from specified color (lit). If the color has Alpha less than 1.0f, the NoTextureAlpha  will be used, otherwise - NoTexture. Creates a material from a given color. Unlit means the material won't be affected by any lights. Name of an image that can be fetched from the . Creates a material from a 2D Texture. Material that contains the image and has been configured with the CoreAssets.Techniques.Diff . This is a shortcut to creating a new mateiral, setting the texture to TextureUnit.Diffuse on the 2D texture loaded from the cache with the name . Create a material from an image and a normal map using DiffNormal technique. Return pass by technique index and pass name. Return shader parameter animation. Return shader parameter animation speed. Return shader parameter animation wrap mode. Return technique by index. Return texture by unit. Return name for texture unit. Return whether line antialiasing is enabled. Or Set line antialiasing on/off. Has effect only on models that consist of line lists. Mark material for auxiliary view rendering. Return number of techniques. Or Set number of techniques. Return whether should render occlusion. Parse a shader parameter value from a string. Retunrs either a bool, a float, or a 2 to 4-component vector. Set additional pixel shader defines. Separate multiple defines with spaces. Setting defines at the material level causes technique(s) to be cloned as necessary. Register object factory. Reset all shader pointers. Remove shader parameter. Return render order. Or Set 8-bit render order within pass. Default 128. Lower values will render earlier and higher values later, taking precedence over e.g. state and distance sorting. Return the scene associated with the material for shader parameter animation updates. Or Associate the material with a scene to ensure that shader parameter animation happens in sync with scene update, respecting the scene time scale. If no scene is set, the global update events will be used. Set shader parameter. Set shader parameter. Set shader parameter. Set shader parameter. Set shader parameter. Set shader parameter. Set shader parameter. Set shader parameter. Set shader parameter. Set shader parameter. Set shader parameter. Set shader parameter. Set shader parameter animation. Set shader parameter animation speed. Set shader parameter animation wrap mode. Set technique. Set texture. Set texture coordinate transform. Set texture coordinate transform. Return shader parameter hash value. Used as an optimization to avoid setting shader parameters unnecessarily. Return culling mode for shadows. Or Set culling mode for shadows. Name of the resource that will be extracted from the  that contains the image to load. Creates a material Skybox where all six elements of the skybox are set to the specified image. A material which uses a  that has all the side of the cube set to the specified image. The techinque on the resulting cube are set to DiffSkybox and the CullMode is set to None. Name of the resource that will be extracted from the  that contains the image for the positive X side of the cube. Name of the resource that will be extracted from the  that contains the image for the negative X side of the cube. Name of the resource that will be extracted from the  that contains the image for the positive Y side of the cube. Name of the resource that will be extracted from the  that contains the image for the negative Y side of the cube. Name of the resource that will be extracted from the  that contains the image for the positive Z side of the cube. Name of the resource that will be extracted from the  that contains the image for the negative Z side of the cube. Creates a material Skybox where all six elements of the skybox are specified. A material which uses a  that has all the side of the cube set to the specified image. The techinque on the resulting cube are set to DiffSkybox and the CullMode is set to None. Ensure that material techniques are listed in correct order. Return whether should render specular. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Set additional vertex shader defines. Separate multiple defines with spaces. Setting defines at the material level causes technique(s) to be cloned as necessary. Contains common mathematical functions and constants. The n. The k. Calculates the binomial coefficient above . n! / (k! * (n - k)!) Clamp an integer to a range. Clamp a float to a range. An angle in degrees Convert degrees to radians The angle expressed in radians An angle in degrees Convert degrees to radians The angle expressed in radians Degrees to radians const. Defines the value of E as a . The number. Calculates the factorial of a given natural number. n! A number. Returns an approximation of the inverse square root of left number. An approximation of the inverse square root of the specified number, with an upper error bound of 0.001 This is an improved implementation of the the method known as Carmack's inverse square root which is found in the Quake III source code. This implementation comes from http://www.codemaestro.com/reviews/review00000105.html. For the history of this method, see http://www.beyond3d.com/content/articles/8/ A number. Returns an approximation of the inverse square root of left number. An approximation of the inverse square root of the specified number, with an upper error bound of 0.001 This is an improved implementation of the the method known as Carmack's inverse square root which is found in the Quake III source code. This implementation comes from http://www.codemaestro.com/reviews/review00000105.html. For the history of this method, see http://www.beyond3d.com/content/articles/8/ Defines the base-10 logarithm of E. Defines the base-2 logarithm of E. The specified number. Returns the next power of two that is larger than the specified number. The next power of two. The specified number. Returns the next power of two that is larger than the specified number. The next power of two. The specified number. Returns the next power of two that is larger than the specified number. The next power of two. The specified number. Returns the next power of two that is larger than the specified number. The next power of two. Defines the value of Pi as a . Defines the value of Pi divided by two as a . Defines the value of Pi divided by three as a . Definesthe value of Pi divided by four as a . Defines the value of Pi divided by six as a . An angle in radians Convert radians to degrees The angle expressed in degrees An angle in radians Convert radians to degrees The angle expressed in degrees The first value. The second value. Swaps two double values. The first value. The second value. Swaps two float values. Defines the value of Pi multiplied by 3 and divided by two as a . Defines the value of Pi multiplied by two as a . Represents a 3x3 Matrix. The array of floats for the components of the matrix. Constructs left matrix from the given array of float-precision floating-point numbers. Constructs left matrix with the same components as the given matrix. The value for row 0 column 0. The value for row 0 column 1. The value for row 0 column 2. The value for row 1 column 0. The value for row 1 column 1. The value for row 1 column 2. The value for row 2 column 0. The value for row 2 column 1. The value for row 2 column 2. Constructs left matrix with the given values. The matrix to add. Add left matrix to this matrix. The matrix to add. The resulting matrix of the addition. Add left matrix to this matrix. The matrix on the right side of the equation The resulting matrix of the addition. Add left matrix to left matrix. The OpenTK.Matrix3 structure to compare with. Indicates whether the current matrix is equal to another matrix. true if the current matrix is equal to the matrix parameter; otherwise, false. The OpenTK.Matrix3 structure to compare to. Indicates whether the current matrix is equal to another matrix. true if the current matrix is equal to the matrix parameter; otherwise, false. The left-hand operand. The right-hand operand. Indicates whether the current matrix is equal to another matrix. true if the current matrix is equal to the matrix parameter; otherwise, false. The OpenTK.Matrix3 structure to compare with. The limit below which the matrices are considered equal. Indicates whether the current matrix is approximately equal to another matrix. true if the current matrix is approximately equal to the matrix parameter; otherwise, false. The left-hand operand. The right-hand operand. The limit below which the matrices are considered equal. Indicates whether the current matrix is approximately equal to another matrix. true if the current matrix is approximately equal to the matrix parameter; otherwise, false. Returns the hash code for this instance. A 32-bit signed integer that is the hash code for this instance. The identity matrix. The index into the components of the matrix. Gets the component at the index into the matrix. The component at the given index into the matrix. The row of the matrix. The column of the matrix. Gets the component at the given row and column in the matrix. The component at the given row and column in the matrix. Multiply matrix times this matrix. The matrix to multiply. Multiply left martix times this matrix. The resulting matrix of the multiplication. Multiply matrix times this matrix. The matrix to multiply. The resulting matrix of the multiplication. Multiply matrix times this matrix. The matrix on the matrix side of the equation. The resulting matrix of the multiplication. Multiply left matrix times left matrix. The matrix on the right side of the equation The resulting matrix of the multiplication. Multiply left matrix times left matrix. The matrix to convert. Converts the matrix into an IntPtr. An IntPtr for the matrix. The matrix to convert. Converts the matrix into left float*. A float* for the matrix. The matrix to convert. Converts the matrix into an array of floats. An array of floats for the matrix. Row 0, Column 0 Row 0, Column 1 Row 0, Column 2 Row 1, Column 0 Row 1, Column 1 Row 1, Column 2 Row 2, Column 0 Row 2, Column 1 Row 2, Column 2 The matrix to subtract. Subtract left matrix from this matrix. The matrix to subtract. The resulting matrix of the subtraction. Subtract left matrix from this matrix. The matrix on the right side of the equation The resulting matrix of the subtraction. Subtract left matrix from left matrix. Returns the fully qualified type name of this instance. A System.String containing left fully qualified type name. A matrix of all zeros. Represents a 3x4 Matrix. Represents a 4x4 Matrix Top row of the matrix Second row of the matrix Third row of the matrix Bottom row of the matrix Constructs a new instance. First item of the first row of the matrix. Second item of the first row of the matrix. Third item of the first row of the matrix. Fourth item of the first row of the matrix. First item of the second row of the matrix. Second item of the second row of the matrix. Third item of the second row of the matrix. Fourth item of the second row of the matrix. First item of the third row of the matrix. Second item of the third row of the matrix. Third item of the third row of the matrix. First item of the third row of the matrix. Fourth item of the fourth row of the matrix. Second item of the fourth row of the matrix. Third item of the fourth row of the matrix. Fourth item of the fourth row of the matrix. Constructs a new instance. The first column of this matrix The second column of this matrix The third column of this matrix The fourth column of this matrix The axis to rotate about. Angle in radians to rotate counter-clockwise (looking in the direction of the given axis). Build a rotation matrix from the specified axis/angle rotation. A matrix instance. The axis to rotate about. Angle in radians to rotate counter-clockwise (looking in the direction of the given axis). A matrix instance. Build a rotation matrix from the specified axis/angle rotation. The width of the projection volume. The height of the projection volume. The near edge of the projection volume. The far edge of the projection volume. Creates an orthographic projection matrix. The resulting Matrix4 instance. The width of the projection volume. The height of the projection volume. The near edge of the projection volume. The far edge of the projection volume. The resulting Matrix4 instance. Creates an orthographic projection matrix. The left edge of the projection volume. The right edge of the projection volume. The bottom edge of the projection volume. The top edge of the projection volume. The near edge of the projection volume. The far edge of the projection volume. Creates an orthographic projection matrix. The resulting Matrix4 instance. The left edge of the projection volume. The right edge of the projection volume. The bottom edge of the projection volume. The top edge of the projection volume. The near edge of the projection volume. The far edge of the projection volume. The resulting Matrix4 instance. Creates an orthographic projection matrix. Angle of the field of view in the y direction (in radians) Aspect ratio of the view (width / height) Distance to the near clip plane Distance to the far clip plane Creates a perspective projection matrix. A projection matrix that transforms camera space to raster space Thrown under the following conditions: fovy is zero, less than zero or larger than Math.PIaspect is negative or zerozNear is negative or zerozFar is negative or zerozNear is larger than zFar Angle of the field of view in the y direction (in radians) Aspect ratio of the view (width / height) Distance to the near clip plane Distance to the far clip plane A projection matrix that transforms camera space to raster space Creates a perspective projection matrix. Thrown under the following conditions: fovy is zero, less than zero or larger than Math.PIaspect is negative or zerozNear is negative or zerozFar is negative or zerozNear is larger than zFar Left edge of the view frustum Right edge of the view frustum Bottom edge of the view frustum Top edge of the view frustum Distance to the near clip plane Distance to the far clip plane Creates an perspective projection matrix. A projection matrix that transforms camera space to raster space Thrown under the following conditions: zNear is negative or zerozFar is negative or zerozNear is larger than zFar Left edge of the view frustum Right edge of the view frustum Bottom edge of the view frustum Top edge of the view frustum Distance to the near clip plane Distance to the far clip plane A projection matrix that transforms camera space to raster space Creates an perspective projection matrix. Thrown under the following conditions: zNear is negative or zerozFar is negative or zerozNear is larger than zFar The counter-clockwise angle in radians. Builds a rotation matrix for a rotation around the x-axis. The resulting Matrix4 instance. The counter-clockwise angle in radians. The resulting Matrix4 instance. Builds a rotation matrix for a rotation around the x-axis. The counter-clockwise angle in radians. Builds a rotation matrix for a rotation around the y-axis. The resulting Matrix4 instance. The counter-clockwise angle in radians. The resulting Matrix4 instance. Builds a rotation matrix for a rotation around the y-axis. The counter-clockwise angle in radians. Builds a rotation matrix for a rotation around the z-axis. The resulting Matrix4 instance. The counter-clockwise angle in radians. The resulting Matrix4 instance. Builds a rotation matrix for a rotation around the z-axis. The translation vector. Creates a translation matrix. The resulting Matrix4 instance. The translation vector. The resulting Matrix4 instance. Creates a translation matrix. X translation. Y translation. Z translation. Creates a translation matrix. The resulting Matrix4 instance. X translation. Y translation. Z translation. The resulting Matrix4 instance. Creates a translation matrix. The determinant of this matrix The object to compare tresult. Indicates whether this instance and a specified object are equal. True if the instances are equal; false otherwise. An matrix to compare with this matrix. Indicates whether the current matrix is equal to another matrix. true if the current matrix is equal to the matrix parameter; otherwise, false. Left edge of the view frustum Right edge of the view frustum Bottom edge of the view frustum Top edge of the view frustum Distance to the near clip plane Distance to the far clip plane Build a projection matrix A projection matrix that transforms camera space to raster space Returns the hashcode for this instance. A System.Int32 containing the unique hashcode for this instance. The identity matrix Converts this instance into its inverse. The matrix to invert Calculate the inverse of the given matrix The inverse of the given matrix if it has one, or the input if it is singular Thrown if the Matrix4 is singular. Eye (camera) position in world space Target position in world space Up vector in world space (should not be parallel to the camera direction, that is target - eye) Build a world space to camera space matrix A Matrix4 that transforms world space to camera space Eye (camera) position in world space Eye (camera) position in world space Eye (camera) position in world space Target position in world space Target position in world space Target position in world space Up vector in world space (should not be parallel to the camera direction, that is target - eye) Up vector in world space (should not be parallel to the camera direction, that is target - eye) Up vector in world space (should not be parallel to the camera direction, that is target - eye) Build a world space to camera space matrix A Matrix4 that transforms world space to camera space Gets or sets the value at row 1, column 1 of this instance. Gets or sets the value at row 1, column 2 of this instance. Gets or sets the value at row 1, column 3 of this instance. Gets or sets the value at row 1, column 4 of this instance. Gets or sets the value at row 2, column 1 of this instance. Gets or sets the value at row 2, column 2 of this instance. Gets or sets the value at row 2, column 3 of this instance. Gets or sets the value at row 2, column 4 of this instance. Gets or sets the value at row 3, column 1 of this instance. Gets or sets the value at row 3, column 2 of this instance. Gets or sets the value at row 3, column 3 of this instance. Gets or sets the value at row 3, column 4 of this instance. Gets or sets the value at row 4, column 1 of this instance. Gets or sets the value at row 4, column 2 of this instance. Gets or sets the value at row 4, column 3 of this instance. Gets or sets the value at row 4, column 4 of this instance. The left operand of the multiplication. The right operand of the multiplication. Multiplies two instances. A new instance that is the result of the multiplication The left operand of the multiplication. The right operand of the multiplication. A new instance that is the result of the multiplication Multiplies two instances. The first instance. The second instance. Compares two instances for equality. True, if left equals right; false otherwise. The first instance. The second instance. Compares two instances for inequality. True, if left does not equal right; false otherwise. left-hand operand right-hand operand Matrix multiplication A new Matrix44 which holds the result of the multiplication Angle of the field of view in the y direction (in radians) Aspect ratio of the view (width / height) Distance to the near clip plane Distance to the far clip plane Build a projection matrix A projection matrix that transforms camera space to raster space the quaternion Build a rotation matrix from a quaternion A rotation matrix the axis to rotate about angle in radians to rotate counter-clockwise (looking in the direction of the given axis) Build a rotation matrix to rotate about the given axis A rotation matrix angle in radians to rotate counter-clockwise around the x-axis Build a rotation matrix that rotates about the x-axis A rotation matrix angle in radians to rotate counter-clockwise around the y-axis Build a rotation matrix that rotates about the y-axis A rotation matrix angle in radians to rotate counter-clockwise around the z-axis Build a rotation matrix that rotates about the z-axis A rotation matrix Top row of the matrix 2nd row of the matrix 3rd row of the matrix Bottom row of the matrix Single scale factor for x,y and z axes Build a scaling matrix A scaling matrix Scale factors for x,y and z axes Build a scaling matrix A scaling matrix Scale factor for x-axis Scale factor for y-axis Scale factor for z-axis Build a scaling matrix A scaling matrix Returns a System.String that represents the current Matrix44. The translation vector. Builds a translation matrix. A new Matrix4 instance. X translation Y translation Z translation Build a translation matrix with the given translation A Translation matrix Converts this instance into its transpose. The matrix to transpose Calculate the transpose of the given matrix The transpose of the given matrix The matrix to transpose The result of the calculation Calculate the transpose of the given matrix 3D model resource. Constructs a new instance of Urho.Model which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Model, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Model linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return bounding box. Or Set local-space bounding box. Clone the model. The geometry data is deep-copied and can be modified in the clone without affecting the original. Finish resource loading. Always called from the main thread. Return true if successful. Return geometry by index and LOD level. The LOD level is clamped if out of range. Return geometry center by index. Return vertex morph by name. Return vertex morph by index. Return vertex morph by name hash. Return vertex buffer morph range vertex count. Return vertex buffer morph range start. Return number of LOD levels in geometry. Return index buffers. Return number of geometries. Or Set number of geometries. Return number of vertex morphs. Register object factory. Set geometry. Set geometry center. Set number of LOD levels in a geometry. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return vertex buffers. UrhoSharp-specific version of DebugHud. For internal use. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Event arguments for the Input's MouseButtonDown event Event arguments for the Input's MouseButtonUp event Input Mouse Modes. The default behaviour, allowing the toggling of operating system cursor visibility and allowing the cursor to escape the window when visible. When the operating system cursor is invisible in absolute mouse mode, the mouse is confined to the window. If the operating system and UI cursors are both invisible, interaction with the user interface will be limited (for example, drag move and drag end events will not trigger).    Setting this value to Absolute will call SetMouseGrabbed(false). sets the operating system cursor to invisible and confines the cursor to the window. The operating system cursor cannot be set to be visible in this mode via SetMouseVisible(), however changes are tracked and will be restored when another mouse mode is set. When the virtual cursor is also invisible, UI interaction will still function as normal (eg: drag events will trigger). Setting this will call SetMouseGrabbed(true). Grabs the mouse from the operating system and confines the operating system cursor to the window, wrapping the cursor when it is near the edges. Setting this will call SetMouseGrabbed(true). Event arguments for the Input's MouseModeChanged event Event arguments for the Input's MouseMoved event Event arguments for the Input's MouseVisibleChanged event Event arguments for the Input's MouseWheel event Event arguments for the Input's MultiGesture event A flag representing the type of path point- none, the start of a path segment, the end of one, or an off-mesh connection. Scene node that may contain components and child nodes. Nodes are the building block of your application.   Each Node has a 3D transform (position, rotation and scale), a name and an ID and can contain other nodes (child nodes).   Your application starts life with a special kind of node, the Scene node. To bring Nodes to life, you attach one or more components into it (.   Components provide functionality from giving a node a visual representation, to emitting sound, to emitting light and many more. These are created either with their constructors and then by attaching them using the  method or by calling the  method which can do both operations in one call. Here are some common scenarios, creating a  a  and a . (); Renderer.SetViewport(0, Viewport = new Viewport(Context, scene, cameraNode.GetComponent(), null)); // Lights var lightNode1 = scene.CreateChild(); lightNode1.Position = new Vector3(0, -5, -40); lightNode1.AddComponent(new Light(Context) { LightType = LightType.Point, Range = 120, Brightness = 1.5f }); // Models var cache = Application.ResourceCache; var model = Node.CreateComponent(); model.Model = cache.GetModel ("player.mdl"); var material = cache.GetMaterial("player.xml").Clone(""); model.SetMaterial(material);]]> Constructs a new instance of Urho.Node which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Node, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Node linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. The node to append to the scene. If index is greater than current children size, append the new child at the end. Add a child scene node at a specific index.  This appends the child to the end of the list. The NodeAdded event is raised if the node is currently attached to a scene. Component to add. ID to assign to the component, if zero, the  will assign the ID automatically. Add a pre-created component. This adds the component and defaults to CreateMode.Replicated for the addition mode. Component to add. ID to assign to the component, if zero, the  will assign the ID automatically. Component and child node creation mode for networking. Add a pre-created component. Add listener component that is notified of node being dirtied. Can either be in the same node or another. The string to associate Attaches the specified string as a tag to this Node. Use the  to remove this tag, or the  method to determine if the element has the specified tag attached. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Apply attribute changes that can not be applied immediately recursively to child nodes and components. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The new parent for the node. Changes the parent for the node Moves the node to a new parent. Return immediate child scene nodes. Clean up all references to a network connection that is about to be removed. Clone scene node, components and child nodes. Return the clone. Clone a component from another node using its create mode. Return the clone if successful or null on failure. Clone a component from another node and specify the create mode. Return the clone if successful or null on failure. Return all components. UrhoType to create. Creation mode for the component, or Replicated if not specified. ID to assign to the component, or null if not specified. Create a component to this node (with specified ID if provided). Returns the created component.  The result will already be attached to the node. Creation mode for the component, or Replicated if not specified. ID to assign to the component, or null if not specified. Creates a component with the Node’s context and attaches it to the node. Returns the created component.  The result will already be attached to the node. (); planeObject.Model = cache.GetModel ("Models/Plane.mdl"); planeObject.SetMaterial(cache.GetMaterial("Materials/StoneTiled.xml")); ]]> UrhoType to create,  Creation mode for the component, or Replicated if not specified. ID to assign to the component, or null if not specified. Creates a component with the Node’s context and attaches it to the node using an UrhoType description. Returns the created component.  The result will already be attached to the node. (StaticModel.TypeStatic); planeObject.Model = cache.GetModel ("Models/Plane.mdl"); planeObject.SetMaterial(cache.GetMaterial("Materials/StoneTiled.xml")); ]]> Return forward direction in parent space. Positive Z axis equals identity rotation. Determines whether transform has changed and world transform needs recalculation. Controls whether the node is enabled. Disables nodes effectively disable all their components. Returns the node's last own enabled state. May be different than the value returned by IsEnabled when SetDeepEnabled has been used. Return child scene node by index. Return child scene node by name. Return child scene node by name hash. If true, the search includes nested children, otherwise the search is done only on the immediate children of this node. Returns children nodes that have a specific component attached to it. Array containing the nodes that have the specified component, or an empty array if there are none. Returns only exact components of T type. Ignores subclasses of T, for example, GetChildrenWithComponent<StaticModel>() won’t return nodes with AnimatedModel components (AnimatedModels is a subclass of StaticModel). The type of the component to lookup. If , this performs a recursive search on the child nodes of this node. Return component by type. If there are several, returns the first. The component of the specified , if found, otherwise . This method searches the current node for a component with an urho component type of .  This will either search only the components attached to this node if recursive is set to , or it will search for the component recursive on all the children nodes attached to this node. If , this performs a recursive search on the child nodes of this node. Return the component of the specified T parameters. If there are several, returns the first. The component of the specified , if found, otherwise . This method searches the current node for a component with an urho component type .  This will either search only the components attached to this node if recursive is set to , or it will search for the component recursive on all the children nodes attached to this node. Return number of child scene nodes. Type name of the component to create. Component and child node creation mode for networking. The identifier to assign to the component if it must be created. Create a component to this node if it does not exist already. Returns the component of the specified that was either located, or that was created. This method calls the  method to perform the search, if the component is not found, then it calls  method with the specified , and . If , this performs a recursive search on the child nodes of this node. Create a component to this node if it does not exist already. Returns the component of the specified  that was either located, or that was created. This method calls the  method to perform the search, if the component is not found, then it calls  method  Return whether has a specific component. The tag to check Determines if the node has the specified tag attached to it. if it does, otherwise. Use the  to add a tag to the node and  to remove it. Return ID. Or Set ID. Called by Scene. ID assigned to this node. You should ideally have unique IDs. Convert a local space position to world space. Convert a local space position or rotation to world space. Convert a local space position or rotation to world space (for Urho2D). Look at a target position in the chosen transform space. Note that the up vector is always specified in world space. Return true if successful, or false if resulted in an illegal rotation, in which case the current rotation remains. Mark node and child nodes to need world transform recalculation. Notify listener components. Mark for attribute check on the next network update. Mark node dirty in scene replication states. Return name. Or Set name of the scene node. Names are not required to be unique. Return name hash. Return network position attribute. Or Set network position attribute. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return number of components. Return number of non-local components. Calculate number of non-temporary child nodes. Calculate number of non-temporary components. Return owner connection in networking. Or Set owner connection for networking. Return parent scene node. Or Set parent scene node. Retains the world transform. Pauses all actions that have been started with . Rotate around the X axis. Return position in parent space. Or Set position in parent space. If the scene node is on the root level (is child of the scene itself), this is same as world space. Return position in parent space (for Urho2D). Prepare network update by comparing attributes and marking replication states dirty as necessary. Register object factory. Remove from the parent node. If no other shared pointer references exist, causes immediate deletion. If you want to move the node to another node, you can use the  method. Removes all actions that have been started with . Remove all child scene nodes. Remove all components from this node. Removes all tags that have been associated with the node. Remove a child scene node. Remove child scene nodes that match criteria. Remove a component from this node. Remove the first component of specific type from this node. Removes the component of the specified type. Remove all components of specific type. Remove components that match criteria. Remove listener component. Tag to remove from the node. Removes a string tag from the Node. if the tag exited on the node, otherwise. Use the  to add a tag to the node and  to probe if it is attached. Reset enabled state to the node's remembered state prior to calling SetDeepEnabled. Reset scene, ID and owner. Called by Scene. Resumes all actions that have been started with . Return right direction in parent space. Positive X axis equals identity rotation. Rotate around the Z axis. Rotate the scene node in the chosen transform space. Rotate the scene node in the chosen transform space (for Urho2D). Rotate around a point in the chosen transform space. Rotate around a point in the chosen transform space (for Urho2D). Return rotation in parent space. Or Set rotation in parent space. Return rotation in parent space (for Urho2D). Or Set rotation in parent space (for Urho2D). Actions to execute. Runs the specified actions. The actions are groupped in a Sequence action. An array of FiniteTimeAction objects. Runs a sequence of Actions so that it can be awaited. Task representing the actions. Return whether should save default-valued attributes into XML. Always save node transforms for readability, even if identity. Where the json is stored at. Indentation to use for the data. Saves the entire node as a prefab as Json data. Returns on success. The destiation to store the node on. Saves the entire node as a prefab into the provided XmlElement. Return scale in parent space. Or Set scale in parent space. Return scale in parent space (for Urho2D). Modify scale in parent space uniformly. Modify scale in parent space. Modify scale in parent space (for Urho2D). Return scene. Or Set scene. Called by Scene. Set enabled state on self and child nodes. Nodes' own enabled state is remembered (IsEnabledSelf) and can be restored. Set forward direction in parent space. Positive Z axis equals identity rotation. Set enabled state on self and child nodes. Unlike SetDeepEnabled this does not remember the nodes' own enabled state, but overwrites it. Set position in parent space (for Urho2D). Set position in parent space (for Urho2D). Updates the position but does not flag the node as dirty, nor as requiring a network update. Sets the rotation but does not flag the node as dirty, nor as requiring a network update. Set uniform scale in parent space. Set scale in parent space (for Urho2D). Set scale in parent space (for Urho2D). Sets the scale but does not flag the node as dirty, nor as requiring a network update. Set both position and rotation in parent space as an atomic operation. This is faster than setting position and rotation separately. Set both position, rotation and uniform scale in parent space as an atomic operation. Set both position, rotation and scale in parent space as an atomic operation. Set both position and rotation in parent space as an atomic operation (for Urho2D). Set both position, rotation and uniform scale in parent space as an atomic operation (for Urho2D). Set both position, rotation and scale in parent space as an atomic operation (for Urho2D). Sets the node transform but does not flag the node as dirty, nor as requiring a network update. Set a user variable. Set a user variable. Set a user variable. Set a user variable. Set a user variable. Set a user variable. Set a user variable. Set a user variable. Set a user variable. Set a user variable. Set forward direction in world space. Set position in world space. Set position in world space (for Urho2D). Set position in world space (for Urho2D). Set rotation in world space. Set uniform scale in world space. Set scale in world space. Set scale in world space (for Urho2D). Set scale in world space (for Urho2D). Set both position and rotation in world space as an atomic operation. Set both position, rotation and uniform scale in world space as an atomic operation. Set both position, rotation and scale in world space as an atomic opration. Set both position and rotation in world space as an atomic operation (for Urho2D). Set both position, rotation and uniform scale in world space as an atomic operation (for Urho2D). Set both position, rotation and scale in world space as an atomic opration (for Urho2D). Return signed scale in world space. Utilized for Urho2D physics. The handler to invoke when this event is raised. Subscribes to the AnimationTrigger event raised by the Node. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the BoneHierarchyCreated event raised by the Node. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the NodeCollision event raised by the Node. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the NodeCollisionEnd event raised by the Node. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the NodeCollisionStart event raised by the Node. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Return parent space transform matrix. The translation delta to apply. Move the scene node in the chosen transform space. Move the scene node in the chosen transform space (for Urho2D). Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return up direction in parent space. Positive Y axis equals identity rotation. Return direction in world space. Return position in world space. Return position in world space (for Urho2D). Return node's right vector in world space. Return rotation in world space. Return rotation in world space (for Urho2D). Or Set rotation in world space (for Urho2D). Return scale in world space. Return scale in world space (for Urho2D). Convert a world space position to local space. Convert a world space position or rotation to local space. Convert a world space position or rotation to local space (for Urho2D). Return world space transform matrix. Return node's up vector in world space. Rotate around the Y axis. Event arguments for the Scene's NodeAdded event Event arguments for the Node's NodeCollisionEnd event Event arguments for the Node's NodeCollision event Event arguments for the Node's NodeCollisionStart event Event arguments for the Scene's NodeEnabledChanged event Event arguments for the Scene's NodeNameChanged event Event arguments for the Scene's NodeRemoved event Object animation class, an object animation include one or more attribute animations and theirs wrap mode and speed for an Animatable object. Constructs a new instance of Urho.ObjectAnimation which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.ObjectAnimation, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.ObjectAnimation linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add attribute animation, attribute name can in following format: "attribute" or "#0/#1/attribute" or ""#0/#1/ #1/attribute. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return attribute animation by name. Return attribute animation info by name. Return attribute animation speed by name. Return attribute animation wrap mode by name. Register object factory. Remove attribute animation, attribute name can in following format: "attribute" or "#0/#1/attribute" or ""#0/#1/ #1/attribute. Remove attribute animation. The handler to invoke when this event is raised. Subscribes to the AttributeAnimationAdded event raised by the ObjectAnimation. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the AttributeAnimationRemoved event raised by the ObjectAnimation. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. For internal use only. Base class for object factories. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.ObjectFactory, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return execution context. Create an object. Implemented in templated subclasses. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Return type info of objects created by this factory. Urho's low-level type name. Stringified low-level type name. Software renderer for occlusion. Constructs a new instance of Urho.OcclusionBuffer which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.OcclusionBuffer, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.OcclusionBuffer linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return highest level depth values. Build reduced size mip levels. Clear the buffer. Return culling mode. Or Set culling mode. Draw submitted batches. Uses worker threads if enabled during SetSize(). Return buffer height. Test a bounding box for visibility. For best performance, build depth hierarchy first. Return maximum number of triangles. Or Set maximum triangles to render. Return number of rendered triangles. Return projection matrix. Reset number of triangles. Reset last used timer. Set camera view to render from. Return whether is using threads to speed up rendering. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return time since last use in milliseconds. Return view transform matrix. Return buffer width. An Octree’s Octant. This is one of the components of the  Octree component that implements spacial partitioning Implements spatial partitioning and accelerated visibility queries. Without this 3D objects can not be rendered. Should be added only to the root scene node. Constructs a new instance of Urho.Octree which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Octree, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Octree linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add a drawable manually. Cancel drawable object's update. Visualize the component as debug geometry. Visualize the component as debug geometry. Return subdivision levels. Mark drawable object as requiring an update and a reinsertion. Register object factory. Remove a manually added drawable. Set size and maximum subdivision levels. If octree is not empty, drawable objects will be temporarily moved to the root. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Particle effect definition. Constructs a new instance of Urho.ParticleEffect which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.ParticleEffect, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.ParticleEffect linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return emission active period length (0 = infinite.) Or Set emission active period length (0 = infinite.) Add a color frame sorted in the correct position based on time. Return animation Lod bias. Or Set animation LOD bias. Return constant force acting on particles. Or Set constant force acting on particles. Return particle velocity damping force. Or Set particle velocity damping force. Return emitter size. Or Set emitter size. Return emitter type. Or Set emitter type. Finish resource loading. Always called from the main thread. Return true if successful. Return how the particles rotate in relation to the camera. Or Set how the particles should rotate in relation to the camera. Default is to follow camera rotation on all axes (FC_ROTATE_XYZ.) Return whether billboards are fixed screen size. Or Set whether billboards have fixed size on screen (measured in pixels) regardless of distance to camera. Return a color animation frame, or null if outside range. Return a texture animation frame, or null if outside range. Return emission inactive period length (0 = infinite.) Or Set emission inactive period length (0 = infinite.) Return material. Or Set material. Return positive direction limit. Or Set positive direction limit. Return maximum emission rate. Or Set maximum emission rate. Return particle maximum size. Or Set particle maximum size. Return particle maximum rotation. Or Set particle maximum rotation. Return particle maximum rotation speed. Or Set particle maximum rotation speed. Return particle maximum time to live. Or Set particle maximum time to live. Return particle maximum velocity. Or Set particle maximum velocity. Return negative direction limit. Or Set negative direction limit. Return minimum emission rate. Or Set minimum emission rate. Return particle minimum size. Or Set particle minimum size. Return particle minimum rotation. Or Set particle minimum rotation. Return particle minimum rotation speed. Or Set particle minimum rotation speed. Return particle minimum time to live. Or Set particle minimum time to live. Return particle minimum velocity. Or Set particle minimum velocity. Return number of color animation frames. Or Set number of color frames. Return maximum number of particles. Or Set maximum number of particles. Return number of texture animation frames. Or Set number of texture frames. Return random direction. Return random rotation. Return random rotationspeed. Return random size. Return random timetolive. Return random velocity. Register object factory. Determines whether billboards are relative to the scene node. This defaults to true. Remove color frame at index Remove texture frame at index Determines whether scene node scale affects billboards' size. Return particle size additive modifier. Or Set particle size additive modifier. Return particle size multiplicative modifier. Or Set particle size multiplicative modifier. Sort the list of color frames based on time. Determines whether billboards are sorted. Sort the list of texture frames based on time. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return whether to update when particles are not visible. Or Set whether to update when particles are not visible. Particle emitter component. Constructs a new instance of Urho.ParticleEmitter which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.ParticleEmitter, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.ParticleEmitter linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Apply not continuously updated values such as the material, the number of particles and sorting mode from the particle effect. Call this if you change the effect programmatically. Return automatic removal mode on particle effect completion. Or Set to remove either the emitter component or its owner node from the scene automatically on particle effect completion. Disabled by default. Return particle effect. Or Set particle effect. Set particles effect attribute. Controls whether is currently emitting. If the state was changed, also resets the emission period timer.. Return maximum number of particles. Or Set maximum number of particles. Handle enabled/disabled state change. Register object factory. Remove all current particles. Reset the particle emitter completely. Removes current particles, sets emitting state on, and resets the emission timer. Reset the emission period timer. Return whether particles are to be serialized. Or Set whether particles should be serialized. Default true, set false to reduce scene file size. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Material rendering pass, which defines shaders and render state. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Pass, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return alpha-to-coverage mode. Or Set alpha-to-coverage on/off. Return blend mode. Or Set blend mode. Return culling mode override. If pass is not overriding culling mode (default), the illegal mode MAX_CULLMODES is returned. Or Set culling mode override. By default culling mode is read from the material instead. Set the illegal culling mode MAX_CULLMODES to disable override again. Return depth compare mode. Or Set depth compare mode. Return depth write mode. Or Set depth write on/off. Return whether requires desktop level hardware. Return the effective pixel shader defines, accounting for excludes. Called internally by Renderer. Return the effective vertex shader defines, accounting for excludes. Called internally by Renderer. Return pass index. This is used for optimal render-time pass queries that avoid map lookups. Return pass lighting mode. Or Set pass lighting mode, affects what shader variations will be attempted to be loaded. Mark shaders loaded this frame. Return pass name. Return pixel shader name. Or Set pixel shader name. Return pixel shader define excludes. Or Set pixel shader define excludes. Use to mark defines that the shader code will not recognize, to prevent compiling redundant shader variations. Return pixel shader defines. Or Set pixel shader defines. Reset shader pointers. Set whether requires desktop level hardware. Return last shaders loaded frame number. Return vertex shader name. Or Set vertex shader name. Return vertex shader define excludes. Or Set vertex shader define excludes. Use to mark defines that the shader code will not recognize, to prevent compiling redundant shader variations. Return vertex shader defines. Or Set vertex shader defines. Lighting mode of a pass. Surface in three dimensional space. Construct from a 4-dimensional vector, where the w coordinate is the plane parameter. Construct from a normal vector and a point on the plane. Plane absolute normal. Plane constant. Plane normal. Enumeration describing the executing platform, the value is obtained getting the  property. Running on Android. Running on iOS. Running on Linux. Running on MacOS X. Running on an unknown platform. Running on Windows. A convex volume built from polygon faces. Clear all faces. Return whether is empty. Event arguments for the Engine's PostRenderUpdate event Event arguments for the Engine's PostUpdate event Primitive type. Hierarchical performance profiler subsystem. Constructs a new instance of Urho.Profiler which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Profiler, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Profiler linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Begin the profiling frame. Called by HandleBeginFrame(). Begin a new interval. Return the current profiling block. End timing the current profiling block. End the profiling frame. Called by HandleEndFrame(). Return the root profiling block. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Represents a Quaternion. The vector part The w part Construct a new Quaternion from vector and w components The x component The y component The z component The w component Construct a new Quaternion The first operand The second operand Add two quaternions The result of the addition The first operand The second operand The result of the addition Add two quaternions Convert this quaternion to its conjugate The quaternion Get the conjugate of the given quaternion The conjugate of the given quaternion The quaternion The conjugate of the given quaternion Get the conjugate of the given quaternion The other object to be used in the comparison. Compares this object instance to another object for equality. True if both objects are Quaternions of equal value. Otherwise it returns false. The other Quaternion to be used in the comparison. Compares this Quaternion instance to another Quaternion for equality. True if both instances are equal; false otherwise. The axis to rotate about The rotation angle in degrees Build a quaternion from the given axis and angle Provides the hash code for this object. A hash code formed from the bitwise XOR of this objects members. Defines the identity quaternion. The quaternion to invert Get the inverse of the given quaternion The inverse of the given quaternion The quaternion to invert The inverse of the given quaternion Get the inverse of the given quaternion Gets the length (magnitude) of the quaternion. Gets the square of the quaternion length (magnitude). The first instance. The second instance. Multiplies two instances. A new instance containing the result of the calculation. The first instance. The second instance. A new instance containing the result of the calculation. Multiplies two instances. The instance. The scalar. Multiplies an instance by a scalar. A new instance containing the result of the calculation. The first instance. The second instance. Multiplies two instances. A new instance containing the result of the calculation. The instance. The scalar. A new instance containing the result of the calculation. Multiplies an instance by a scalar. The first instance. The second instance. A new instance containing the result of the calculation. Multiplies two instances. Scales the Quaternion to unit length. The quaternion to normalize Scale the given quaternion to unit length The normalized quaternion The quaternion to normalize The normalized quaternion Scale the given quaternion to unit length The first instance. The second instance. Adds two instances. The result of the calculation. The first instance. The second instance. Compares two instances for equality. True, if left equals right; false otherwise. The first instance. The second instance. Compares two instances for inequality. True, if left does not equal right; false otherwise. The scalar. The instance. Multiplies an instance by a scalar. A new instance containing the result of the calculation. The instance. The scalar. Multiplies an instance by a scalar. A new instance containing the result of the calculation. The first instance. The second instance. Multiplies two instances. The result of the calculation. The instance. The vector. Multiplies an instance by a vector3. A new instance containing the result of the calculation. The first instance. The second instance. Subtracts two instances. The result of the calculation. The first quaternion The second quaternion The blend factor Do Spherical linear interpolation between two quaternions A smooth blend between the given quaternions The left instance. The right instance. Subtracts two instances. The result of the operation. The left instance. The right instance. The result of the operation. Subtracts two instances. Convert this instance to an axis-angle representation. A Vector4 that is the axis-angle representation of this quaternion. The resultant axis The resultant angle Convert the current quaternion to axis angle representation Returns a System.String that represents the current Quaternion. Gets or sets the W component of this instance. Gets or sets the X component of this instance. Gets or sets an OpenTK.Vector3 with the X, Y and Z components of this instance. Gets or sets an OpenTK.Vector3 with the X, Y and Z components of this instance. Gets or sets the Y component of this instance. Gets or sets the Z component of this instance. Set of usefull Random helper methods. Infinite straight line in a three-dimensional space Rays are lines that start at one point in space and point towards a specific direction Constructs from origin and direction, the direction will be normalized. The other ray. Return closest point to another ray. Vector representing the closest point to the other ray. Ray direction Point to compute the distance to. Return distance of a point from the ray. Return distance of a point from the ray. The object to compare to. Compares the provided object with this ray Returns if the obj is a Ray, and the values of the array are the same as this array, otherwise. Returns the Ray’s hashcode. The plane to compute the hit distance against. Computes the hit distance to a plane. Return hit distance to a plane, or  if no hit. Left ray Right ray Compares two rays for equality if they are equal, otherwise. Left ray Right ray Compares two rays and determine if they are not equal.  if they are not equal,  otherwise. Ray origin. Point to project Project a point on the ray Computes the ray’s Origin + DotProductOf (-Origin, Direction) * Direction. Graphics raycast detail level. Raycast result. Represents a rectangle. Base class for intrusively reference-counted objects. These are noncopyable and non-assignable. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.RefCounted, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Increment reference count. Can also be called outside of a SharedPtr for traditional reference counting. True if underlying native object is deleted Return pointer to the reference count structure. Return reference count. Decrement reference count and delete self if no more references. Can also be called outside of a SharedPtr for traditional reference counting. Return weak reference count. Rendering path sorting modes. Rendering path command types. Clear any of color, depth and stencil. Color clear can optionally use the fog color from the Zone visible at the far clip distance. Render per-pixel forward lighting for opaque objects with the specified pass name. Shadow maps are also rendered as necessary. Render deferred light volumes using the specified shaders. G-buffer textures can be bound as necessary. Render a viewport-sized quad using the specified shaders and compilation defines. Textures can be bound and additionally shader parameters and the blend mode (default=replace) can be specified. Render the UI into the output rendertarget. Using this will cause the default %UI render to the backbuffer to be skipped. Render scene objects whose  contains the specified pass. Will either be front-to-back ordered with state sorting, or back-to-front ordered with no state sorting. For deferred rendering, object lightmasks can be optionally marked to the stencil buffer. Vertex lights can optionally be handled during a pass, if it has the necessary shader combinations. Textures global to the pass can be bound to free texture units; these can either be the viewport, a named rendertarget, or a texture resource identified with its pathname. High-level rendering subsystem. Manages drawing of 3D views. Renderer implements the actual rendering of 3D views each frame, and controls global settings such as texture quality, material quality, specular lighting and shadow map base resolution. To render, it needs a  with an  component, and a  that does not necessarily have to belong to the scene. The octree stores all visible components (derived from ) to allow querying for them in an accelerated manner. The needed information is collected in a  object, which can be assigned with  method. By default there is one viewport, but the amount can be increased with the  property. The viewport(s) should cover the entire screen or otherwise hall-of-mirrors artifacts may occur. By specifying a zero screen rectangle the whole window will be used automatically. The viewports will be rendered in ascending order, so if you want for example to have a small overlay window on top of the main viewport, use viewport index 0 for the main view, and 1 for the overlay. Viewports can also be defined for render target textures. See “Auxiliary Views” in the documentation for  for details. Each viewport defines a command sequence for rendering the scene, the . By default there exist forward, light pre-pass and deferred render paths in the bin/CoreData/RenderPaths directory, see  to set the default for new viewports. If not overridden from the command line, forward rendering is the default. Deferred rendering modes will be advantageous once there is a large number of per-pixel lights affecting each object, but their disadvantages are the lack of hardware multisampling and inability to choose the lighting model per material. In place of multisample antialiasing, a FXAA post-processing edge filter can be used, see the MultipleViewports sample application (bin/Data/Scripts/09_MultipleViewports.as) for an example of how to use. The steps for rendering each viewport on each frame are roughly the following: Query the octree for visible objects and lights in the camera's view frustum. Check the influence of each visible light on the objects. If the light casts shadows, query the octree for shadowcaster objects. Construct render operations (batches) for the visible objects, according to the scene passes in the render path command sequence. Perform the render path command sequence during the rendering step at the end of the frame. If the scene has a  component and the viewport has debug rendering enabled, render debug geometry last. Can be controlled with , default is enabled. In the default render paths, the rendering operations proceed in the following order: Opaque geometry ambient pass, or G-buffer pass in deferred rendering modes. Opaque geometry per-pixel lighting passes. For shadow casting lights, the shadow map is rendered first. (Light pre-pass only) Opaque geometry material pass, which renders the objects with accumulated per-pixel lighting. Post-opaque pass for custom render ordering such as the skybox. Refractive geometry pass. Transparent geometry pass. Transparent, alpha-blended objects are sorted according to distance and rendered back-to-front to ensure correct blending. Post-alpha pass, can be used for 3D overlays that should appear on top of everything else.

    Rendering components

     The rendering-related components defined by the Graphics and UI libraries are: : spatial partitioning of Drawables for accelerated visibility queries. Needs to be created to the  (root node.) : describes a viewpoint for rendering, including projection parameters (FOV, near/far distance, perspective/orthographic) : Base class for anything visible. : non-skinned geometry. Can LOD transition according to distance. : renders several object instances while culling and receiving light as one unit. : a subclass of  that appears to always stay in place. : skinned geometry that can do skeletal and vertex morph animation. : drives animations forward automatically and controls animation fade-in/out. : a group of camera-facing billboards, which can have varying sizes, rotations and texture coordinates. : a subclass of  that emits particle billboards. : illuminates the scene. Can optionally cast shadows. : renders heightmap terrain. : renders runtime-defined unindexed geometry. The geometry data is not serialized or replicated over the network. : renders decal geometry on top of objects. : defines ambient light and fog settings for objects inside the zone volume. : text that is rendered into the 3D view. Additionally there are 2D drawable components defined by the Urho2D library.

    Optimizations

     The following techniques will be used to reduce the amount of CPU and GPU work when rendering. By default they are all on: Software rasterized occlusion: after the octree has been queried for visible objects, the objects that are marked as occluders are rendered on the CPU to a small hierarchical-depth buffer, and it will be used to test the non-occluders for visibility. Use   and  to configure the occlusion rendering. Occlusion testing will always be multithreaded, however occlusion rendering is by default singlethreaded, to allow rejecting subsequent occluders while rendering front-to-back. Use  to enable threading also in rendering, however this can actually perform worse in e.g. terrain scenes where terrain patches act as occluders. Hardware instancing: rendering operations with the same geometry, material and light will be grouped together and performed as one draw call if supported. Note that even when instancing is not available, they still benefit from the grouping, as render state only needs to be checked & set once before rendering each group, reducing the CPU cost. Light stencil masking: in forward rendering, before objects lit by a spot or point light are re-rendered additively, the light's bounding shape is rendered to the stencil buffer to ensure pixels outside the light range are not processed. Note that many more optimization opportunities are possible at the content level, for example using geometry & material LOD, grouping many static objects into one object for less draw calls, minimizing the amount of subgeometries (submeshes) per object for less draw calls, using texture atlases to avoid render state changes, using compressed (and smaller) textures, and setting maximum draw distances for objects, lights and shadows.

    Reusing view preparation

     In some applications, like stereoscopic VR rendering, one needs to render a slightly different view of the world to separate viewports. Normally this results in the view preparation process (described above) being repeated for each view, which can be costly for CPU performance. To eliminate the duplicate view preparation cost, you can use   to instruct a  to use a different camera for culling than rendering. When multiple viewports share the same culling camera, the view preparation will be performed only once. To work properly, the culling camera's frustum should cover all the views you are rendering using it, or else missing objects may be present. The culling camera should not be using the auto aspect ratio mode, to ensure you stay in full control of its view frustum.


    Constructs a new instance of Urho.Renderer which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Renderer, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Renderer linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return the default range attenuation texture. Return the default spotlight attenuation texture. Return the default material. Return default renderpath. Or Set default renderpath. Return default non-textured material technique. Or Set default non-textured material technique. Return the default zone. Add debug geometry to the debug renderer. Return whether drawing shadows is enabled. Or Set shadows on/off. Return whether dynamic instancing is in use. Or Set dynamic instancing on/off. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return the shadowed pointlight face selection cube map. Return a view or its source view if it uses one. Used internally for render statistics. Allocate a depth-stencil surface that does not need to be readable. Should only be called during actual rendering, not before. Return volume geometry for a light. Return number of geometries rendered. Return number of lights rendered. Return number of occluders rendered. Return number of shadow maps rendered. Allocate an occlusion buffer. Return a prepared view if exists for the specified camera. Used to avoid duplicate view preparation CPU work. Allocate a rendertarget or depth-stencil texture for deferred rendering or postprocessing. Should only be called during actual rendering, not before. Allocate a shadow map. If shadow map reuse is disabled, a different map is returned each time. Return backbuffer viewport by index. Return whether HDR rendering is enabled. Or Set HDR rendering on/off. Return the shadowed pointlight indirection cube map. Return the instancing vertex buffer Return material quality level. Or Set material quality level. See the QUALITY constants in GraphicsDefs.h. Return maximum number of occluder triangles. Or Set maximum number of occluder triangles. Return maximum number of shadow maps per resolution. Or Set maximum number of shadow maps created for one resolution. Only has effect if reuse of shadow maps is disabled. Return maximum number of sorted instances per batch group. Or Set maximum number of sorted instances per batch group. If exceeded, instances are rendered unsorted. Return minimum number of instances required in a batch group to render as instanced. Or Set minimum number of instances required in a batch group to render as instanced. Return shadow normal offset multiplier for mobile platforms. Or Set shadow normal offset multiplier for mobile platforms to counteract possible worse shadow map precision. Default 1.0 (no effect.) Return shadow depth bias addition for mobile platforms. Or Set shadow depth bias addition for mobile platforms (OpenGL ES.) No effect on desktops. Default 0.0001. Return shadow depth bias multiplier for mobile platforms. Or Set shadow depth bias multiplier for mobile platforms (OpenGL ES.) No effect on desktops. Default 2. Return number of batches rendered. Return number of extra instancing buffer elements. Or Set number of extra instancing buffer elements. Default is 0. Extra 4-vectors are available through TEXCOORD7 and further. Return number of primitives rendered. Return number of backbuffer viewports. Or Set number of backbuffer viewports to render. Return number of views rendered. Return occluder screen size threshold. Or Set required screen size (1.0 = full screen) for occluders. Return occlusion buffer width. Or Set occluder buffer width. Optimize a light by scissor rectangle. Optimize a light by marking it to the stencil buffer and setting a stencil test. Return quad geometry used in postprocessing. Queue a render surface's viewports for rendering. Called by the surface, or by View. Queue a viewport for rendering. Null surface means backbuffer. Force reload of shaders. Render. Called by Engine. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Ensure sufficient size of the instancing vertex buffer. Return true if successful. Return whether shadow maps are reused. Or Set reuse of shadow maps. Default is true. If disabled, also transparent geometry can be shadowed. Set cull mode while taking possible projection flipping into account. Set default renderpath from xml file. Set a backbuffer viewport. Set shadow parameters when VSM is used, they help to reduce light bleeding. LightBleeding must be in [0, 1] Allocate a temporary shadow camera and a scene node for it. Is thread-safe. Return shadow map resolution. Or Set shadow map resolution. Return shadow quality. Or Set shadow quality mode. See the SHADOWQUALITY constants in GraphicsDefs.h. Return shadow softness. Or Set shadow softness, only works when SHADOWQUALITY_BLUR_VSM is used. Return whether specular lighting is enabled. Or Set specular lighting on/off. Mark a view as prepared by the specified culling camera. The handler to invoke when this event is raised. Subscribes to the BeginViewRender event raised by the Renderer. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the EndViewRender event raised by the Renderer. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the RenderSurfaceUpdate event raised by the Renderer. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Return texture anisotropy. Or Set texture anisotropy. Return texture filtering. Or Set texture filtering. Return texture quality level. Or Set texture quality level. See the QUALITY constants in GraphicsDefs.h. Return whether occlusion rendering is threaded. Or Set whether to thread occluder rendering. Default false. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Update for rendering. Called by HandleRenderUpdate(). Return VSM shadow multisample level. Or Set VSM shadow map multisampling level. Default 1 (no multisampling.) Return VSM shadow parameters. Rendering path definition.  rendering and any post-processing on a Viewport is defined by its RenderPath object, which can either be read from an XML file or be created programmatically. The render path consists of rendertarget definitions and commands. The commands are executed in order to yield the rendering result. Each command outputs either to the destination rendertarget & viewport (default if output definition is omitted), or one of the named rendertargets. MRT output is also possible. If the rendertarget is a cube map, the face to render to (0-5) can also be specified. A rendertarget's size can be either absolute or multiply or divide the destination viewport size. The multiplier or divisor does not need to be an integer number. Furthermore, a rendertarget can be declared "persistent" so that it will not be mixed with other rendertargets of the same size and format, and its contents can be assumed to be available also on subsequent frames. Note that if you already have created a named rendertarget texture in code and have stored it into the resource cache by using  you can use it directly as an output (by referring to its name) without requiring a rendertarget definition for it. The available commands are: clear: Clear any of color, depth and stencil. Color clear can optionally use the fog color from the Zone visible at the far clip distance. scenepass: Render scene objects whose  contains the specified pass. Will either be front-to-back ordered with state sorting, or back-to-front ordered with no state sorting. For deferred rendering, object lightmasks can be optionally marked to the stencil buffer. Vertex lights can optionally be handled during a pass, if it has the necessary shader combinations. Textures global to the pass can be bound to free texture units; these can either be the viewport, a named rendertarget, or a texture resource identified with its pathname. quad: Render a viewport-sized quad using the specified shaders and compilation defines. Textures can be bound and additionally shader parameters and the blend mode (default=replace) can be specified. forwardlights: Render per-pixel forward lighting for opaque objects with the specified pass name. Shadow maps are also rendered as necessary. lightvolumes: Render deferred light volumes using the specified shaders. G-buffer textures can be bound as necessary. renderui: Render the UI into the output rendertarget. Using this will cause the default %UI render to the backbuffer to be skipped. A render path can be loaded from a main XML file by calling , after which other XML files (for example one for each post-processing effect) can be appended to it by calling . Rendertargets and commands can be enabled or disabled by calling  to switch eg. a post-processing effect on or off. To aid in this, both can be identified by tag names, for example the bloom effect uses the tag "Bloom" for all of its rendertargets and commands. It is legal to both write to the destination viewport and sample from it during the same command: pingpong copies of its contents will be made automatically. If the viewport has hardware multisampling on, the multisampled backbuffer will be resolved to a texture before sampling it. The render path XML definition looks like this: ]]> For examples of renderpath definitions, see the default forward, deferred and light pre-pass renderpaths in the bin/CoreData/RenderPaths directory, and the postprocess renderpath definitions in the bin/Data/PostProcess directory.

    Depth-stencil handling and reading scene depth

     Normally needed depth-stencil surfaces are automatically allocated when the render path is executed. The special "lineardepth" (synonym "depth") format is intended for storing scene depth in deferred rendering. It is not an actual hardware depth-stencil texture, but a 32-bit single channel (R) float rendertarget. (On OpenGL2 it's RGBA instead, due to the limitation of all color buffers having to be the same format. The shader include file Samplers.glsl in bin/CoreData/Shaders/GLSL provides functions to encode and decode linear depth to RGB.) Writing depth manually to a rendertarget, while using a non-readable depth-stencil surface ensures best compatibility and prevents any conflicts from using both depth test and manual depth sampling at the same time. There is also a possibility to define a readable hardware depth texture, and instruct the render path to use it instead. Availability for this must first be checked with the function GetReadableDepthSupport(). On Direct3D9 this will use the INTZ "hack" format. To define a readable depth-stencil texture, use the format "readabledepth" (synonym "hwdepth") and set it as the depth-stencil by using the "depthstencil" attribute in render path commands. Note that you must set it in every command where you want to use it, otherwise an automatically allocated depth-stencil will be used. Note also that the existence of a stencil channel is not guaranteed, so stencil masking optimizations for lights normally used by the Renderer and View classes will be disabled. In the special case of a depth-only rendering pass you can set the readable depth texture directly as the "output" and don't need to specify the "depthstencil" attribute at all. After the readable depth texture has been filled, it can be bound to a texture unit in any subsequent commands. Pixel shaders should use the ReconstructDepth() helper function to reconstruct a linear depth value between 0-1 from the nonlinear hardware depth value. When the readable depth texture is bound for sampling, depth write is automatically disabled, as both modifying and sampling the depth would be undefined. An example render path for readable hardware depth exists in bin/CoreData/RenderPaths/ForwardHWDepth.xml: ]]> The render path starts by allocating a readable depth-stencil texture the same size as the destination viewport, clearing its depth, then rendering a depth-only pass to it. Next the destination color rendertarget is cleared normally, while the readable depth texture is used as the depth-stencil for that and all subsequent commands. Any command after the depth render pass could now bind the depth texture to an unit for sampling, for example for smooth particle or SSAO effects. The ForwardDepth.xml render path does the same, but using a linear depth rendertarget instead of a hardware depth texture. The advantage is better compatibility (guaranteed to work without checking ) but it has worse performance as it will fill the hardware depth-stencil twice.

    Special Considerations for Forward Lighting

     Otherwise fully customized scene render passes can be specified, but there are a few things to remember related to forward lighting: The opaque base pass must be tagged with metadata "base". When forward lighting logic does the lit base pass optimization, it will search for a pass with the word "lit" prepended, ie. if your custom opaque base pass is called "custombase", the corresponding lit base pass would be "litcustombase". The transparent base pass must be tagged with metadata "alpha". For lit transparent objects, the forward lighting logic will look for a pass with the word "lit" prepended, ie. if the custom alpha base pass is called "customalpha", the corresponding lit pass is "litcustomalpha". The lit drawcalls will be interleaved with the transparent base pass, and the scenepass command should have back-to-front sorting enabled. If forward and deferred lighting are mixed, the G-buffer writing pass must be tagged with metadata "gbuffer" to prevent geometry being double-lit also with forward lights. Remember to mark the lighting mode (per-vertex / per-pixel) into the techniques which define custom passes, as the lighting mode can be guessed automatically only for the known default passes. The forwardlights command can optionally disable the lit base pass optimization without having to touch the material tech iques, if a separate opaque ambient-only base pass is needed. B default the optimization is enabled.

    Special Considerations for Post-Processing Effects

    Post-processing effects are usually implemented by using the quad command. When using intermediate rendertargets that are of different size than the viewport rendertarget, it is necessary in shaders to reference their (inverse) size and the half-pixel offset for Direct3D9. These shader uniforms are automatically generated for named rendertargets. For an example look at the bloom postprocess shaders: the rendertarget called HBlur will define the shader uniforms cHBlurInvSize and cHBlurOffsets (both Vector2.) In OpenGL post-processing shaders it is important to distinguish between sampling a rendertarget texture and a regular texture resource, because intermediate rendertargets (such as the G-buffer) may be vertically inverted. Use the GetScreenPos() or GetQuadTexCoord() functions to get rendertarget UV coordinates from the clip coordinates; this takes flipping into account automatically. For sampling a regular texture, use GetQuadTexCoordNoFlip() function, which requires world coordinates instead of clip coordinates.     Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.RenderPath, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Clone the rendering path. Return command at index, or null if does not exist. Return number of commands. Return number of rendertargets. Remove a command by index. Remove commands by tag name. Remove a rendertarget by name. Remove a rendertarget by index. Remove rendertargets by tag name. Enable/disable commands and rendertargets by tag. Set a shader parameter in all commands that define it. Set a shader parameter in all commands that define it. Set a shader parameter in all commands that define it. Set a shader parameter in all commands that define it. Set a shader parameter in all commands that define it. Set a shader parameter in all commands that define it. Set a shader parameter in all commands that define it. Set a shader parameter in all commands that define it. Set a shader parameter in all commands that define it. Set a shader parameter in all commands that define it. Toggle enabled state of commands and rendertargets by tag. Rendering path command. Viewports defines a command sequence for rendering a scene, called the Render Path.   Blend mode, affects quad command only. Clear color, affects the clear command only. Clear depth, affectrs the clear command only. Clear flags, affects the clear command only. Clear stencil, affects the clear command only. Depth-stencil output name. Enabled flag. Mark to stencil flag Command/pass metadata. Output render targets and faces. Scene pass name. Scene pass index, filled by view. Pixel shader defines Pixel shader name. Pointers to a vector of paris of stringhashes and variants. Sorting mode. Tag name Texture 0. Texture 1. Texture 10. Texture 11. Texture 12. Texture 13. Texture 14. Texture 15. Texture 2 Texture 3 Texture 4. Texture 5. Texture 6. Texture 7. Texture 8. Texture 9. Command type. This returns the Urho's type and is surfaced for low-level Urho code. Use fog color for clearing Use lit base pass optimization for forward per-pixel lights. Vertex lights flag. Vertex shader defines Vertex shader name Color or depth-stencil surface that can be rendered into.

    Auxiliary Views

     Auxiliary views are viewports assigned to a  by calling its  method. By default these will be rendered on each frame that the texture containing the surface is visible, and can be typically used to implement for example camera displays or reflections. The texture in question must have been created in rendertarget mode, see  method. The viewport is not assigned directly to the texture because of cube map support: a renderable cube map has 6 render surfaces, and done this way, a different camera could be assigned to each. A "backup texture" can be assigned to the rendertarget texture: because it is illegal to sample a texture that is also being simultaneously rendered to (in cases where the texture becomes "recursively" visible in the auxiliary view), the backup texture can be used to specify which texture should be used in place instead. Rendering detailed auxiliary views can easily have a large performance impact. Some things you can do for optimization with the auxiliary view camera: Set the far clip distance as small as possible. Use viewmasks on the camera and the scene objects to only render some of the objects in the auxiliary view. Use the camera’s  property to disable shadows, to disable occlusion, or force the lowest material quality. The surface can also be configured to always update its viewports, or to only update when manually requested. See . For example an editor widget showing a rendered texture might use either of those modes. Call  to request a manual update of the surface on the current frame.     Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.RenderSurface, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return multisampling autoresolve mode. Return viewport by index. Return height. Return linked depth buffer. Or Set linked depth-stencil surface. Return linked color buffer. Or Set linked color rendertarget. Return multisampling level. Return number of viewports. Or Set number of viewports. Return parent texture. Queue manual update of the viewport(s). eturn Direct3D11 read-only depth-stencil view. May be null if not applicable. Not valid on OpenGL. Release renderbuffer if any. Return Direct3D11 rendertarget or depth-stencil view. Not valid on OpenGL. Reset update queued flag. Called internally. Get or Set or clear the need resolve flag. Called internally by Graphics. Set viewport. Return Direct3D9 surface. Return viewport update mode. Or Set viewport update mode. Default is to update when visible. Return viewport update mode. Return usage. Return width. Event arguments for the Renderer's RenderSurfaceUpdate event Update mode for render surface viewports. Rendertarget size mode. Event arguments for the Engine's RenderUpdate event Urho's type system type. This returns the Urho's type and is surfaced for low-level Urho code. Optional resource request processor. Can deny requests, re-route resource file names, or perform other processing per request. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.ResourceRouter, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Base class for resources that support arbitrary metadata stored. Metadata serialization shall be implemented in derived classes. Return whether the resource has metadata. Remove all metadata variables. Drawable component that creates a tail. Constructs a new instance of Urho.RibbonTrail which is tied to the . Constructs a new instance of Urho.RibbonTrail linked to a specific . Return animation LOD bias. Or Set animation LOD bias. Mark for bounding box and vertex buffer update. Call after modifying the trails. Return whether is currently emitting. Or Set whether trail should be emitting. Get vertex blended color for end of trail. Or Set vertex blended scale for end of trail. Get vertex blended scale for end of trail. Or Set vertex blended scale for end of trail. Return tail time to live. Or Set tail time to live. Return material. Or Set material. Return material attribute. Handle enabled/disabled state change. Return whether tails are sorted. Or Set whether tails are sorted by distance. Default false. Get vertex blended color for start of trail. Or Set vertex blended color for start of trail. Get vertex blended scale for start of trail. Or Set vertex blended color for start of trail. Get number of column for tails. Or Set number of column for every tails. Can be useful for fixing distortion at high angle. Return how the trail behave. Or Set how the trail behave. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return whether a geometry update is necessary, and if it can happen in a worker thread. Return whether to update when trail emitter are not visible. Or Set whether to update when trail emiiter are not visible. Get distance between points. Or Set distance between points. Get width of the trail. Or Set width of the tail. Only works for face camera trail type. Root scene node, represents the whole scene. When you create a Scene, it is automatically attached to the specified context (or the default as exposed by .   The Scene is just the toplevel  and it holds the various nodes for your application.    In general, you will want to add an Octree component to your scene, without it, none of the visual components will be shown.  The default Octree component volume goes from (-1000,-1000,-1000) to (1000,1000,1000) in world coordinates. (); // Create a child scene node (at world origin) and a StaticModel // component into it. Set the StaticModel to show a simple plane mesh // with a "stone" material. Note that naming the scene nodes is // optional. Scale the scene node larger (100 x 100 world units) var planeNode = scene.CreateChild("Plane"); planeNode.Scale = new Vector3 (100, 1, 100); var planeObject = planeNode.CreateComponent (); planeObject.Model = cache.GetModel ("Models/Plane.mdl"); planeObject.SetMaterial(cache.GetMaterial("Materials/StoneTiled.xml")); // Create a directional light to the world so that we can see something. The // light scene node's orientation controls the light direction; we will use // the SetDirection() function which calculates the orientation from a forward // direction vector. // The light will use default settings (white light, no shadows) var lightNode = scene.CreateChild("DirectionalLight"); lightNode.SetDirection (new Vector3(0.6f, -1.0f, 0.8f)); ]]> Constructs a new instance of Urho.Scene which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Scene, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Scene linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add a required package file for networking. To be called on the server. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return whether an asynchronous loading operation is in progress. Return maximum milliseconds per frame to spend on async loading. Or Set maximum milliseconds per frame to spend on async scene loading. Return the load mode of the current asynchronous loading operation. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return asynchronous loading progress between 0.0 and 1.0, or 1.0 if not in progress. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Begin a threaded update. During threaded update components can choose to delay dirty processing. Return source file checksum. Clean up all references to a network connection that is about to be removed. Clear scene completely of either replicated, local or all nodes and components. Clear required package files. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Add a component to the delayed dirty notify queue. Is thread-safe. Return elapsed time in seconds. Or Set elapsed time in seconds. This can be used to prevent inaccuracy in the timer if the scene runs for a long time. End a threaded update. Notify components that marked themselves for delayed dirty processing. Return source file name. Return component from the whole scene by ID, or null if not found. Get free component ID, either non-local or local. Get free node ID, either non-local or local. Return node from the whole scene by ID, or null if not found. Return a node user variable name, or empty if not registered. data source Position where the object will be instantiated. Rotation used for the object. Creation mode. Instantiate scene content from JSON data.  Return root node if successful, on error. data source Position where the object will be instantiated. Rotation used for the object. Creation mode. Instantiate scene content from serialized XML data. Return root node if successful,  on error. data source Position where the object will be instantiated. Rotation used for the object. Creation mode. Instantiate scene content from serialized XML data. Load from a binary file asynchronously. Return true if started successfully. The LOAD_RESOURCES_ONLY mode can also be used to preload resources from object prefab files. Mark for attribute check on the next network update. Mark a comoponent for attribute check on the next network update. Mark a node for attribute check on the next network update. Mark a node dirty in scene replication states. The node does not need to have own replication state yet. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Prepare network update by comparing attributes and marking replication states dirty as necessary. Register object factory. Node must be registered first. Register a node user variable hash reverse mapping (for editing.) Return required package files. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Set node user variable reverse mappings. Return motion smoothing constant. Or Set network client motion smoothing constant. Return motion smoothing snap threshold. Or Set network client motion smoothing snap threshold. Stop asynchronous loading. The handler to invoke when this event is raised. Subscribes to the AsyncLoadFinished event raised by the Scene. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the AsyncLoadProgress event raised by the Scene. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the AttributeAnimationUpdate event raised by the Scene. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ComponentAdded event raised by the Scene. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ComponentCloned event raised by the Urho.Scene (single subscriber). Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ComponentEnabledChanged event raised by the Scene. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ComponentRemoved event raised by the Scene. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the NodeAdded event raised by the Scene. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the NodeCloned event raised by the Urho.Scene (single subscriber). Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the NodeEnabledChanged event raised by the Scene. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the NodeNameChanged event raised by the Scene. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the NodeRemoved event raised by the Scene. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the SceneDrawableUpdateFinished event raised by the Scene. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ScenePostUpdate event raised by the Scene. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the SceneSubsystemUpdate event raised by the Scene. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the SceneUpdate event raised by the Scene. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the UpdateSmoothing event raised by the Scene. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Return threaded update flag. Return update time scale. Or Set update time scale. 1.0 = real time (default.) Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Clear all registered node user variable hash reverse mappings. Unregister a node user variable hash reverse mapping. Update scene. Called by HandleUpdate. Controls whether updates to the scene are enabled or disabled. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return node user variable reverse mappings. Event arguments for the Scene's SceneDrawableUpdateFinished event Event arguments for the Scene's ScenePostUpdate event Event arguments for the Scene's SceneSubsystemUpdate event Event arguments for the Scene's SceneUpdate event Contains SDL exported methods for internal use. \name Usage page 0x07 These values are from usage page 0x07 (USB keyboard page). \name Usage page 0x0C These values are mapped from usage page 0x0C (USB consumer page). \name Walther keys These are values that Christian Walther added (for mac keyboard?). This last event is only for bounding internal arrays Base class for objects with automatic serialization through attributes. Constructs a new instance of Urho.Serializable which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Serializable, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Serializable linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Allocate network attribute state. Apply attribute changes that can not be applied immediately. Called after scene load or a network update. Return attribute value by name. Return empty if not found. Return attribute value by index. Return empty if illegal index. Return attribute default value by name. Return empty if not found. Return attribute default value by index. Return empty if illegal index. Return whether an attribute's network updates are being intercepted. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Mark for attribute check on the next network update. Return the network attribute state, if allocated. Return number of attributes. Return number of network replication attributes. Remove instance's default values if they are set previously. Reset all editable attributes to their default values. Return whether should save default-valued attributes into XML. Default false. Set attribute by name. Return true if successfully set. Set attribute by name. Return true if successfully set. Set attribute by name. Return true if successfully set. Set attribute by name. Return true if successfully set. Set attribute by name. Return true if successfully set. Set attribute by name. Return true if successfully set. Set attribute by name. Return true if successfully set. Set attribute by name. Return true if successfully set. Set attribute by name. Return true if successfully set. Set attribute by name. Return true if successfully set. Set attribute by index. Return true if successfully set. Set attribute by index. Return true if successfully set. Set attribute by index. Return true if successfully set. Set attribute by index. Return true if successfully set. Set attribute by index. Return true if successfully set. Set attribute by index. Return true if successfully set. Set attribute by index. Return true if successfully set. Set attribute by index. Return true if successfully set. Set attribute by index. Return true if successfully set. Set attribute by index. Return true if successfully set. Enable interception of an attribute from network updates. Intercepted attributes are sent as events instead of applying directly. This can be used to implement client side prediction. The handler to invoke when this event is raised. Subscribes to the InterceptNetworkUpdate event raised by the Serializable. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the TemporaryChanged event raised by the Serializable. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Flags whether the Node or Component is flagged as temporary or not. Nodes that are flagged as temporary will not be saved. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Shader resource consisting of several shader variations. Urho3D uses an ubershader-like approach: permutations of each shader will be built with different compilation defines, to produce eg. static or skinned, deferred or forward or shadowed/unshadowed rendering. The building of these permutations happens on demand: technique and renderpath definition files both refer to shaders and the compilation defines to use with them. In addition the engine will add inbuilt defines related to geometry type and lighting. It is not generally possible to enumerate beforehand all the possible permutations that can be built out of a single shader. On Direct3D compiled shader bytecode is saved to disk in a "Cache" subdirectory next to the shader source code, so that the possibly time-consuming compile can be skipped on the next time the shader permutation is needed. On OpenGL such mechanism is not available.

    Built-in Compilation Defines

     When rendering scene objects, the engine expects certain shader permutations to exist for different geometry types and lighting conditions. These correspond to the following compilation defines:

    Built-in Shader Uniforms

     When objects or quad passes are being rendered, various engine inbuilt uniforms are set to assist with the rendering. Below is a partial list of the uniforms listed as HLSL data types. Look at the file Uniforms.glsl for the corresponding GLSL uniforms.

    Writing Shaders

     Shaders must be written separately for HLSL (Direct3D) and GLSL (OpenGL). The built-in shaders try to implement the same functionality on both shader languages as closely as possible. To get started with writing your own shaders, start with studying the most basic examples possible: the Basic, Shadow and Unlit shaders. Note the shader include files which bring common functionality, for example Uniforms.hlsl, Samplers.hlsl and Transform.hlsl for HLSL shaders. Transforming the vertex (which hides the actual skinning, instancing or billboarding process) is a slight hack which uses a combination of macros and functions: it is safest to copy the following piece of code verbatim: For HLSL: Shaders must be written separately for HLSL (Direct3D) and GLSL (OpenGL). The built-in shaders try to implement the same functionality on both shader languages as closely as possible. To get started with writing your own shaders, start with studying the most basic examples possible: the Basic, Shadow and Unlit shaders. Note the shader include files which bring common functionality, for example Uniforms.hlsl, Samplers.hlsl and Transform.hlsl for HLSL shaders. Transforming the vertex (which hides the actual skinning, instancing or billboarding process) is a slight hack which uses a combination of macros and functions: it is safest to copy the following piece of code verbatim: For HLSL: On both Direct3D and OpenGL the vertex and pixel shaders are written into the same file, and the entrypoint functions must be called VS() and PS(). In OpenGL mode one of these is transformed to the main() function required by GLSL behind the scenes. When compiling a vertex shader, the compilation define "COMPILEVS" is always present, and likewise "COMPILEPS" when compiling a pixel shader. These are heavily used in the shader include files to prevent constructs that are illegal for the "wrong" type of shader, and to reduce compilation time. The uniforms must be prefixed in a certain way so that the engine understands them: c for uniform constants, for example cMatDiffColor. The c is stripped when referred to inside the engine, so it would be called "MatDiffColor" in eg. s for texture samplers, for example sDiffMap. In GLSL shaders it is important that the samplers are assigned to the correct texture units. If you are using sampler names that are not predefined in the engine like sDiffMap, just make sure there is a number somewhere in the sampler's name and it will be interpreted as the texture unit. For example the terrain shader uses texture units 0-3 in the following way: The maximum number of bones supported for hardware skinning depends on the graphics API and is relayed to the shader code in the MAXBONES compilation define. Typically the maximum is 64, but is reduced to 32 on the Raspberry PI, and increased to 128 on Direct3D 11 and OpenGL 3. See also .

    API Differences

     Direct3D9 and Direct3D11 share the same HLSL shader code, and likewise OpenGL 2, OpenGL 3, OpenGL ES 2 and WebGL share the same GLSL code. Macros and some conditional code are used to hide the API differences where possible. When HLSL shaders are compiled for Direct3D11, the define D3D11 is present, and the following details need to be observed: Uniforms are organized into constant buffers. See the file Uniforms.hlsl for the built-in uniforms. See TerrainBlend.hlsl for an example of defining your own uniforms into the "custom" constant buffer slot. Both textures and samplers are defined for each texture unit. The macros in Samplers.hlsl (Sample2D, SampleCube etc.) can be used to write code that works on both APIs. These take the texture unit name without the 's' prefix. Vertex shader output position and pixel shader output color need to use the SV_POSITION and SV_TARGET semantics. The macros OUTPOSITION and OUTCOLOR0-3 can be used to select the correct semantic on both APIs. In the vertex shader, the output position should be specified last, as otherwise other interpolator outputs may not function correctly. On Direct3D11 the clip plane coordinate must be calculated manually. This is indicated by the CLIPPLANE compilation define, which is added automatically by the class. See for example the LitSolid.hlsl shader. Direct3D11 does not support luminance and luminance-alpha texture formats, but rather uses the R and RG channels. Therefore be prepared to perform swizzling in the texture reads as appropriate. Direct3D11 will fail to render if the vertex shader refers to vertex elements that don't exist in the vertex buffers. For OpenGL, the define GL3 is present when GLSL shaders are being compiled for OpenGL 3+, the define GL_ES is present for OpenGL ES 2, WEBGL define is present for WebGL and RPI define is present for the Raspberry Pi. Observe the following differences: On OpenGL 3 GLSL version 150 will be used if the shader source code does not define the version. The texture sampling functions are different but are worked around with defines in the file Samplers.glsl. Likewise the file Transform.glsl contains macros to hide the differences in declaring vertex attributes, interpolators and fragment outputs. On OpenGL 3 luminance, alpha and luminance-alpha texture formats are deprecated, and are replaced with R and RG formats. Therefore be prepared to perform swizzling in the texture reads as appropriate. On OpenGL ES 2 precision qualifiers need to be used.

    Shader Precaching

     The shader variations that are potentially used by a material technique in different lighting conditions and rendering passes are enumerated at material load time, but because of their large amount, they are not actually compiled or loaded from bytecode before being used in rendering. Especially on OpenGL the compiling of shaders just before rendering can cause hitches in the framerate. To avoid this, used shader combinations can be dumped out to an XML file, then preloaded. See , and in the subsystem. The command line parameters -ds FILE can be used to instruct the to begin dumping shaders automatically on startup. Note that the used shader variations will vary with graphics settings, for example shadow quality high/low or instancing on/off.     Constructs a new instance of Urho.Shader which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Shader, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Shader linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Finish resource loading. Always called from the main thread. Return true if successful. Return either vertex or pixel shader source code. Return a variation with defines. Register object factory. Return the latest timestamp of the shader code and its includes. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Material's shader parameter animation instance. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.ShaderParameterAnimationInfo, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return shader parameter name. Shader parameter groups for determining need to update. On APIs that support constant buffers, these correspond to different constant buffers. Utility class for collecting used shader combinations during runtime for precaching. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.ShaderPrecache, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. The context that this object will be attached to. Constructs a new instance of Urho.ShaderPrecache linked to a specific . Collect a shader combination. Called by Graphics when shaders have been set. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Linked shader program on the GPU. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.ShaderProgram, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Shader types. Vertex or pixel shader on the GPU. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.ShaderVariation, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return compile error/warning string. Return constant buffer data sizes. Compile the shader. Return true if successful. Return defines. Or Set defines. Return defines with the CLIPPLANE define appended. Used internally on Direct3D11 only, will be empty on other APIs. Return vertex element hash. Return full shader name. Return name. Or Set name. Return the owner resource. Release the shader. Return shader type. Shadow type. Hierarchical collection of bones. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Skeleton, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Clear bones. Return bone by index. Return bone by name hash. Return number of bones. Reset all animating bones to initial positions. Reset all animating bones to initial positions without marking the nodes dirty. Requires the node dirtying to be performed later. Return root bone. Set root bone's index. Static model component with fixed position in relation to the camera. Constructs a new instance of Urho.Skybox which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Skybox, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Skybox linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Register object factory. StaticModel must be registered first. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Transform smoothing component for network updates. Constructs a new instance of Urho.SmoothedTransform which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.SmoothedTransform, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.SmoothedTransform linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return whether smoothing is in progress. Register object factory. Set target position in world space. Set target rotation in world space. The handler to invoke when this event is raised. Subscribes to the TargetPositionChanged event raised by the SmoothedTransform. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the TargetRotationChanged event raised by the SmoothedTransform. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Return target position in parent space. Or Set target position in parent space. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return target rotation in parent space. Or Set target rotation in parent space. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return target position in world space. Return target rotation in world space. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Update smoothing. Spline for creating smooth movement based on Speed along a set of Control Points modified by the Interpolation Mode. Constructs a new instance of Urho.SplinePath which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.SplinePath, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.SplinePath linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add a Node to the SplinePath as a Control Point. Apply Attributes to the SplinePath. Clear the Control Points from the SplinePath. Get Controlled Node ID attribute. Or Set Controlled Node ID attribute. Get the controlled Node. Or Set the Node to be moved along the SplinePath. Draw the Debug Geometry. Returns whether the movement along the SplinePath is complete. Get a point on the SplinePath from 0.f to 1.f where 0 is the start and 1 is the end. Get the Interpolation Mode. Or Set the Interpolation Mode. Get the length of SplinePath; Move the controlled Node to the next position along the SplinePath based off the Speed value. Get the parent Node's last position on the spline. Register object factory. Remove a Node Control Point from the SplinePath. Reset movement along the path. Set the controlled Node's position on the SplinePath. Get the movement Speed. Or Set the movement Speed. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Static model component. Constructs a new instance of Urho.StaticModel which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.StaticModel, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.StaticModel linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Apply default materials from a material list file. If filename is empty (default), the model's resource name with extension .txt will be used. Draw to occlusion buffer. Return true if did not run out of triangles. Return the geometry for a specific LOD level. Return material by geometry index. Determines if the given world space point is within the model geometry. Determines if the given local space point is within the model geometry. Return model. Or Set model. Return model attribute. Return number of geometries. Return number of occlusion geometry triangles. Return occlusion LOD level. Or Set occlusion LOD level. By default (M_MAX_UNSIGNED) same as visible. Register object factory. Drawable must be registered first. Set material on all geometries. Set material on one geometry. Return true if successful. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Renders several object instances while culling and receiving light as one unit. Can be used as a CPU-side optimization, but note that also regular StaticModels will use instanced rendering if possible. Constructs a new instance of Urho.StaticModelGroup which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.StaticModelGroup, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.StaticModelGroup linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add an instance scene node. It does not need any drawable components of its own. Apply attribute changes that can not be applied immediately. Called after scene load or a network update. Draw to occlusion buffer. Return true if did not run out of triangles. Return instance node by index. Return number of instance nodes. Return number of occlusion geometry triangles. Register object factory. StaticModel must be registered first. Remove all instance scene nodes. Remove an instance scene node. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Stencil operation. Encapsulates the subscription to an event, the main use is to stop event delivery by unsubscribing or disposing. Instances of Subscription are returned from the various Subscribe methods exposed by the UrhoObject class.   When you want to stop receiving notifications for a subscription, invoke the  method or the  method. Unsubscribes from receiving notifications. Event arguments for the SmoothedTransform's TargetPositionChanged event Event arguments for the SmoothedTransform's TargetRotationChanged event Material technique. Consists of several passes. A technique definition looks like this: vs="VertexShaderName" ps="PixelShaderName" vsdefines="DEFINE1 DEFINE2" psdefines="DEFINE3 DEFINE4" lighting="unlit|pervertex|perpixel" blend="replace|add|multiply|alpha|addalpha|premulalpha|invdestalpha|subtract|subtractalpha" depthtest="always|equal|less|lessequal|greater|greaterequal" depthwrite="true|false" alphamask="true|false" /> ]]> The "desktop" attribute in either technique or pass allows to specify it requires desktop graphics hardware (exclude mobile devices.) Omitting it is the same as specifying false. Shaders are referred to by giving the name of a shader without path and file extension. For example "Basic" or "LitSolid". The engine will add the correct path and file extension (Shaders/HLSL/LitSolid.hlsl for Direct3D, and Shaders/GLSL/LitSolid.glsl for OpenGL) automatically. The same shader source file contains both the vertex and pixel shader. In addition, compilation defines can be specified, which are passed to the shader compiler. For example the define "DIFFMAP" typically enables diffuse mapping in the pixel shader. Shaders and their compilation defines can be specified on both the technique and pass level. If a pass does not override the default shaders specified on the technique level, it still can specify additional compilation defines to be used. However, if a pass overrides the shaders, then the technique-level defines are not used. The technique definition does not need to enumerate shaders used for different geometry types (non-skinned, skinned, instanced, billboard) and different per-vertex and per-pixel light combinations. Instead the engine will add certain hardcoded compilation defines for these. See for details. The purposes of the different passes are: base: Renders ambient light, per-vertex lights and fog for an opaque object. litbase: Renders the first per-pixel light, ambient light and fog for an opaque object. This is an optional pass for optimization. light: Renders one per-pixel light's contribution additively for an opaque object. alpha: Renders ambient light, per-vertex lights and fog for a transparent object. litalpha: Renders one per-pixel light's contribution additively for a transparent object postopaque: Custom rendering pass after opaque geometry. Can be used to render the skybox. refract: Custom rendering pass after postopaque pass. Can sample the viewport texture from the environment texture unit to render refractive objects. postalpha: Custom rendering pass after transparent geometry. prepass: Light pre-pass only - renders normals, specular power and depth to the G-buffer. material: Light pre-pass only - renders opaque geometry final color by combining ambient light, per-vertex lights and per-pixel light accumulation. deferred: Deferred rendering only - renders ambient light and per-vertex lights to the output rendertarget, and diffuse albedo, normals, specular intensity + power and depth to the G-buffer. depth: Renders linear depth to a rendertarget for post-processing effects. shadow: Renders to a hardware shadow map (depth only) for shadow map generation. More custom passes can be defined and referred to in the render path definition. For the built-in passes listed above, the lighting shader permutations to load (unlit, per-vertex or per-pixel) are recognized automatically, but for custom passes they need to be explicitly specified. The default is unlit. The optional "litbase" pass reduces draw call count by combining ambient lighting with the first per-pixel light affecting an object. However, it has intentional limitations to not require too many shader permutations: there must be no vertex lights affecting the object, and the ambient lighting can not have a gradient. In case of excessive overdraw, it is possibly better not to define it, but instead allow the base pass (which is computationally very lightweight) to run first, initializing the Z buffer for later passes. "Alphamask" is not an actual rendering state, but a hint which tells that the pixel shader will use discard based on alpha. Because this may interfere with the early-Z culling, materials without the alpha masking hint will be drawn first. The refract pass requires pingponging the scene rendertarget to a texture, but this will not be performed if there is no refractive geometry to render, so there is no unnecessary cost to it. Constructs a new instance of Urho.Technique which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Technique, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Technique linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Create a new pass. Indicates whether requires desktop level hardware. Return a pass by name, or null if not found. This overload should not be called in time-critical rendering loops; use a pre-acquired pass index instead. Return a pass, or null if not found. Return a pass type index by name. Allocate new if not used yet. Return a supported pass by name. This overload should not be called in time-critical rendering loops; use a pre-acquired pass index instead. Return a pass that is supported for rendering, or null if not found. Return whether has a pass by name. This overload should not be called in time-critical rendering loops; use a pre-acquired pass index instead. Return whether has a pass. Return number of passes. Register object factory. Reset shader pointers in all passes. Remove a pass. Set whether requires desktop level hardware. Indicates whether technique is supported by the current hardware. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Event arguments for the Serializable's TemporaryChanged event Heightmap terrain component. Constructs a new instance of Urho.Terrain which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Terrain, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Terrain linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Apply attribute changes that can not be applied immediately. Called after scene load or a network update. Apply changes from the heightmap image. Return shadowcaster flag. Or Set shadowcaster flag for patches. Regenerate patch geometry. Return draw distance. Or Set draw distance for patches. Return east neighbor terrain. Or Set east (positive X) neighbor terrain for seamless LOD changes across terrains. Return height at world coordinates. Return normal at world coordinates. Return patch by index. Return patch by patch coordinates. Return heightmap image. Return heightmap attribute. Return light mask. Or Set light mask for patches. Is and'ed with light's and zone's light mask to see if the object should be lit. Return LOD bias. Or Set LOD bias for patches. Affects which terrain LOD to display. Return material. Or Set material. Return material attribute. Return maximum number of per-pixel lights. Or Set maximum number of per-pixel lights for patches. Default 0 is unlimited. Return maximum number of LOD levels for terrain patches. This can be between 1-4. Or Set maximum number of LOD levels for terrain patches. This can be between 1-4. Return north neighbor terrain. Or Set north (positive Z) neighbor terrain for seamless LOD changes across terrains. Return heightmap size in patches. Return heightmap size in vertices. Controls the Occludee flag for patches. Controls the Occluder flag for patches. Return LOD level used for occlusion. Or Set LOD level used for terrain patch occlusion. By default (M_MAX_UNSIGNED) the coarsest. Since the LOD level used needs to be fixed, using finer LOD levels may result in false positive occlusion in cases where the actual rendered geometry is coarser, so use with caution. Handle enabled/disabled state change. Return patch quads per side. Or Set patch quads per side. Must be a power of two. Register object factory. Set heightmap image. Dimensions should be a power of two + 1. Uses 8-bit grayscale, or optionally red as MSB and green as LSB for 16-bit accuracy. Return true if successful. Set max LOD levels attribute. Set occlusion LOD level attribute. Set patch size attribute. Return shadow draw distance. Or Set shadow draw distance for patches. Return shadow mask. Or Set shadow mask for patches. Is and'ed with light's light mask and zone's shadow mask to see if the object should be rendered to a shadow map. Return whether smoothing is in use. Or Set smoothing of heightmap. Return south neighbor terrain. Or Set south (negative Z) neighbor terrain for seamless LOD changes across terrains. Return vertex and height spacing. Or Set vertex (XZ) and height (Y) spacing. The handler to invoke when this event is raised. Subscribes to the TerrainCreated event raised by the Terrain. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Update patch based on LOD and neighbor LOD. Return view mask. Or Set view mask for patches. Is and'ed with camera's view mask to see if the object should be rendered. Return visible flag. Return west neighbor terrain. Or Set west (negative X) neighbor terrain for seamless LOD changes across terrains. Convert world position to heightmap pixel position. Note that the internal height data representation is reversed vertically, but in the heightmap image north is at the top. Return zone mask. Or Set zone mask for patches. Is and'ed with zone's zone mask to see if the object should belong to the zone. Event arguments for the Terrain's TerrainCreated event Individually rendered part of a heightmap terrain. Constructs a new instance of Urho.TerrainPatch which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.TerrainPatch, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.TerrainPatch linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return patch coordinates. Or Set patch coordinates. Visualize the component as debug geometry. Draw to occlusion buffer. Return true if did not run out of triangles. Return east neighbor patch. Return visible geometry. Return the geometry for a specific LOD level. Return current LOD level. Return max LOD geometry. Used for decals. Return north neighbor patch. Return number of occlusion geometry triangles. Return geometry used for occlusion. Return owner terrain. Or Set owner terrain. Register object factory. Reset to LOD level 0. Set local-space bounding box. Set material. Set neighbor patches. Return south neighbor patch. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return whether a geometry update is necessary, and if it can happen in a worker thread. Return vertex buffer. Return west neighbor patch. Event arguments for the Input's TextInput event Base class for texture resources. Constructs a new instance of Urho.Texture which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Texture, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Texture linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return texture max. anisotropy level. Value 0 means to use the default value from Renderer. Or Set texture max. anisotropy level. No effect if not using anisotropic filtering. Value 0 (default) uses the default setting from Renderer. Return texture multisampling autoresolve mode. When true, the texture is resolved before being sampled on SetTexture(). When false, the texture will not be resolved and must be read as individual samples in the shader. Return backup texture. Or Set backup texture to use when rendering to this texture. Return border color. Or Set border color for border addressing mode. Check maximum allowed mip levels for a specific texture size. Check maximum allowed mip levels for a specific 3D texture size. Return number of image components required to receive pixel data from GetData(), or 0 for compressed images. Return whether the texture format is compressed. Return height. Return filtering mode. Or Set filtering mode. Return texture format. Return addressing mode by texture coordinate. Return data size in bytes for a rectangular region. Return data size in bytes for a volume region. Return mip level depth, or 0 if level does not exist. Return mip level width, or 0 if level does not exist. Return mip level width, or 0 if level does not exist. Return mip levels to skip on a quality setting when loading. Return data size in bytes for a pixel or block row. Return the corresponding SRGB texture format if supported. If not supported, return format unchanged. Return height. Return number of mip levels. Return whether rendertarget mipmap levels need regenration. Return texture multisampling level (1 = no multisampling). Return whether parameters are dirty. Regenerate mipmap levels for a rendertarget after rendering and before sampling. Called internally by Graphics. No-op on Direct3D9. On OpenGL the texture must have been bound to work properly. Set or clear the need resolve flag. Called internally by Graphics. Return resolve texture. Only used on Direct3D11. Return sampler state object. Only used on Direct3D11. Set addressing mode by texture coordinate. Set the mipmap levels dirty flag. Called internally by Graphics. Set mip levels to skip on a quality setting when loading. Ensures higher quality levels do not skip more. Set number of requested mip levels. Needs to be called before setting size. Set additional parameters from an XML element. Set additional parameters from an XML file. Dirty the parameters. Return shader resource view. Only used on Direct3D11. Return whether shadow compare is enabled. Or Set shadow compare mode. Return whether is using sRGB sampling and writing. Or Set sRGB sampling and writing mode. Update changed parameters to OpenGL. Called by Graphics when binding the texture. Return texture usage type. Return width. 2D texture array resource. Constructs a new instance of Urho.Texture2DArray which is tied to the . Constructs a new instance of Urho.Texture2DArray linked to a specific . Finish resource loading. Always called from the main thread. Return true if successful. Return number of layers in the texture. Or Set the number of layers in the texture. To be used before SetData. Mark the GPU resource destroyed on context destruction. Recreate the GPU resource and restore data if applicable. Release the texture. Return render surface. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. 3D texture resource. Constructs a new instance of Urho.Texture3D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Texture3D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Texture3D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Finish resource loading. Always called from the main thread. Return true if successful. Get data from a mip level. The destination buffer must be big enough. Return true if successful. Register object factory. Release the texture. Set data either partially or fully on a mip level. Return true if successful. Set size, format and usage. Zero size will follow application window size. Return true if successful. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Texture addressing mode. Texture coordinates. Cube texture resource. Constructs a new instance of Urho.TextureCube which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.TextureCube, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.TextureCube linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Finish resource loading. Always called from the main thread. Return true if successful. Get data from a face's mip level. The destination buffer must be big enough. Return true if successful. Return render surface for one face. Register object factory. Release the texture. Set data either partially or fully on a face's mip level. Return true if successful. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Texture filtering mode. Texture units. Texture usage types. %Time and frame counter subsystem. Constructs a new instance of Urho.Time which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Time, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Time linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Begin new frame, with (last) frame duration in seconds and send frame start event. This raises the  event. Return elapsed time from program start as seconds. End frame. Increment total time and send frame end event. This raises the  event. End frame event, invoked from the  method. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return frame number, starting from 1 once BeginFrame() is called for the first time. Return current frames per second. Signals the beginning of the new frame.  and  react to this to check for operating system window messages and arrived network packets. Sleep for a number of milliseconds. Get system time as milliseconds. Return current low-resolution timer period in milliseconds. Or Set the low-resolution timer period in milliseconds. 0 resets to the default period. Get system time as seconds since 1.1.1970. Get a date/time stamp as a string. Return current frame timestep as seconds. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Event arguments for the Input's TouchBegin event Event arguments for the Input's TouchEnd event Event arguments for the Input's TouchMove event Transform space for translations and rotations. Triangle mesh geometry data. Urho's type system type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Construct. Return material which will be used for rendering UI texture. Return UIElement. Return texture which will be used for rendering UI to. Placeholder for allowing unregistered components to be loaded Constructs a new instance of Urho.UnknownComponent which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.UnknownComponent, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.UnknownComponent linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Register object factory. Initialize the type hash only when type name not known. Called by Node when loading. Initialize the type name. Called by Node when loading. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return whether was loaded using XML data. Event arguments for the Engine's Update event Geometry update type. Event arguments for the Scene's UpdateSmoothing event %Console window with log history and command line prompt. Constructs a new instance of Urho.UrhoConsole which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.UrhoConsole, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.UrhoConsole linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Controls whether the console is set to automatically visible when receiving an error log message. Return the background element. Return the close butoon element. Return the last used command interpreter. Or Set the command interpreter. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Copy selected rows to system clipboard. Return the UI style file. Or Set UI elements' style from an XML file. Return whether automatically focuses the line edit when showing. Or Set whether to automatically focus the line edit when showing. Default true on desktops and false on mobile devices, as on mobiles it would pop up the screen keyboard. Return history row at index. Return current history position. Return the line edit element. Return number of buffered rows. Or Set number of buffered rows. Return history maximum size. Or Set command history maximum size, 0 disables history. Return number of displayed rows. Or Set number of displayed rows. The handler to invoke when this event is raised. Subscribes to the ConsoleCommand event raised by the UrhoConsole. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Toggle visibility. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Update elements to layout properly. Call this after manually adjusting the sub-elements. Show or hide the console. Base class for objects with type identification, subsystem access and event sending/receiving capability. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.UrhoObject, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return sending and receiving events blocking status. Or Block object from sending and receiving events. Return object category. Categories are (optionally) registered along with the object factory. Return an empty string if the object category is not registered. Return execution context. Return active event handler. Null outside event handling. Return active event sender. Null outside event handling. Return subsystem by type. Return whether has subscribed to any event. Return whether has subscribed to an event without specific sender. Return whether has subscribed to a specific sender's event. Send event to all subscribers. Subscribe to an event that can be sent by any sender. Subscribe to a specific sender's event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Return type info. Return type info static. Urho's low-level type name. Stringified low-level type name. Unsubscribe from all events. Unsubscribe from an event. Unsubscribe from a specific sender's event. Unsubscribe from a specific sender's events. Value animation class. Constructs a new instance of Urho.ValueAnimation which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.ValueAnimation, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.ValueAnimation linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return begin time. Return end time. Return animation value. Has event frames. Return interpolation method. Or Set interpolation method. Return owner. Or Set owner. Register object factory. Set key frame. Set key frame. Set key frame. Set key frame. Set key frame. Set key frame. Set key frame. Set key frame. Set key frame. Set key frame. Return spline tension. Or Set spline tension, should be between 0.0f and 1.0f, but this is not a must. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return animation is valid. Return value type. Or Set value type. Base class for a value animation instance, which includes animation runtime information and updates the target object's value automatically. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.ValueAnimationInfo, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return animation. Return speed. Or Set speed. Return target object. Return time position. Update. Return true when the animation is finished. No-op when the target object is not defined. Return wrap mode. Or Set wrap mode. Urho's type system type. This returns the Urho's type and is surfaced for low-level Urho code. Variant's supported types. Represents a 2D vector using two single-precision floating-point numbers. The Vector2 structure is suitable for interoperation with unmanaged code requiring two consecutive floats. The Vector2 to copy components from. Constructs a new Vector2 from the given Vector2. The Vector3 to copy components from. Z is discarded. Constructs a new Vector2 from the given Vector3. The Vector4 to copy components from. Z and W are discarded. Constructs a new Vector2 from the given Vector4. The x coordinate of the net Vector2. The y coordinate of the net Vector2. Constructs a new Vector2. Right operand. This parameter is only read from. Add the Vector passed as parameter to this instance. Right operand. This parameter is only read from. Add the Vector passed as parameter to this instance. Left operand. Right operand. Adds two vectors. Result of operation. Left operand. Right operand. Result of operation. Adds two vectors. First input Vector Second input Vector Third input Vector First Barycentric Coordinate Second Barycentric Coordinate Interpolate 3 Vectors using Barycentric coordinates a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise First input Vector. Second input Vector. Third input Vector. First Barycentric Coordinate. Second Barycentric Coordinate. Output Vector. a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise Interpolate 3 Vectors using Barycentric coordinates Input vector Minimum vector Maximum vector Clamp a vector to the given minimum and maximum vectors The clamped vector Input vector Minimum vector Maximum vector The clamped vector Clamp a vector to the given minimum and maximum vectors First operand Second operand Calculate the component-wise maximum of two vectors The component-wise maximum First operand Second operand The component-wise maximum Calculate the component-wise maximum of two vectors First operand Second operand Calculate the component-wise minimum of two vectors The component-wise minimum First operand Second operand The component-wise minimum Calculate the component-wise minimum of two vectors Scalar operand. Divide this instance by a scalar. Vector operand Scalar operand Divide a vector by a scalar Result of the division Vector operand Scalar operand Result of the division Divide a vector by a scalar Left operand. Right operand. Divides a vector by a scalar. Result of the operation. Left operand. Right operand. Divides a vector by the components of a vector (scale). Result of the operation. Left operand. Right operand. Result of the operation. Divides a vector by a scalar. Left operand. Right operand. Result of the operation. Divide a vector by the components of a vector (scale). First operand Second operand Calculate the dot (scalar) product of two vectors The dot product of the two inputs First operand Second operand The dot product of the two inputs Calculate the dot (scalar) product of two vectors The object to compare to. Indicates whether this instance and a specified object are equal. True if the instances are equal; false otherwise. A vector to compare with this vector. Indicates whether the current vector is equal to another vector. true if the current vector is equal to the vector parameter; otherwise, false. Returns the hashcode for this instance. A System.Int32 containing the unique hashcode for this instance. Gets the length (magnitude) of the vector. Gets an approximation of the vector length (magnitude). This property uses an approximation of the square root function to calculate vector magnitude, with an upper error bound of 0.001. Gets the square of the vector length (magnitude). This property avoids the costly square root operation required by the Length property. This makes it more suitable for comparisons. First input vector Second input vector The blend factor. a when blend=0, b when blend=1. Returns a new Vector that is the linear blend of the 2 given Vectors a when blend=0, b when blend=1, and a linear combination otherwise First input vector Second input vector The blend factor. a when blend=0, b when blend=1. a when blend=0, b when blend=1, and a linear combination otherwise Returns a new Vector that is the linear blend of the 2 given Vectors Left operand Right operand Returns the Vector3 with the minimum magnitude The minimum Vector3 Left operand Right operand Returns the Vector3 with the minimum magnitude The minimum Vector3 Scalar operand. Multiply this instance by a scalar. Vector operand Scalar operand Multiply a vector and a scalar Result of the multiplication Vector operand Scalar operand Result of the multiplication Multiply a vector and a scalar Left operand. Right operand. Multiplies a vector by a scalar. Result of the operation. Left operand. Right operand. Multiplies a vector by the components a vector (scale). Result of the operation. Left operand. Right operand. Result of the operation. Multiplies a vector by a scalar. Left operand. Right operand. Result of the operation. Multiplies a vector by the components of a vector (scale). Scales the Vector2 to unit length. The input vector Scale a vector to unit length The normalized vector The input vector The normalized vector Scale a vector to unit length Scales the Vector2 to approximately unit length. The input vector Scale a vector to approximately unit length The normalized vector The input vector The normalized vector Scale a vector to approximately unit length Defines an instance with all components set to 1. Left operand. Right operand. Adds the specified instances. Result of addition. Left operand Right operand Divides the specified instance by a scalar. Result of the division. Left operand. Right operand. Compares the specified instances for equality. True if both instances are equal; false otherwise. Left operand. Right operand. Compares the specified instances for inequality. True if both instances are not equal; false otherwise. Left operand. Right operand. Multiplies the specified instance by a scalar. Result of multiplication. Left operand. Right operand. Multiplies the specified instance by a scalar. Result of multiplication. Left operand. Right operand. Subtracts the specified instances. Result of subtraction. Operand. Negates the specified instance. Result of negation. Gets the perpendicular vector on the left side of this vector. Gets the perpendicular vector on the right side of this vector. The scaling of the individual components. Scales this instance by the given parameter. The scaling of the individual components. Scales this instance by the given parameter. The scale of the X component. The scale of the Y component. Scales the current Vector2 by the given amounts. Defines the size of the Vector2 struct in bytes. Right operand. This parameter is only read from. Subtract the Vector passed as parameter from this instance. Right operand. This parameter is only read from. Subtract the Vector passed as parameter from this instance. First operand Second operand Subtract one Vector from another Result of subtraction First operand Second operand Result of subtraction Subtract one Vector from another First operand Second operand Subtract one Vector from another Result of subtraction First operand Second operand Result of subtraction Subtract one Vector from another Returns a System.String that represents the current Vector2. Defines a unit-length Vector2 that points towards the X-axis. Defines a unit-length Vector2 that points towards the Y-axis. The X component of the Vector2. The Y component of the Vector2. Defines a zero-length Vector2. Represents a 3D vector using three single-precision floating-point numbers. The Vector3 structure is suitable for interoperation with unmanaged code requiring three consecutive floats. The Vector2 to copy components from. Constructs a new Vector3 from the given Vector2. The Vector3 to copy components from. Constructs a new Vector3 from the given Vector3. The Vector4 to copy components from. Constructs a new Vector3 from the given Vector4. The x component of the Vector3. The y component of the Vector3. The z component of the Vector3. Constructs a new Vector3. Right operand. This parameter is only read from. Add the Vector passed as parameter to this instance. Right operand. This parameter is only read from. Add the Vector passed as parameter to this instance. Left operand. Right operand. Adds two vectors. Result of operation. Left operand. Right operand. Result of operation. Adds two vectors. First input Vector Second input Vector Third input Vector First Barycentric Coordinate Second Barycentric Coordinate Interpolate 3 Vectors using Barycentric coordinates a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise First input Vector. Second input Vector. Third input Vector. First Barycentric Coordinate. Second Barycentric Coordinate. Output Vector. a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise Interpolate 3 Vectors using Barycentric coordinates The first vector. The second vector. Calculates the angle (in radians) between two vectors. Angle (in radians) between the vectors. Note that the returned angle is never bigger than the constant Pi. The first vector. The second vector. Angle (in radians) between the vectors. Calculates the angle (in radians) between two vectors. Note that the returned angle is never bigger than the constant Pi. Input vector Minimum vector Maximum vector Clamp a vector to the given minimum and maximum vectors The clamped vector Input vector Minimum vector Maximum vector The clamped vector Clamp a vector to the given minimum and maximum vectors First operand Second operand Calculate the component-wise maximum of two vectors The component-wise maximum First operand Second operand The component-wise maximum Calculate the component-wise maximum of two vectors First operand Second operand Calculate the component-wise minimum of two vectors The component-wise minimum First operand Second operand The component-wise minimum Calculate the component-wise minimum of two vectors First operand Second operand Caclulate the cross (vector) product of two vectors The cross product of the two inputs First operand Second operand The cross product of the two inputs Caclulate the cross (vector) product of two vectors Scalar operand. Divide this instance by a scalar. Vector operand Scalar operand Divide a vector by a scalar Result of the division Vector operand Scalar operand Result of the division Divide a vector by a scalar Left operand. Right operand. Divides a vector by a scalar. Result of the operation. Left operand. Right operand. Divides a vector by the components of a vector (scale). Result of the operation. Left operand. Right operand. Result of the operation. Divides a vector by a scalar. Left operand. Right operand. Result of the operation. Divide a vector by the components of a vector (scale). First operand Second operand Calculate the dot (scalar) product of two vectors The dot product of the two inputs First operand Second operand The dot product of the two inputs Calculate the dot (scalar) product of two vectors The object to compare to. Indicates whether this instance and a specified object are equal. True if the instances are equal; false otherwise. A vector to compare with this vector. Indicates whether the current vector is equal to another vector. true if the current vector is equal to the vector parameter; otherwise, false. Returns the hashcode for this instance. A System.Int32 containing the unique hashcode for this instance. Gets the length (magnitude) of the vector. Gets an approximation of the vector length (magnitude). This property uses an approximation of the square root function to calculate vector magnitude, with an upper error bound of 0.001. Gets the square of the vector length (magnitude). This property avoids the costly square root operation required by the Length property. This makes it more suitable for comparisons. First input vector Second input vector The blend factor. a when blend=0, b when blend=1. Returns a new Vector that is the linear blend of the 2 given Vectors a when blend=0, b when blend=1, and a linear combination otherwise First input vector Second input vector The blend factor. a when blend=0, b when blend=1. a when blend=0, b when blend=1, and a linear combination otherwise Returns a new Vector that is the linear blend of the 2 given Vectors Left operand Right operand Returns the Vector3 with the minimum magnitude The minimum Vector3 Left operand Right operand Returns the Vector3 with the minimum magnitude The minimum Vector3 Scalar operand. Multiply this instance by a scalar. Vector operand Scalar operand Multiply a vector and a scalar Result of the multiplication Vector operand Scalar operand Result of the multiplication Multiply a vector and a scalar Left operand. Right operand. Multiplies a vector by a scalar. Result of the operation. Left operand. Right operand. Multiplies a vector by the components a vector (scale). Result of the operation. Left operand. Right operand. Result of the operation. Multiplies a vector by a scalar. Left operand. Right operand. Result of the operation. Multiplies a vector by the components of a vector (scale). Scales the Vector3 to unit length. The input vector Scale a vector to unit length The normalized vector The input vector The normalized vector Scale a vector to unit length Scales the Vector3 to approximately unit length. The input vector Scale a vector to approximately unit length The normalized vector The input vector The normalized vector Scale a vector to approximately unit length Defines an instance with all components set to 1. The first instance. The second instance. Adds two instances. The result of the calculation. The instance. The scalar. Divides an instance by a scalar. The result of the calculation. The first instance. The second instance. Compares two instances for equality. True, if left equals right; false otherwise. The first instance. The second instance. Compares two instances for inequality. True, if left does not equa lright; false otherwise. The scalar. The instance. Multiplies an instance by a scalar. The result of the calculation. The instance. The scalar. Multiplies an instance by a scalar. The result of the calculation. The first instance. The second instance. Subtracts two instances. The result of the calculation. The instance. Negates an instance. The result of the calculation. The scaling of the individual components. Scales this instance by the given parameter. The scaling of the individual components. Scales this instance by the given parameter. The scale of the X component. The scale of the Y component. The scale of the Z component. Scales the current Vector3 by the given amounts. Right operand. This parameter is only read from. Subtract the Vector passed as parameter from this instance. Right operand. This parameter is only read from. Subtract the Vector passed as parameter from this instance. First operand Second operand Subtract one Vector from another Result of subtraction First operand Second operand Result of subtraction Subtract one Vector from another First operand Second operand Subtract one Vector from another Result of subtraction First operand Second operand Result of subtraction Subtract one Vector from another Returns a System.String that represents the current Vector3. The vector to transform The desired transformation Transform a Vector by the given Matrix The transformed vector The vector to transform The desired transformation The transformed vector Transform a Vector by the given Matrix The normal to transform The desired transformation Transform a Normal by the given Matrix The transformed normal This calculates the inverse of the given matrix, use TransformNormalInverse if you already have the inverse to avoid this extra calculation The normal to transform The desired transformation The transformed normal Transform a Normal by the given Matrix This calculates the inverse of the given matrix, use TransformNormalInverse if you already have the inverse to avoid this extra calculation The normal to transform The inverse of the desired transformation Transform a Normal by the (transpose of the) given Matrix The transformed normal This version doesn't calculate the inverse matrix. Use this version if you already have the inverse of the desired transform to hand The normal to transform The inverse of the desired transformation The transformed normal Transform a Normal by the (transpose of the) given Matrix This version doesn't calculate the inverse matrix. Use this version if you already have the inverse of the desired transform to hand The vector to transform The desired transformation Transform a Vector3 by the given Matrix, and project the resulting Vector4 back to a Vector3 The transformed vector The vector to transform The desired transformation The transformed vector Transform a Vector3 by the given Matrix, and project the resulting Vector4 back to a Vector3 The position to transform The desired transformation Transform a Position by the given Matrix The transformed position The position to transform The desired transformation The transformed position Transform a Position by the given Matrix The vector to transform The desired transformation Transform a direction vector by the given Matrix Assumes the matrix has a bottom row of (0,0,0,1), that is the translation part is ignored. The transformed vector The vector to transform The desired transformation The transformed vector Transform a direction vector by the given Matrix Assumes the matrix has a bottom row of (0,0,0,1), that is the translation part is ignored. Defines a unit-length Vector3 that points towards the X-axis. Defines a unit-length Vector3 that points towards the Y-axis. /// Defines a unit-length Vector3 that points towards the Z-axis. The X component of the Vector3. Gets or sets an OpenTK.Vector2 with the X and Y components of this instance. The Y component of the Vector3. The Z component of the Vector3. Defines a zero-length Vector3. Represents a 4D vector using four single-precision floating-point numbers. The Vector4 structure is suitable for interoperation with unmanaged code requiring four consecutive floats. The Vector2 to copy components from. Constructs a new Vector4 from the given Vector2. The Vector3 to copy components from. Constructs a new Vector4 from the given Vector3. The Vector4 to copy components from. Constructs a new Vector4 from the given Vector4. The Vector3 to copy components from. The W component of the new Vector4. Constructs a new Vector4 from the specified Vector3 and W component. The x component of the Vector4. The y component of the Vector4. The z component of the Vector4. The z component of the Vector4. Constructs a new Vector4. Right operand. This parameter is only read from. Add the Vector passed as parameter to this instance. Right operand. This parameter is only read from. Add the Vector passed as parameter to this instance. Left operand. Right operand. Adds two vectors. Result of operation. Left operand. Right operand. Result of operation. Adds two vectors. First input Vector Second input Vector Third input Vector First Barycentric Coordinate Second Barycentric Coordinate Interpolate 3 Vectors using Barycentric coordinates a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise First input Vector. Second input Vector. Third input Vector. First Barycentric Coordinate. Second Barycentric Coordinate. Output Vector. a when u=v=0, b when u=1,v=0, c when u=0,v=1, and a linear combination of a,b,c otherwise Interpolate 3 Vectors using Barycentric coordinates Input vector Minimum vector Maximum vector Clamp a vector to the given minimum and maximum vectors The clamped vector Input vector Minimum vector Maximum vector The clamped vector Clamp a vector to the given minimum and maximum vectors Scalar operand. Divide this instance by a scalar. Vector operand Scalar operand Divide a vector by a scalar Result of the division Vector operand Scalar operand Result of the division Divide a vector by a scalar Left operand. Right operand. Divides a vector by a scalar. Result of the operation. Left operand. Right operand. Divides a vector by the components of a vector (scale). Result of the operation. Left operand. Right operand. Result of the operation. Divides a vector by a scalar. Left operand. Right operand. Result of the operation. Divide a vector by the components of a vector (scale). First operand Second operand Calculate the dot product of two vectors The dot product of the two inputs First operand Second operand The dot product of the two inputs Calculate the dot product of two vectors The object to compare to. Indicates whether this instance and a specified object are equal. True if the instances are equal; false otherwise. A vector to compare with this vector. Indicates whether the current vector is equal to another vector. true if the current vector is equal to the vector parameter; otherwise, false. Returns the hashcode for this instance. A System.Int32 containing the unique hashcode for this instance. Gets the length (magnitude) of the vector. Gets an approximation of the vector length (magnitude). This property uses an approximation of the square root function to calculate vector magnitude, with an upper error bound of 0.001. Gets the square of the vector length (magnitude). This property avoids the costly square root operation required by the Length property. This makes it more suitable for comparisons. First input vector Second input vector The blend factor. a when blend=0, b when blend=1. Returns a new Vector that is the linear blend of the 2 given Vectors a when blend=0, b when blend=1, and a linear combination otherwise First input vector Second input vector The blend factor. a when blend=0, b when blend=1. a when blend=0, b when blend=1, and a linear combination otherwise Returns a new Vector that is the linear blend of the 2 given Vectors First operand Second operand Calculate the component-wise maximum of two vectors The component-wise maximum First operand Second operand The component-wise maximum Calculate the component-wise maximum of two vectors First operand Second operand Calculate the component-wise minimum of two vectors The component-wise minimum First operand Second operand The component-wise minimum Calculate the component-wise minimum of two vectors Scalar operand. Multiply this instance by a scalar. Vector operand Scalar operand Multiply a vector and a scalar Result of the multiplication Vector operand Scalar operand Result of the multiplication Multiply a vector and a scalar Left operand. Right operand. Multiplies a vector by a scalar. Result of the operation. Left operand. Right operand. Multiplies a vector by the components a vector (scale). Result of the operation. Left operand. Right operand. Result of the operation. Multiplies a vector by a scalar. Left operand. Right operand. Result of the operation. Multiplies a vector by the components of a vector (scale). Scales the Vector4 to unit length. The input vector Scale a vector to unit length The normalized vector The input vector The normalized vector Scale a vector to unit length Scales the Vector4 to approximately unit length. The input vector Scale a vector to approximately unit length The normalized vector The input vector The normalized vector Scale a vector to approximately unit length Defines an instance with all components set to 1. The first instance. The second instance. Adds two instances. The result of the calculation. The instance. The scalar. Divides an instance by a scalar. The result of the calculation. The first instance. The second instance. Compares two instances for equality. True, if left equals right; false otherwise. The instance. Returns a pointer to the first element of the specified instance. A pointer to the first element of v. The instance. Returns a pointer to the first element of the specified instance. A pointer to the first element of v. The first instance. The second instance. Compares two instances for inequality. True, if left does not equa lright; false otherwise. The scalar. The instance. Multiplies an instance by a scalar. The result of the calculation. The instance. The scalar. Multiplies an instance by a scalar. The result of the calculation. The first instance. The second instance. Subtracts two instances. The result of the calculation. The instance. Negates an instance. The result of the calculation. The scaling of the individual components. Scales this instance by the given parameter. The scaling of the individual components. Scales this instance by the given parameter. The scale of the X component. The scale of the Y component. The scale of the Z component. The scale of the Z component. Scales the current Vector4 by the given amounts. Defines the size of the Vector4 struct in bytes. Right operand. This parameter is only read from. Subtract the Vector passed as parameter from this instance. Right operand. This parameter is only read from. Subtract the Vector passed as parameter from this instance. First operand Second operand Subtract one Vector from another Result of subtraction First operand Second operand Result of subtraction Subtract one Vector from another First operand Second operand Subtract one Vector from another Result of subtraction First operand Second operand Result of subtraction Subtract one Vector from another Returns a System.String that represents the current Vector4. The vector to transform The desired transformation Transform a Vector by the given Matrix The transformed vector The vector to transform The desired transformation The transformed vector Transform a Vector by the given Matrix Defines a unit-length Vector4 that points towards the W-axis. Defines a unit-length Vector4 that points towards the X-axis. Defines a unit-length Vector4 that points towards the Y-axis. Defines a unit-length Vector4 that points towards the Z-axis. The W component of the Vector4. The X component of the Vector4. Gets or sets an OpenTK.Vector2 with the X and Y components of this instance. Gets or sets an OpenTK.Vector3 with the X, Y and Z components of this instance. The Y component of the Vector4. The Z component of the Vector4. Defines a zero-length Vector4. Represents a vector that can be retrieved in different formats. When you have a VectorBase, you can retrieve the data pointed to by the buffer with the given size into a managed array by invoking the generic ToArray method. Pointer to the buffer holding the vector data. Capacity for the vector The current size of the vector. Hardware vertex buffer. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.VertexBuffer, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. The context that this object will be attached to. Constructs a new instance of Urho.VertexBuffer linked to a specific . Return whether is dynamic.. Return bitmask of vertex elements. Return vertex size corresponding to a vertex element mask. Lock the buffer for write-only editing. Return data pointer if successful. Optionally discard data outside the range. Return whether is currently locked. Mark the buffer destroyed on graphics context destruction. May be a no-op depending on the API. Release the buffer. Set all data in the buffer. Set a data range in the buffer. Optionally discard data outside the range. Set size and vertex elements and dynamic mode. Previous data will be lost. Return CPU memory shadow data. Controls CPU memory shadowing. Controls shadowing in CPU memory. Shadowing is forced on if the graphics subsystem does not exist. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Unlock the buffer and apply changes to the GPU buffer. Return number of vertices. Return vertex size. Vertex elements. Semantic index of element, for example multi-texcoords. Offset of element from vertex start. Filled by VertexBuffer once the vertex declaration is built. Per-instance flag. Arbitrary vertex declaration element semantics. Arbitrary vertex declaration element datatypes. Per-vertex light vertex shader variations. Internal structure for 3D rendering work. Created for each backbuffer and texture viewport, but not for shadow cameras. Constructs a new instance of Urho.View which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.View, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.View linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return camera. Return culling camera. Normally same as the viewport camera. Define with rendertarget and viewport. Return true if successful. Return whether should draw debug geometry. Draw a fullscreen quad. Shaders and renderstates must have been set beforehand. Quad will be drawn to the middle of depth range, similarly to deferred directional lights. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Get a named texture from the rendertarget list or from the resource cache, to be either used as a rendertarget or texture binding. Return graphics subsystem. Return number of occluders that were actually rendered. Occluders may be rejected if running out of triangles or if behind other occluders. Return the last used software occlusion buffer. Return octree. Render batches. Return renderer subsystem. Return the rendertarget. 0 if using the backbuffer. Return scene. Set camera-specific shader parameters. Called by Batch and internally by View. Set command's shader parameters if any. Called internally by View. Set G-buffer offset and inverse size shader parameters. Called by Batch and internally by View. Set global (per-frame) shader parameters. Called by Batch and internally by View. Internal use. Return the source view that was already prepared. Used when viewports specify the same culling camera. The handler to invoke when this event is raised. Subscribes to the BeginViewUpdate event raised by the View. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the EndViewUpdate event raised by the View. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return view rectangle. Return view dimensions. Viewport definition either for a render surface or the backbuffer. Constructs a new instance of Urho.Viewport which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Viewport, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Viewport linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. The context that this object will be attached to. Creates an instance of Viewport that is attached to an execution context. This creates an instance of Viewport attached to the specified execution context. The context that this object will be attached to. Creates an instance of Viewport that is attached to an execution context. This creates an instance of Viewport attached to the specified execution context. Allocate the view structure. Called by Renderer. Return camera. Or Set camera. Return the culling camera. If null, the viewport camera will be used for culling (normal case.) Or Set separate camera to use for culling. Sharing a culling camera between several viewports allows to prepare the view only once, saving in CPU use. The culling camera's frustum should cover all the viewport cameras' frusta or else objects may be missing from the rendered view. Return whether to draw debug geometry. Or Set whether to render debug geometry. Default true. Return ray corresponding to normalized screen coordinates. Return rectangle. Or Set rectangle. Return rendering path. Or Set rendering path. Return scene. Or Set scene. The color to set. Sets the clear color on all clear render commands in the render path.  This walks the list of commands in the  and for each command with the value  Clear, it sets the UseFogColor property to zero, and the ClearColor value to the specified . Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return the internal rendering structure. May be null if the viewport has not been rendered yet. Supports the Urho interoperability engine, a weak native urho pointer. Not to be used by user code. Event arguments for the WorkQueue's WorkItemCompleted event Work queue subsystem for multithreading. Constructs a new instance of Urho.WorkQueue which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.WorkQueue, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.WorkQueue linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Finish all queued work which has at least the specified priority. Main thread will also execute priority work. Pause worker threads if no more work remains. Return whether the queue is currently completing work in the main thread. Create worker threads. Can only be called once. Get pointer to an usable WorkItem from the item pool. Allocate one if no more free items. Return whether all work with at least the specified priority is finished. Return how many milliseconds maximum to spend on non-threaded low-priority work. Or Set how many milliseconds maximum per frame to spend on low-priority work, when there are no worker threads. Return number of worker threads. Pause worker threads. Resume worker threads. The handler to invoke when this event is raised. Subscribes to the WorkItemCompleted event raised by the WorkQueue. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Return the pool tolerance. Or Set the pool telerance before it starts deleting pool items. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Animation wrap mode. %Component that describes global rendering properties. Constructs a new instance of Urho.Zone which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Zone, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Zone linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return zone's own ambient color, disregarding gradient mode. Or Set ambient color Return ambient end color. Not safe to call from worker threads due to possible octree query. Return whether ambient gradient mode is enabled. Or Set ambient gradient mode. In gradient mode ambient color is interpolated from neighbor zones. Return ambient start color. Not safe to call from worker threads due to possible octree query. Visualize the component as debug geometry. Return fog color. Or Set fog color. Return fog end distance. Or Set fog end distance. Return fog height distance relative to the scene node's world position. Or Set fog height distance relative to the scene node's world position. Effective only in height fog mode. Return fog height scale. Or Set fog height scale. Effective only in height fog mode. Return fog start distance. Or Set fog start distance. Return whether height fog mode is enabled. Or Set height fog mode. Return inverse world transform. Check whether a point is inside. Return whether override mode is enabled. Or Set override mode. If camera is inside an override zone, that zone will be used for all rendered objects instead of their own zone. Return zone priority. Or Set zone priority. If an object or camera is inside several zones, the one with highest priority is used. Register object factory. Drawable must be registered first. Set local-space bounding box. Will be used as an oriented bounding box to test whether objects or the camera are inside. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return zone texture. Or Set zone texture. This will be bound to the zone texture unit when rendering objects inside the zone. Note that the default shaders do not use it. Return zone texture attribute. Base class for all the Action Easing functions. In general, you will be using one of the concrete subclasses:  The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Base class for actions that have an immediate effect. This is a base class that will invoke the Update method in the  with the value of one as soon as it is executed.    The following example shows how you would implement an instant: In this imaginary action, you there would be an inverse operation called “MyInstantReverse”, which is used to implement the Reverse method in this case. The “PerformOp” call is the one that does the change, and it will be invoked only once. Creates a new instance of the instant action This method must be overwritten and return the reverse action of your custom action. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The manager for all executing actions. This class manages all the executing actions.   The provided interface can be used to query and probe the running actions. This class is a singleton. Constructor, instantiated internally. Low-level: adds the specified action to the node. Releases the resources of the action manager. Releases the resources of the action manager. Finalizer Returns the action that has the specified tag ID on the specified target. Returns the ActionState associated with the specified tag ID on the specified target. Returns the number of actions executing on the given target Pauses all the running actions and returns a list of the elements that were paused. Pauses the specified target. Removes a specific action that is currently executing (based on its actionState). Removes the specified action from a node, using a tag ID. Removes all running actions. Removes all running actions from a specific node. Resumes the actions on the specified node. Resumes all the targets in the provided list. Action tick method, invoked externally. Encapsulates the states of a running action. ActionStates encapsulate the running state of an Action when the  method is invoked to trigger the execution fo the action. Points to the action that is triggering the creation of this state, this is the blueprint for what the action should do. The node that this action will be operating on. Creates a new action state Links to the action for which this action state was created. Gets a value indicating whether this instance is done. true if this instance is done; otherwise, false. The node that this action will be operating on. Delta Time Called every frame with it's delta time. DON'T override unless you know what you are doing. Called after the action has finished. It will set the 'Target' to null.  You should never call this method manually. Instead, call the  method with this action state. Gets or sets the target. Will be set with the 'StartAction' method of the corresponding Action. When the 'Stop' method is called, Target will be set to null. The target. A value between 0 and 1 For example: 0 means that the action just started 0.5 means that the action is in the middle 1 means that the action is over Called once per frame. When you provide your own Actions, and your own action states, this is the method that will perform the actual changes to your  node.   The action should affect the state of the target node in an implementation specific way, and should be done in function of the specified dt. Enumeration used to tag actions, the only interesting value is the field “Invalid” which is used to tell the tag apart from user-set tags. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Base class for actions in Urho. In general, you will be using one of the concrete implementations of BaseAction that provide a lot of functionality. Actions are stateless, when you subclass this class, you should never keep any writable state.  Your subclass should merely act as a blueprint for what the action should do. When you create own actions, you need to override the  method to return an  subclass which is in chage of driving the action over time. Base constructor The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. The new  that encapsulates the state and provides the implementation to perform your action. New action that will perform the inverse of this action Tag used to easily reference an action from code using a code. Sets the position of the node to follow a specified bezier path. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Bezier path configuration using two control points and an end position. Sets the position of the node to follow a specified bezier path. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Blinks a node by setting its Enabled state. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Invokes an  on every Action Update tick. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Invokes an  on every Action Update tick, passing the node where the action is taking place. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Invokes an  on every Action Update tick, passing the node where the action is taking place and a specified data payload. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Invokes an  on every Action Update tick, passing  a specified data payload. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. An action which completes after the specified time. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Easing function: back in. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Easing function: back out. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Easing function: bounce in. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Easing function: bounce in and out. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Easing function: bounce out. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Custom easing function using a function that provides the easing values. This is an easing action that can use a delegate to compute the easing behavior. The easing action that this is wrapping. Function that takes as input the time, and returns the transformed time that should be passed to the underlying wrapped action. Initializes the custom easing function with a function that will apply a distortion over time. The configured easing function. Returns an  instance of this action. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Base class for elastic easing actions. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Base class for easing actions that have an easing rate component. Base class for ,  and  Initializes the rate class with the given action to ease over, and the rate of change. Rate of change for the action. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Fades-in the  component or  component of a . This fades in an attached  component of a node by altering the alpha component on the  property, or the attached  component of a node by altering the alpha component on the  property. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Fades-out the  component or  component of a . This fades out an attached  component of a node by altering the alpha component on the  property, or the attached  component of a node by altering the alpha component on the  property. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Alters the alpha component of the  component or  component of a . This changes the alpha transparency to the specified opacity of an attached  component of a node by altering the alpha component on the  property, or the attached  component of a node by altering the alpha component on the  property. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Base class for actions that have a time duration. Initializes the action with a duration of zero. Initializes the action with the specified duration in seconds. Duration of the action. Subclasses should return the inverse of the operation. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Hides a node. Sets the Enabled property of the target node to to false. Returns an instance of  The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Sets the position of a node. Sets the  property of the target node to to false. Creates the action from a 3d vector. Creates the action from integer values. The position configured for this action. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Removes the node from its container (another node) Invokes the Node’s Parent RemoveChild. This operation is not supported for this kind of action. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Shows a node. Sets the Enabled property of the target node to to false. Creates the action Returns an instance of  The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Toggles the visibility of a node. Toggles the status of the  property of the target node.   The new that encapsulates the state and provides the implementation to perform your action. Creates the action state for this action, called on demand from the framework to start executing the recipe. New action that will perform the inverse of this action Encapsulates the running state for the action. This object is created on demand when the action starts executing on a node, and it tracks the state of the action as it executes. Audio subsystem, used to playback both regular audio and 3D sound. The Audio class represents the audio subsystem, which implements an audio output stream. It is the hub for audio operations in your application.  See the  documentation for more information. To hear pseudo-3D positional sounds, a  component must exist in a scene node and be assigned to the audio subsystem by setting the  property.  The output is software mixed for an unlimited amount of simultaneous sounds. Ogg Vorbis sounds are decoded on the fly, and decoding them can be memory- and CPU-intensive, so WAV files are recommended when a large number of short sound effects need to be played. For purposes of volume control, each  can be classified into a user defined group which is multiplied with a master category and the individual  gain set using  for the final volume level. To control the category volumes, set the , which defines the category if it didn't already exist. It is possible to control the playback of a class of sounds identified by their type by using the ,  and  methods.  You can probe whether a specific sound type is paused by calling the .   The list of possible sound types are the strings “Master”, “Effect”, “Ambient”, “Voice” and “Music”. Constructs a new instance of Urho.Audio.Audio which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Audio.Audio, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Audio.Audio linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add a sound source to keep track of. Called by SoundSource. Return master gain for a specific sound source type. Unknown sound types will return full gain (1). Return sound type specific gain multiplied by master gain. Return whether the specified master gain has been defined. Return whether an audio stream has been reserved. Return whether output is interpolated. The type of the sound to probe, some possible value  “Master”, “Effect”, “Ambient”, “Voice” and “Music”. Returns whether the specified sound type is currently paused. True if the sound for that sound type is paused, false otherwise. Return active sound listener. Or Set active sound listener for 3D sounds. Assign a SoundListener to this property.  The sound listener must be attached to a node in the scene for this to work. Mix sound sources into the buffer. Return mixing rate. The list of possible sound types are the strings “Master”, “Effect”, “Ambient”, “Voice” and “Music”. Pause playing back the sounds of the specific type. Restart sound output. Return whether audio is being output. Remove a sound source. Called by SoundSource. Resumes playback of all sound types. This can be used to resume all sound type playback (some might have been paused by calling  The list of possible sound types are the strings “Master”, “Effect”, “Ambient”, “Voice” and “Music”. Resumes playing back the sounds of the specific type. Return byte size of one sample. Set master gain on a specific sound type such as sound effects, music or voice. Initialize sound output with specified buffer length and output mode. Determines whether output is stereo. Suspend sound output. Stop any sound source playing a certain sound clip. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Sound stream that supports manual buffering of data from the main thread. Use this class to push audio data to be played back from the main thread. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Audio.BufferedSoundStream, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Buffer sound data. Makes a copy of it. Buffer sound data from a byte array. Buffer sound data from a short array. Return length of buffered (unplayed) sound data in seconds. Return amount of buffered (unplayed) sound data in bytes. Remove all buffered audio data. Produce sound data into destination. Return number of bytes produced. Called by SoundSource from the mixing thread. Ogg Vorbis sound stream. Ogg Vorbis sound stream. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Audio.OggVorbisSoundStream, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Produce sound data into destination. Return number of bytes produced. Called by SoundSource from the mixing thread. Sound resource. Sounds can be played back with either the  or the  components.  This allows manual stereo panning of mono sounds; stereo sounds will be output with their original stereo mix. Constructs a new instance of Urho.Audio.Sound which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Audio.Sound, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Audio.Sound linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return whether is compressed. Return total sound data size. Return a new instance of a decoder sound stream. Used by compressed sounds. Return sound data end. Fix interpolation by copying data from loop start to loop end (looped), or adding silence (oneshot.) Called internally, does not normally need to be called, unless the sound data is modified manually on the fly. Return default frequency as a float. Return default frequency as an integer. Return length in seconds. Set loop on/off. If loop is enabled, sets the full sound as loop range. Register object factory. Return loop start. Return sample size. Set uncompressed sound data. Set uncompressed sound data format. Define loop. Set sound size in bytes. Also resets the sound to be uncompressed and one-shot. Return whether data is sixteen bit. Return sound data start. Return whether data is stereo. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Sound listener component This is used for 3D positional sounds.  To use this, the  in the  must created that contains an instance of this component and be assigned by the audio subsystem by setting the  property. If the sound listener's scene node exists within a specific scene, it will only hear sounds from that scene, but if it has been created into a "sceneless" node it will hear sounds from all scenes. Constructs a new instance of Urho.Audio.SoundListener which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Audio.SoundListener, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Audio.SoundListener linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Sound source component with stereo position. Provides support for playing back . The  components support automatic removal from the node they belong to, once playback is finished. To use, set the  on them. This may be useful when a game object plays several "fire and forget" sound effects. Constructs a new instance of Urho.Audio.SoundSource which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Audio.SoundSource, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Audio.SoundSource linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return attenuation. Or Set attenuation. 1.0 is unaltered. Used for distance attenuated playback. Return automatic removal mode on sound playback completion. Or Set to remove either the sound source component or its owner node from the scene automatically on sound playback completion. Disabled by default. Return frequency. Or Set frequency. Return gain. Or Set gain. 0.0 is silence, 1.0 is full volume. Mix sound source output to a 32-bit clipping buffer. Called by Audio. Return stereo panning. Or Set stereo panning. -1.0 is full left and 1.0 is full right. Play a sound. Start playing a sound stream. Play a sound with specified frequency. Play a sound with specified frequency and gain. Play a sound with specified frequency, gain and panning. Return whether is playing. Return playback position. Return sound position attribute. Or Set sound position attribute. Register object factory. Set sound playing attribute Set new playback position. Set sound type, determines the master gain group. Return sound. Return sound attribute. Return sound type, determines the master gain group. Stop playback. Return playback time position. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Update the sound source. Perform subclass specific operations. Called by Audio. Update the effective master gain. Called internally and by Audio when the master gain changes. Sound source component with three-dimensional position. This plays  To hear pseudo-3D positional sounds, a  component must exist in a scene node and be assigned to the audio subsystem by setting the  property. If the sound listener's scene node exists within a specific scene, it will only hear sounds from that scene, but if it has been created into a "sceneless" node it will hear sounds from all scenes. Playing the above sound formats in pseudo-3D using the  component. It has stereo positioning and distance attenuation, but does not (at least yet) filter the sound depending on the direction. Constructs a new instance of Urho.Audio.SoundSource3D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Audio.SoundSource3D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Audio.SoundSource3D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Calculate attenuation and panning based on current position and listener position. Visualize the component as debug geometry. Return far distance. Or Set far distance. Outside this range sound will be completely attenuated. Return inner angle in degrees. Or Set inner angle in degrees. Inside this angle sound will not be attenuated.By default 360, meaning direction never has an effect. Return near distance. Or Set near distance. Inside this range sound will not be attenuated. Return outer angle in degrees. Or Set outer angle in degrees. Outside this angle sound will be completely attenuated. By default 360, meaning direction never has an effect. Register object factory. Return rolloff power factor. Set angle attenuation parameters. Set attenuation parameters. Set rolloff power factor, defines attenuation function shape. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Update sound source. Base class for sound streams. In addition to playing existing sound resources, sound can be generated during runtime using the   class and its subclasses. To start playback of a stream on a , call . Sound streaming is used internally to implement on-the-fly Ogg Vorbis decoding. See the SoundSynthesis sample for an example of using the  subclass, which allows the sound data to be queued for playback from the main thread. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Audio.SoundStream, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return default frequency as a float. Produce sound data into destination. Return number of bytes produced. Called by SoundSource from the mixing thread. Return default frequency as an integer. Return sample size. Set sound data format. Return whether audio data is sixteen bit. Return whether data is stereo. Return whether playback should stop when no more data. Or Set whether playback should stop when no more data. Default false. Path to a folder containing "Data" folder. CurrentDirectory if null Image UI element with optional border. The  and elements deriving from it specify a texture and an absolute pixel rect within it to use for rendering; see  and . The texture is modulated with the element's color. To allow for more versatile scaling the element can be divided into 9 sub-quads or patches by specifying the width of each of its borders, see . Setting zero borders (the default) causes the element to be drawn as one quad. The absolute pixel rects interact poorly with the  texture quality setting, which reduces texture sizes by skipping the topmost mipmaps. Generating mipmaps is also often unnecessary for UI textures, as they are usually displayed with 1:1 ratio on the screen. Therefore it's a good practice to use the following accompanying settings XML file for UI textures to disable quality reduction and mipmaps (mipmap enable set to false, quality low set to zero in the texture xml group). Constructs a new instance of Urho.Gui.BorderImage which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.BorderImage, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.BorderImage linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return blend mode. Or Set blend mode. Return border screen dimensions. Or Set border dimensions on the screen. Return offset to image rectangle used on hover. Or Set offset to image rectangle used on hover. Return border image dimensions. Zero rect uses border screen dimensions. Or Set border dimensions on the image. If zero (default) uses the screen dimensions, resulting in pixel-perfect borders. Return image rectangle. Or Set part of texture to use as the image. Register object factory. Use whole texture as the image. Set offset to image rectangle used on hover. Return texture. Or Set texture. Return texture attribute. Determines whether the image is tiled. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Push button %UI element. Constructs a new instance of Urho.Gui.Button which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.Button, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.Button linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return disabled image offset. Or Set offset to image rectangle used when disabled. Return whether is currently pressed. React to mouse click begin. React to mouse click end. React to a key press. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return offset of child elements when pressed. Or Set offset of child elements when pressed. Return pressed image offset. Or Set offset to image rectangle used when pressed. Register object factory. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return repeat delay. Or Set repeat delay. Return repeat rate. Or Set repeat rate. Set offset of child elements when pressed. Set offset to image rectangle used when pressed. Set repeat properties. Rate 0 (default) disables repeat. The handler to invoke when this event is raised. Subscribes to the Pressed event raised by the Button. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the Released event raised by the Button. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Perform UI element update. UI element that can be toggled between unchecked and checked state. Constructs a new instance of Urho.Gui.CheckBox which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.CheckBox, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.CheckBox linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. The checked state for the checkbox. Return checked image offset. Or Set checked image offset. React to mouse click begin. React to a key press. Register object factory. Set checked image offset. The handler to invoke when this event is raised. Subscribes to the Toggled event raised by the CheckBox. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. UI element corners. Mouse cursor UI element. Urho3D supports custom  Shapes defined from an . The Shape can be an OS default from the CursorShape enum, which are automatically switched to and from by the UI subsystem, but can be manually switched to using  Alternatively they can be defined using a name in a string  format to identify it. There are a number of reserved names that are used for the OS defaults: Normal IBeam Cross ResizeVertical ResizeDiagonalTopRight ResizeHorizontal ResizeDiagonalTopLeft ResizeAll AcceptDrop RejectDrop Busy BusyArrow Cursor Shapes can be define in a number of different ways: Constructs a new instance of Urho.Gui.Cursor which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.Cursor, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.Cursor linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Apply pending OS cursor shape. Called by UI. No-op when the OS mouse pointer is not used. Define a shape. Define a shape. Register object factory. Set current shape. Get current shape. Or Set current shape. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return whether is using system default shapes. Or Set whether to use system default shapes. Is only possible when the OS mouse cursor has been set visible from the Input subsystem. Cursor shapes recognized by the UI subsystem. Event arguments for the UIElement's Defocused event Event arguments for the UIElement's DragBegin event Event arguments for the UIElement's DragCancel event Event arguments for the UIElement's DragDropFinish event Event arguments for the UIElement's DragDropTest event Event arguments for the UIElement's DragEnd event Event arguments for the UIElement's DragMove event %Menu %UI element that displays a popup list view. Constructs a new instance of Urho.Gui.DropDownList which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.DropDownList, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.DropDownList linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add item to the end of the list. Apply attribute changes that can not be applied immediately. Return item at index. Insert item to a specific position. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return listview element. Return number of items. React to the popup being hidden. React to editable status change. React to the popup being shown. Return selected item placeholder element. Return place holder text. Or Set place holder text. This is the text shown when there is no selection in drop down list. Register object factory. Remove all items. Remove item at index. Remove specific item. Return whether popup should be automatically resized. Or Set whether popup should be automatically resized to match the dropdown button width. Return selected item, or null if none selected. Return selection index, or M_MAX_UNSIGNED if none selected. Or Set selection. Set selection attribute. The handler to invoke when this event is raised. Subscribes to the ItemSelected event raised by the DropDownList. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Event arguments for the UIElement's ElementAdded event Event arguments for the UIElement's ElementRemoved event Event arguments for the FileSelector's FileSelected event %File selector dialog. Constructs a new instance of Urho.Gui.FileSelector which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.FileSelector, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.FileSelector linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return cancel button. Return close button. Return the UI style file. Or Set fileselector UI style. Return directory mode flag. Or Set directory selection mode. Default false. Return file list. Return current filename. Or Set current filename. Return filename editor. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return current filter. Return current filter index. Return filter dropdown. Return OK button. Return current path. Or Set current path. Return path editor. Register object factory. Set button texts. The handler to invoke when this event is raised. Subscribes to the FileSelected event raised by the FileSelector. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Return window title. Or Set title text. Return window title text element. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Update elements to layout properly. Call this after manually adjusting the sub-elements. Return fileselector window. Event arguments for the UI's FocusChanged event Event arguments for the UIElement's Focused event UI element focus mode. Font resource. UrhoSharp supports both FreeType (.ttf, .otf) and http://www.angelcode.com/products/bmfont/ "bitmap" fonts. For FreeType fonts, it is possible to adjust the positioning of the font glyphs. See  to set a fixed pixel offset for all point sizes, or  to set a floating point offset that will be multiplied with the point size before applying. The offset information can be also stored in an accompanying XML file next to the font file, which is formatted in the following way: (it is legal to specify either or both of absolute and scaled offsets, and either or both of X and Y coordinates) Constructs a new instance of Urho.Gui.Font which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.Font, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.Font linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return absolute position adjustment for glyphs. Or Set absolute (in pixels) position adjustment for glyphs. Return font type. Register object factory. Release font faces and recreate them next time when requested. Called when font textures lost or global font properties change. Return point size scaled position adjustment for glyphs. Or Set point size scaled position adjustment for glyphs. Determines if it is a signed distance field font. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Font face description. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.FontFace, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. True if any of the textures has dataloss. Return pointer to the glyph structure corresponding to a character. Return null if glyph not found. Return if font face uses mutable glyphs. Return point size. Return row height. Return textures. Bitmap font face description. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.FontFaceBitmap, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Load from existed font face, pack used glyphs into smallest texture size and smallest number of texture. Free type font face description. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.FontFaceFreeType, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return pointer to the glyph structure corresponding to a character. Return null if glyph not found. Return if font face uses mutable glyphs. ListView selection highlight mode. UI element horizontal alignment. Event arguments for the UIElement's HoverBegin event Event arguments for the UIElement's HoverEnd event Event arguments for the ListView's ItemClicked event Event arguments for the ListView's ItemDeselected event Event arguments for the ListView's ItemDoubleClicked event Event arguments for the DropDownList's ItemSelected event Layout operation mode. Event arguments for the UIElement's LayoutUpdated event Single-line text editor UI element. Constructs a new instance of Urho.Gui.LineEdit which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.LineEdit, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.LineEdit linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Apply attribute changes that can not be applied immediately. Return cursor element. Return cursor blink rate. Or Set cursor blink rate. 0 disables blinking. Controls whether the cursor can be moved. The cursor position. Return echo character. Or Set echo character for password entry and such. 0 (default) shows the actual text. Return maximum text length. Or Set maximum text length. 0 for unlimited. React to mouse click begin. React to mouse doubleclick. React to a key press. Register object factory. The handler to invoke when this event is raised. Subscribes to the TextChanged event raised by the LineEdit. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the TextFinished event raised by the LineEdit. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the UnhandledKey event raised by the LineEdit. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Return text. Or Set text. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Controls whether copy-paste operations are allowed. Return text element. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The current state of text selection, whether it is enabled or not. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Perform UI element update. Scrollable list UI element. Constructs a new instance of Urho.Gui.ListView which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.ListView, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.ListView linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add item to the end of the list. Add item to the selection, multiselect mode only. Return base indent. Or Set base indent, i.e. the indent level of the ultimate parent item. Move selection by a delta and clamp at list ends. If additive (multiselect only), will add to the existing selection. Clear selection. Return whether selection is cleared on defocus. Or Enable clearing of selection on defocus. Copy selected items to system clipboard. Currently only applicable to Text items. Disable automatic layout update for internal elements. Enable automatic layout update for internal elements. Ensure full visibility of the item. Ensure full visibility of the item. Expand item at index. Only has effect in hierarchy mode. Return index of item, or M_MAX_UNSIGNED If not found. Return item at index. Return whether hierarchy mode enabled. Or Enable hierarchy mode. Allows items to have parent-child relationship at different indent level and the ability to expand/collapse child items. All items in the list will be lost during mode change. Return highlight mode. Or Set selected items' highlight mode. Insert item at a specific index. In hierarchy mode, the optional parameter will be used to determine the child's indent level in respect to its parent. If index is greater than the total items then the new item is inserted at the end of the list. In hierarchy mode, if index is greater than the index of last children of the specified parent item then the new item is inserted next to the last children. And if the index is lesser than the index of the parent item itself then the new item is inserted before the first child item. Return whether an item at index has its children expanded (in hierachy mode only). Return whether an item at index is seleccted. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return whether multiselect enabled. Or Enable multiselect. Return number of items. React to a key press. Register object factory. Remove all items. Remove item at index. In hierarchy mode will also remove any children. Remove specific item, starting search at the specified index if provided. In hierarchy mode will also remove any children. Remove item from the selection. Return first selected item, or null if none selected. Return first selected index, or M_MAX_UNSIGNED if none selected. Or Set selection. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return whether reacts to click end instead of click start for item selection. Or Enable reacting to click end instead of click start for item selection. Default false. The handler to invoke when this event is raised. Subscribes to the ItemClicked event raised by the ListView. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ItemDeselected event raised by the ListView. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ItemDoubleClicked event raised by the ListView. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ItemSelected event raised by the ListView. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the SelectionChanged event raised by the ListView. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the UnhandledKey event raised by the ListView. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Toggle item's expanded flag at index. Only has effect in hierarchy mode. Toggle selection of an item. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Manually update layout on internal elements. Menu UI element that optionally shows a popup. Constructs a new instance of Urho.Gui.Menu which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.Menu, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.Menu linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return accelerator key code, 0 if disabled. Return accelerator qualifiers. Return whether popup is open. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. React to the popup being hidden. React to mouse hover. React to the popup being shown. Return popup element. Or Set popup element to show on selection. Return popup element offset. Or Set popup element offset. Register object factory. Set accelerator key (set zero key code to disable.) Set popup element offset. Force the popup to show or hide. The handler to invoke when this event is raised. Subscribes to the MenuSelected event raised by the Menu. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Perform UI element update. Event arguments for the Menu's MenuSelected event Event arguments for the MessageBox's MessageACK event Message box dialog. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.MessageBox, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. The context that this object will be attached to. Constructs a new instance of Urho.Gui.MessageBox linked to a specific . Return message text. Return empty string if there is no message text element. Or Set message text. No-ops if there is no message text element. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Register object factory. The handler to invoke when this event is raised. Subscribes to the MessageACK event raised by the MessageBox. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Return title text. Return empty string if there is no title text element. Or Set title text. No-ops if there is no title text element. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return dialog window. Event arguments for the Window's ModalChanged event Event arguments for the UIElement's NameChanged event UI element orientation. Event arguments for the UIElement's Positioned event Event arguments for the Button's Pressed event Event arguments for the Button's Released event Event arguments for the UIElement's Resized event Delta X Delta Y Element to be resized Height Width Scroll bar UI element with forward and back buttons. Constructs a new instance of Urho.Gui.ScrollBar which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.ScrollBar, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.ScrollBar linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Apply attribute changes that can not be applied immediately. Return back button element. Change slider current value by a delta. Return scroll step multiplied by factor. Return forward button element. React to editable status change. Return scrollbar orientation. Or Set orientation type. Return slider range. Or Set slider range maximum value (minimum value is always 0.) Register object factory. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return button scroll step. Or Set button scroll step. Return slider element. Scroll back one step. Return button step factor. Or Set button step factor, can be used to adjust the step for constant pixel size. Scroll forward one step. The handler to invoke when this event is raised. Subscribes to the ScrollBarChanged event raised by the ScrollBar. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return slider current value. Or Set slider current value. Event arguments for the ScrollBar's ScrollBarChanged event Scrollable UI element for showing a (possibly large) child element. Constructs a new instance of Urho.Gui.ScrollView which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.ScrollView, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.ScrollView linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Apply attribute changes that can not be applied immediately. Return whether child element will be disabled while touch scrolling. Or Set whether child elements should be disabled while touch scrolling. Return how much touch movement is needed to trigger child element disabling. Or Set how much touch movement is needed to trigger child element disabling. Return content element. Or Set content element. Return horizontal scroll bar. Return whether the horizontal scrollbar is visible. Or Set horizontal scrollbar visibility manually. Disables scrollbar autoshow/hide. React to a key press. React to mouse wheel. Return arrow key page step. Or Set arrow key page step. Register object factory. Return whether scrollbars are automatically shown/hidden. Or Set whether to automatically show/hide scrollbars. Default true. Return scroll deceleration. Or Set scroll deceleration. Return scroll panel. Return scroll snap epsilon Or Set scroll snap epsilon Return arrow key scroll step. Or Set arrow key scroll step. Also sets it on the scrollbars. Set scrollbars' visibility manually. Disables scrollbar autoshow/hide. Set view offset from the top-left corner. Set view position attribute. The handler to invoke when this event is raised. Subscribes to the ViewChanged event raised by the ScrollView. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Perform UI element update. Return vertical scroll bar. Return whether the vertical scrollbar is visible. Or Set vertical scrollbar visibility manually. Disables scrollbar autoshow/hide. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return view offset from the top-left corner. Or Set view offset from the top-left corner. Return whether the element could handle wheel input. Event arguments for the ListView's SelectionChanged event Slider bar UI element. Constructs a new instance of Urho.Gui.Slider which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.Slider, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.Slider linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Change value by a delta. Return knob element. React to mouse click begin. React to mouse click end. React to mouse hover. Return orientation type. Or Set orientation type. Return slider range. Or Set slider range maximum value (minimum value is always 0.) Register object factory. Return paging minimum repeat rate (number of events per second). Or Set paging minimum repeat rate (number of events per second). The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The handler to invoke when this event is raised. Subscribes to the SliderChanged event raised by the Slider. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the SliderPaged event raised by the Slider. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Perform UI element update. Return slider current value. Or Set slider current value. Event arguments for the Slider's SliderChanged event Event arguments for the Slider's SliderPaged event UI element which allows sub-pixel positioning and size, as well as rotation. Only other Sprites should be added as child elements. Sprites are a special kind of UI element that allow subpixel (float) positioning and scaling, as well as rotation, while the other elements use integer positioning for pixel-perfect display. Sprites can be used to implement rotating HUD elements such as minimaps or speedometer needles. Due to the free transformability, sprites can not be reliably queried with . Also, only other sprites should be parented to sprites, as the other elements do not support scaling and rotation. Constructs a new instance of Urho.Gui.Sprite which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.Sprite, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.Sprite linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return blend mode. Or Set blend mode. Element coordinates to convert. Convert element coordinates to screen coordinates. Screen coordinates Return hotspot. Or Set hotspot for positioning and rotation. Return image rectangle. Or Set part of texture to use as the image. Return whether is visible and inside a scissor rectangle and should be rendered. Return floating point position. Or Set floating point position. Register object factory. Return rotation angle. Or Set rotation angle. Return scale. Or Set scale. Scale also affects child sprites. Update and return screen position. Screen coordinates to convert Convert screen coordinates to element coordinates. The coordinates in the element space. Use whole texture as the image. Set hotspot for positioning and rotation. Set floating point position. Set uniform scale. Scale also affects child sprites. Set scale. Scale also affects child sprites. Return texture. Or Set texture. Return texture attribute. Rendering transformation, also used to transform child sprites. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Text UI element. Constructs a new instance of Urho.Gui.Text which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.Text, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.Text linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Apply attribute changes that can not be applied immediately. Return auto localizable mode. Or The text will be automatically translated. The text value used as string identifier. Clear selection. Return effect color. Or Set effect color. Return effect Z bias. Or Set text effect Z bias. Zero by default, adjusted only in 3D mode. Return effect round stroke. Or Set stroke rounding. Corners of the font will be rounded off in the stroke so the stroke won't have corners. Return effect shadow offset. Or Set shadow offset. Return effect stroke thickness. Or Set stroke thickness. Return font. Return font attribute. Return font size. Return hover background color. Or Set hover background color. Color with 0 alpha (default) disables. Return number of characters. Return number of rows. React to indent change. Register object factory. Return row height. Return row spacing. Or Set row spacing, 1.0 for original font spacing. Return selection background color. Or Set selection background color. Color with 0 alpha (default) disables. Return selection length. Return selection start. Set selection. When length is not provided, select until the text ends. Return row alignment. Or Set row alignment. Return text attribute. Return text effect. Or Set text effect. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return text. Or Set text. Text is assumed to be either ASCII or UTF8-encoded. Return wordwrap mode. Or Set wordwrap. In wordwrap mode the text element will respect its current width. Otherwise it resizes itself freely. 3D text component. Constructs a new instance of Urho.Gui.Text3D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.Text3D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.Text3D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Apply attribute changes that can not be applied immediately. Get color attribute. Uses just the top-left color. Return effect color. Or Set effect color. Return effect depth bias. Or Set effect Z bias. Return effect round stroke. Or Set stroke rounding. Corners of the font will be rounded off in the stroke so the stroke won't have corners. Return effect shadow offset. Or Set shadow offset. Return effect stroke thickness. Or Set stroke thickness. Return how the text rotates in relation to the camera. Or Set how the text should rotate in relation to the camera. Default is to not rotate (FC_NONE.) Return whether text has fixed screen size. Or Set whether text has fixed size on screen (pixel-perfect) regardless of distance to camera. Works best when combined with face camera rotation. Default false. Return font. Return font attribute. Return font size. Return corner color. Return width of row by index. Return text height. Return horizontal alignment. Or Set horizontal alignment. Return material. Or Set material. Return material attribute. Return number of characters. Return number of rows. Return opacity. Or Set opacity. Register object factory. Drawable must be registered first. Return row height. Return row spacing. Or Set row spacing, 1.0 for original font spacing. Set horizontal and vertical alignment. Set color on all corners. Set color on one corner. Return text. Or Set text. Text is assumed to be either ASCII or UTF8-encoded. Return row alignment. Or Set row alignment. Return text attribute. Return text effect. Or Set text effect. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return whether a geometry update is necessary, and if it can happen in a worker thread. Return vertical alignment. Or Set vertical alignment. Return text width. Or Set text width. Only has effect in word wrap mode. Return wordwrap mode. Or Set wordwrap. In wordwrap mode the text element will respect its current width. Otherwise it resizes itself freely. Event arguments for the LineEdit's TextChanged event Text effect. Event arguments for the LineEdit's TextFinished event Event arguments for the CheckBox's Toggled event Tooltip UI element. Constructs a new instance of Urho.Gui.ToolTip which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.ToolTip, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.ToolTip linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return the delay in seconds until the tooltip shows once hovering. Or Set the delay in seconds until the tooltip shows once hovering. Set zero to use the default from the UI subsystem. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Perform UI element update. Traversal mode for rendering. UI subsystem. Manages the graphical user interface. Urho3D implements a simple, hierarchical user interface system based on rectangular elements. The elements provided are: : a texture image with an optional border : a pushbutton : a button that can be toggled on/off : a mouse cursor : shows a vertical list of items (optionally scrollable) as a popup : a single-line text editor : shows a scrollable vertical list of items : a button which can show a popup element : a slider with back and forward buttons : a scrollable view of child elements : a horizontal or vertical slider bar : a texture image which supports subpixel positioning, scaling and rotating. : static text that can be multiline : a popup which automatically displays itself when the cursor hovers on its parent element. : container for other elements, renders nothing by itself : a window that renders a 3D viewport : a movable and resizable window The root UI element can be queried from the UI subsystem. It is an empty canvas () as large as the application window, into which other elements can be added. Elements are added into each other similarly as scene nodes, using the  and .  To allow the elements react to mouse input, either a mouse cursor element must be defined using the  property  or the operating system mouse cursor must be set visible from the  subsystem.


    Constructs a new instance of Urho.Gui.UI which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.UI, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.UI linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Clear the UI (excluding the cursor.) Return clipboard text. Or Set clipboard text. Return cursor. Or Set cursor UI element. Return cursor position. Return root element custom size. Returns 0,0 when custom size is not being used and automatic resizing according to window size is in use instead (default.) Or Set custom size of the root element. This disables automatic resizing of the root element according to window size. Set custom size 0,0 to return to automatic resizing. Debug draw a UI element. Return tooltip default display delay in seconds. Or Set tooltip default display delay in seconds. Return UI element double click interval in seconds. Or Set UI element double click interval in seconds. Return UI drag start event distance threshold in pixels. Or Set UI drag event start distance threshold in pixels. Return UI drag start event interval in seconds. Or Set UI drag event start interval in seconds. Return whether a drag is in progress. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return focused element. Return the current FreeType font hinting level. Or Set the hinting level used by FreeType fonts. Get the oversampling (horizonal stretching) used to improve subpixel font rendering. Only affects fonts smaller than the subpixel limit. Or Set the oversampling (horizonal stretching) used to improve subpixel font rendering. Only affects fonts smaller than the subpixel limit. Get the font subpixel threshold. Below this size, if the hint level is LIGHT or NONE, fonts will use subpixel positioning plus oversampling for higher-quality rendering. Has no effect at hint level NORMAL. Or Set the font subpixel threshold. Below this size, if the hint level is LIGHT or NONE, fonts will use subpixel positioning plus oversampling for higher-quality rendering. Has no effect at hint level NORMAL. Return whether is using forced autohinting. Or Set whether to force font autohinting instead of using FreeType's TTF bytecode interpreter. Return topmost enabled root-level non-modal element. Return the drag element at index. Return UI element at screen coordinates. By default returns only input-enabled elements. Return UI element at screen coordinates. By default returns only input-enabled elements. Return true when UI has modal element(s). Return font texture maximum size. Or Set maximum font face texture size. Must be a power of two. Default is 2048. Determines whether mouse wheel can control also a non-focused element.. Return the number of currently dragged elements. Render the UI. If resetRenderTargets is true, is assumed to be the default UI render to backbuffer called by Engine, and will be performed only once. Additional UI renders to a different rendertarget may be triggered from the renderpath. Update the UI for rendering. Called by HandleRenderUpdate(). Return root UI element. Return root modal element. Return current UI scale. Or Set %UI scale. 1.0 is default (pixel perfect). Resize the root element to match. Set focused UI element. Set modal element. Until all the modal elements are dismissed, all the inputs and events are only sent to them. Return true when successful. Only the modal element can clear its modal status or when it is being destructed. The handler to invoke when this event is raised. Subscribes to the FocusChanged event raised by the UI. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the UIDropFile event raised by the UI. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the UIMouseClick event raised by the UI. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the UIMouseClickEnd event raised by the UI. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Update the UI logic. Called by HandlePostUpdate(). Return whether is using mutable (eraseable) glyphs for fonts. Or Set whether to use mutable (eraseable) glyphs to ensure a font face never expands to more than one texture. Default false. Return whether focusing a %LineEdit will show the on-screen keyboard. Or Set whether to show the on-screen keyboard (if supported) when a %LineEdit is focused. Default true on mobile devices. Return whether is using the system clipboard. Or Set whether to use system clipboard. Default false. Event arguments for the UI's UIDropFile event Base class for UI elements. User interface elements are serializable, so they can be serialized to/from XML using their attributes. There are two distinct use cases for UI definition files: either defining just the UI element style and leaving the actual position and dimensions to be filled in later, or fully defining an UI element layout. The default element style definitions, used for example by the editor and the debug console, are in the file bin/Data/UI/DefaultStyle.xml. The method  in UI will take an XML file and instantiate the elements defined in it. To be valid XML, there should be one root-level UI element. An optional style XML file can be specified; the idea is to first read the element's style from that file, then fill in the rest from the actual layout XML file. This way the layout file can be relatively simple, as the majority of the data is already defined. Note that a style can not be easily applied recursively to the loaded elements afterward. Therefore remember to specify the style file already when loading, or alternatively assign a default style file to the UI root element, which will then be picked up by all loaded layouts. This works because the UI subsystem searches the style file by going up the parental chain starting from target parent UI element. The search stops immediately when a style file is found or when it has reached the root element. Also note that UrhoSharp does not limit the number of style files being used at the same time in an application. You may have different style file set along the UI parental hierarchy, if your application needs that. You can also use the Editor application to create UI layouts. The serialization format is similar to scene XML serialization, with three important differences: 1) The element type to instantiate, and the style to use for it can be set separately. For example the following element definition tells to instantiate a  element, and that it should use the style "CloseButton" defined in the style XML file. 2) Internal child elements, for example the scroll bars of a , need to be marked as such to avoid instantiating them as duplicates. This is done by adding the attribute internal="true" to the XML element, and is required in both layout and style XML files. Furthermore, the elements must be listed in the order they have been added as children of the parent element (if in doubt, see the element's C++ constructor code. Omitting elements in the middle is OK) 3) The popup element shown by  and  is not an actual child element. In XML serialization, it is nevertheless stored as a child element, but is marked with the attribute popup="true”. You can associate one or more strings to a UIElement, by using the  and the  methods.

    UI Element Layout

     By default UI elements operate in a "free" layout mode, where child elements' positions can be specified relative to any of the parent element corners, but they are not automatically positioned or resized. To create automatically adjusting layouts, the layout mode can be switched to either "horizontal" or "vertical". Now the child elements will be positioned left to right or top to bottom, based on the order in which they were added. They will be preferably resized to fit the parent element, taking into account their minimum and maximum sizes, but failing to do that, the parent element will be resized. Left, top, right and bottom border widths and spacing between elements can also be specified for the layout. A grid layout is not directly supported, but it can be manually created with a horizontal layout inside a vertical layout, or vice versa.     Constructs a new instance of Urho.Gui.UIElement which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.UIElement, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.UIElement linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add a child element. The string to associate Attaches the specified string as a tag to this UIElement. Use the  to remove this tag, or the  method to determine if the element has the specified tag attached. Return applied style name. Return an empty string when the applied style is an 'auto' style (i.e. style derived from instance's type). Apply attribute changes that can not be applied immediately. Return whether should be put to background when another element is focused. Or Set whether should be put to background when another element is focused. Bring UI element to front. Return whether should be brought to front when focused. Or Set whether should be brought to front when focused. Return child element offset. Or Set child offset. Return immediate child elements. Return child element clipping border. Or Set child element clipping border. Return whether should clip child elements. Or Set whether should clip child elements. Default false. Return color attribute. Uses just the top-left color. Return combined screen coordinate rect of element and its children. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Name to assign to the child Position in the hierarchy where the button will be created, if none, this adds it as the last element. Creates a . Name assign to the created element.   You can lookup the element later with  to find this component later. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Creates a . StringHash code for the element to create, it must correspond to a  type. Name assign to the created element.   You can lookup the element later with  to find this component later. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Create and add a child element and return it. The created UIElement.    If the provided type is not a , the return value is . StringHash code for the element to create, it must correspond to a  type. Name assign to the created element.   You can lookup the element later with  to find this component later. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Create and add a child element and return it. The created element.    If the provided type is not known, the return value is . Name assign to the created element.   You can lookup the element later with  to find this component later. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Creates a . Name assign to the created element.   You can lookup the element later with  to find this component later. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Creates a . Name assign to the created element.   You can lookup the element later with  to find this component later. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Creates a . Name assign to the created element.   You can lookup the element later with  to find this component later. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Creates a . Name assign to the created element.   You can lookup the element later with  to find this component later. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Creates a . Name assign to the created element.   You can lookup the element later with  to find this component later. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Creates a . Name assign to the created element.   You can lookup the element later with  to find this component later. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Creates a . Name assign to the created element.   You can lookup the element later with  to find this component later. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Creates a . Name assign to the created element.   You can lookup the element later with  to find this component later. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Creates a . Name assign to the created element.   You can lookup the element later with  to find this component later. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Creates a . Name assign to the created element.   You can lookup the element later with  to find this component later. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Name assign to the created element.   You can lookup the element later with  to find this component later. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Creates a . Name assign to the created element.   You can lookup the element later with  to find this component later. Position in the hierarchy where the button will be created, if none, this adds it as the last element. Creates a . Handle being defocused. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return derived color. Only valid when no gradient. Return derived opacity (affected by parent elements.) If UseDerivedOpacity is false, returns same as element's own opacity. Disable automatic layout update. Should only be used if there are performance problems. React to mouse drag begin. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return the drag button combo if this element is being dragged. Return the number of buttons dragging this element. React to a mouse drag cancel event (ie, when an extra button is pressed). The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. React to drag and drop finish. Return true to signal that the drop was accepted. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return drag and drop flags. Or Set drag and drop flags. React to drag and drop test. Return true to signal that the drop is acceptable. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. React to mouse drag end. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. React to mouse drag motion. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Controls whether value is editable through input. Return effective color, multiplied by brightness and affected by temperature when "use physical values" is enabled. Alpha is always 1 so that can compare against the default black color to detect a light with no effect. A child element has been added to an element. Sent by the UI root element, or element-event-sender if set. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Get element which should send child added / removed events. A child element is about to be removed from an element. Sent by the UI root element, or element-event-sender if set. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Convert element coordinates to screen coordinates. Enable automatic positioning & sizing of the element relative to its parent using min/max anchor and min/max offset. Default false. Controls whether the element reacts to input. Returns the element's last own enabled state. May be different than the value returned by IsEnabled when SetDeepEnabled has been used. Enable automatic layout update. Filter attributes in serialization process. Find child index. Return M_MAX_UNSIGNED if not found. Return true if height is fixed. Return true if size is fixed. Return true if width is fixed. Handle being focused. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return focus mode. Or Set focus mode. Return child element by index. This is the name that was used when one of the Create methods was invoked. If , this searches on nested elements for the  with the given . Return child element by name. The child with the associated , if found, otherwise. Return corner color. Return default style. Return number of child elements. Return whether has different color in at least one corner. Return whether has focus. Tag string to probe. Determines if the UIElement has the associated tag attached to it. True if the specified tag has been associated with this UIElement. Use the  to add a tag to a UIElement, and  to remove this tag. Return height. Or Set height only. Return horizontal alignment. Or Set horizontal alignment. Hovering on an UI element has started The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Hovering on an UI element has ended The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return whether the cursor is hovering on this element. Return horizontal indentation. Or Set horizontal indentation. Return indent spacing (number of pixels per indentation level). Or Set indent spacing (number of pixels per indentation level). Return indent width in pixels. Insert a child element into a specific position in the child list. Flag that determines whether is internally created. Return whether element should send child added / removed events by itself. If false, defers to parent element. Return whether a point (either in element or screen coordinates) is inside the element. Return whether a point (either in element or screen coordinates) is inside the combined rect of the element and its children. Return whether is visible and inside a scissor rectangle and should be rendered. Return layout border. Or Set layout border. Return maximum layout element size in the layout direction. Only valid after layout has been calculated. Used internally by UI for optimizations. Return layout flex scale. Or Set layout flex scale. Return layout mode. Or Set layout mode only. Return layout spacing. Or Set layout spacing. UI element layout updated. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Create a child by loading from XML data with style. Returns the child element if successful, null if otherwise. Load from XML data. Return true if successful. Load from XML data. Return true if successful. Create a child by loading from XML data with style. Returns the child element if successful, null if otherwise. Set maximum (bottom right) anchor in relation to the parent element (from 0 to 1.) No effect when anchor is not enabled. Return minimum height. Or Set maximum height. Return maximum offset. Or Set offset of element's bottom right from the maximum anchor in pixels. No effect when anchor is not enabled. Return maximum size. Or Set maximum size. Return minimum width. Or Set maximum width. Return minimum anchor. Or Set minimum (top left) anchor in relation to the parent element (from 0 to 1.) No effect when anchor is not enabled. Return minimum height. Or Set minimum height. Return minimum offset. Or Set offset of element's top left from the minimum anchor in pixels. No effect when anchor is not enabled. Return minimum size. Or Set minimum size. Return minimum width. Or Set minimum width. Return name. Or Set name. UI element name changed. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. React to mouse click begin. React to mouse click end. React to double mouse click. React to mouse hover. React to indent change. React to a key press. React to position change. React to resze. React to editable status change. React to mouse wheel. Return opacity. Or Set opacity. Return parent element. Return pivot. Or Set pivot relative to element's size (from 0 to 1, where 0.5 is center.) Overrides horizontal & vertical alignment. Return position. Or Set position. React to position change. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return priority. Or Set priority. Register object factory. Remove from the parent element. If no other shared pointer references exist, causes immediate deletion. Remove all child elements. Remove all tags. Remove a child element. Starting search at specified index if provided. Remove a child element at index. Tag to remove Removes the specified tag from the UIElement. if the tag existed, otherwise. Use the  to add a tag to a UIElement, and  to determine if an element has the specified tag attached. Reset enabled state to the element's remembered state prior to calling SetDeepEnabled. React to resize. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return root element. Save as XML data. Return true if successful. Save as XML data. Return true if successful. Update and return screen position. Convert screen coordinates to element coordinates. Return whether is selected. Actual meaning is element dependent. Set horizontal and vertical alignment. Set color on all corners. Set color on one corner. Set enabled state on self and child elements. Elements' own enabled state is remembered (IsEnabledSelf) and can be restored. Set default style file for later use by children elements. Set element event sender flag. When child element is added or deleted, the event would be sent using UIElement found in the parental chain having this flag set. If not set, the event is sent using UI's root as per normal. Set enabled state on self and child elements. Unlike SetDeepEnabled this does not remember the elements' own enabled state, but overwrites it. Set fixed height. Set fixed size. Set fixed size. Set fixed width. Set whether is focused. Only one element can be focused at a time. Set layout. Set maximum (bottom right) anchor in relation to the parent element (from 0 to 1.) No effect when anchor is not enabled. Set maximum size. Set minimum (top left) anchor in relation to the parent element (from 0 to 1.) No effect when anchor is not enabled. Set minimum size. Set parent element. Same as parent->InsertChild(index, this). Set pivot relative to element's size (from 0 to 1, where 0.5 is center.) Overrides horizontal & vertical alignment. Set position. Set size. Set style from an XML element. Return true if the style is applied successfully. Set style from an XML file. Find the style element by name. If the style file is not explicitly provided, use the default style from parental chain. Return true if the style is applied successfully. Set style from an XML file. Find the style element automatically by using the element's typename. If the style file is not explicitly provided, use the default style from parental chain. Return true if the style is applied successfully. Set a user variable. Set a user variable. Set a user variable. Set a user variable. Set a user variable. Set a user variable. Set a user variable. Set a user variable. Set a user variable. Set a user variable. Set a user variable. Set a user variable. Return whether should sort child elements according to priority. Or Set whether should sort child elements according to priority. Default true. Return size. Or Set size. Sort child elements if sorting enabled and order dirty. Called by UI. The handler to invoke when this event is raised. Subscribes to the Defocused event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the DragBegin event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the DragCancel event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the DragDropFinish event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the DragDropTest event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the DragEnd event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the DragMove event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ElementAdded event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ElementRemoved event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the Focused event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the HoverBegin event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the HoverEnd event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the LayoutUpdated event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the NameChanged event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the Positioned event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the Resized event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the VisibleChanged event raised by the UIElement. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Return traversal mode for rendering. Or Set traversal mode for rendering. The default traversal mode is TM_BREADTH_FIRST for non-root element. Root element should be set to TM_DEPTH_FIRST to avoid artifacts during rendering. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Perform UI element update. Manually update layout. Should not be necessary in most cases, but is provided for completeness. Return whether parent elements' opacity affects opacity. Or Set whether parent elements' opacity affects opacity. Default true. Return vertical alignment. Or Set vertical alignment. Determines whether element itself should be visible. Elements can be also hidden due to the parent being not visible, use VisibleEffective to check. React to visibility change. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return whether element is effectively visible (parent element chain is visible.) Return whether the element could handle wheel input. Return width. Or Set width only. Event arguments for the UI's UIMouseClickEnd event Event arguments for the UI's UIMouseClick event Event arguments for the LineEdit's UnhandledKey event UI element vertical alignment. UI element which renders a 3D scene. Constructs a new instance of Urho.Gui.View3D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.View3D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.View3D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return whether render target updates automatically. Or Set render target auto update mode. Default is true. Return camera scene node. Return depth stencil texture. Return render texture pixel format. Or Set render texture pixel format. Default is RGB. Queue manual update on the render texture. Register object factory. Return render texture. Return scene. Define the scene and camera to use in rendering. When ownScene is true the View3D will take ownership of them with shared pointers. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return viewport. Event arguments for the ScrollView's ViewChanged event Event arguments for the UIElement's VisibleChanged event Window UI element that can optionally by moved or resized. Constructs a new instance of Urho.Gui.Window which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Gui.Window, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Gui.Window linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return whether is resizing height is fixed. Or Set whether resizing height is fixed. Return whether is resizing width is fixed. Or Set whether resizing width is fixed. Return modal flag. Or Set modal flag. When the modal flag is set, the focused window needs to be dismissed first to allow other UI elements to gain focus. Return whether can be dismissed with escape key. Or Set whether model window can be dismissed with the escape key. Default true. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Get modal frame color. Or Set modal frame color. Get modal frame size. Or Set modal frame size. Get modal shade color. Or Set modal shade color. Return whether is movable. Or Set whether can be moved. React to mouse hover. Register object factory. Return whether is resizable. Or Set whether can be resized. Return resize area width at edges. Or Set resize area width at edges. The handler to invoke when this event is raised. Subscribes to the ModalChanged event raised by the Window. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Window movement and resizing modes. Event arguments for the FileSystem's AsyncExecFinished event File opened either through the filesystem or from within a package file. Constructs a new instance of Urho.IO.File which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.IO.File, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.IO.File linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. The context that this object will be attached to. Creates an instance of File that is attached to an execution context. This creates an instance of File attached to the specified execution context. The context that this object will be attached to. Creates an instance of File that is attached to an execution context. This creates an instance of File attached to the specified execution context. Return a checksum of the file contents using the SDBM hash algorithm. Close the file. Return the file handle. Flush any buffered output to the file. Return whether is open. Return the open mode. Return the file name. Or Change the file name. Used by the resource system. Open a filesystem file. Return true if successful. Open from within a package file. Return true if successful. Return whether the file originates from a package (false if it originates from a host file system file) Read bytes from the file. Return number of bytes actually read. Set position from the beginning of the file. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Write bytes to the file. Return number of bytes actually written. File open mode. Subsystem for file and directory operations and access control. Constructs a new instance of Urho.IO.FileSystem which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.IO.FileSystem, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.IO.FileSystem linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Check if a path is allowed to be accessed. If no paths are registered, all are allowed. Copy a file. Return true if successful. Create a directory. Return the absolute current working directory. Delete a file. Return true if successful. Check if a directory exists. Return whether is executing engine console commands as OS-specific system command. Or Set whether to execute engine console commands as OS-specific system command. Check if a file exists. Return the application preferences directory. Returns the file's last modified time as seconds since 1.1.1970, or 0 if can not be accessed. Return whether paths have been registered. Return the program's directory. If it does not contain the Urho3D default CoreData and Data directories, and the current working directory does, return the working directory instead. Register a path as allowed to access. If no paths are registered, all are allowed. Registering allowed paths is considered securing the Urho3D execution environment: running programs and opening files externally through the system will fail afterward. Rename a file. Return true if successful. Set the current working directory. Set a file's last modified time as seconds since 1.1.1970. Return true on success. The handler to invoke when this event is raised. Subscribes to the AsyncExecFinished event raised by the FileSystem. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Run a program using the command interpreter, block until it exits and return the exit code. Will fail if any allowed paths are defined. Run a program using the command interpreter asynchronously. Return a request ID or M_MAX_UNSIGNED if failed. The exit code will be posted together with the request ID in an AsyncExecFinished event. Will fail if any allowed paths are defined. Open a file in an external program, with mode such as "edit" optionally specified. Will fail if any allowed paths are defined. Return path of temporary directory. Path always ends with a forward slash. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return the user documents directory. Watches a directory and its subdirectories for files being modified. Constructs a new instance of Urho.IO.FileWatcher which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.IO.FileWatcher, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.IO.FileWatcher linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add a file change into the changes queue. Return the delay in seconds for notifying file changes. Or Set the delay in seconds before file changes are notified. This (hopefully) avoids notifying when a file save is still in progress. Default 1 second. Return the path being watched, or empty if not watching. Start watching a directory. Return true if successful. Stop watching the directory. Directory watching loop. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Logging subsystem. Constructs a new instance of Urho.IO.Log which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.IO.Log, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.IO.Log linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Close the log file. Return last log message. Return logging level. Or Set logging level. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Open the log file. Return whether log is in quiet mode (only errors printed to standard error stream). The handler to invoke when this event is raised. Subscribes to the LogMessage event raised by the Log. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Return whether log messages are timestamped. Or Set whether to timestamp log messages. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Write to the log. If logging level is higher than the level of the message, the message is ignored. Write raw output to the log. Event arguments for the Log's LogMessage event Stores files of a directory tree sequentially for convenient access. Constructs a new instance of Urho.IO.PackageFile which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.IO.PackageFile, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.IO.PackageFile linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. The context that this object will be attached to. Creates an instance of PackageFile that is attached to an execution context. This creates an instance of PackageFile attached to the specified execution context. Return checksum of the package file contents. Return whether the files are compressed. Check if a file exists within the package file. This will be case-insensitive on Windows and case-sensitive on other platforms. Return the file entry corresponding to the name, or null if not found. This will be case-insensitive on Windows and case-sensitive on other platforms. Return the package file name. Return hash of the package file name. Return number of files. Open the package file. Return true if successful. Return total data size from all the file entries in the package file. Return total size of the package file. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Crowd agent component, requires a CrowdManager component in the scene. When not set explicitly, agent's radius and height are defaulted to navigation mesh's agent radius and height, respectively. Constructs a new instance of Urho.Navigation.CrowdAgent which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Navigation.CrowdAgent, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Navigation.CrowdAgent linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return the agent's actual velocity. Return the agent id. Return the agent's state. Apply attribute changes that can not be applied immediately. Called after scene load or a network update. Return the agent's desired velocity. Draw debug geometry. Draw debug feelers. Return true when the agent has arrived at its target. Return true when the agent has a target. Get the agent's height. Or Set the agent's height. Return true when the agent is in crowd (being managed by a crowd manager). Get the agent's max acceleration. Or Set the agent's max acceleration. Get the agent's max velocity. Or Set the agent's max velocity. Get the agent's navigation pushiness. Or Set the agent's navigation pushiness. Get the agent's navigation quality. Or Set the agent's navigation quality. Get the agent's obstacle avoidance type. Or Set the agent's obstacle avoidance type. Handle enabled/disabled state change. Return the agent's position. Get the agent's query filter type. Or Set the agent's query filter type. Get the agent's radius. Or Set the agent's radius. Register object factory. Return the agent's requested target type, if any. Reset any target request for the specified agent. Return the agent's requested target position. Or Submit a new target position request for this agent. Return the agent's target state. Return the agent's requested target velocity. Or Submit a new target velocity request for this agent. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return true when the node's position should be updated by the CrowdManager. Or Update the node position. When set to false, the node position should be updated by other means (e.g. using Physics) in response to the E_CROWD_AGENT_REPOSITION event. Event arguments for the CrowdManager's CrowdAgentFailure event Event arguments for the CrowdManager's CrowdAgentReposition event The agent is not in a valid state. Event arguments for the CrowdManager's CrowdAgentStateChanged event Crowd manager scene component. Should be added only to the root scene node. Constructs a new instance of Urho.Navigation.CrowdManager which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Navigation.CrowdManager, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Navigation.CrowdManager linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Apply attribute changes that can not be applied immediately. Called after scene load or a network update. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Add debug geometry to the debug renderer. Draw the agents' pathing debug data. Find the nearest point on the navigation mesh to a given point using the crowd initialized query extent (based on maxAgentRadius) and the specified query filter type. Get the cost of an area for the specified query filter type. Return distance to wall from a point using the crowd initialized query extent (based on maxAgentRadius) and the specified query filter type. Maximum search radius must be specified. Get the exclude flags for the specified query filter type. Get the include flags for the specified query filter type. Get the number of configured area in the specified query filter type. Get the params for the specified obstacle avoidance type. Return a random point on the navigation mesh using the crowd initialized query extent (based on maxAgentRadius) and the specified query filter type. Return a random point on the navigation mesh within a circle using the crowd initialized query extent (based on maxAgentRadius) and the specified query filter type. The circle radius is only a guideline and in practice the returned point may be further away. Get the maximum radius of any agent. Or Set the maximum radius of any agent. Get the maximum number of agents. Or Set the maximum number of agents. Try to move along the surface from one point to another using the crowd initialized query extent (based on maxAgentRadius) and the specified query filter type. Get the Navigation mesh assigned to the crowd. Or Assigns the navigation mesh for the crowd. Get the number of configured obstacle avoidance types. Get the number of configured query filter types. Perform a walkability raycast on the navigation mesh between start and end using the crowd initialized query extent (based on maxAgentRadius) and the specified query filter type. Return the point where a wall was hit, or the end point if no walls. Register object factory. Reset any crowd target for all crowd agents found in the specified node. Defaulted to scene node. Set the cost of an area for the specified query filter type. Set the crowd target position. The target position is set to all crowd agents found in the specified node. Defaulted to scene node. Set the crowd move velocity. The move velocity is applied to all crowd agents found in the specified node. Defaulted to scene node. Set the exclude flags for the specified query filter type. Set the include flags for the specified query filter type. Set the params for the specified obstacle avoidance type. The handler to invoke when this event is raised. Subscribes to the CrowdAgentFailure event raised by the CrowdManager. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the CrowdAgentReposition event raised by the CrowdManager. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the CrowdAgentStateChanged event raised by the CrowdManager. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Constructor. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Navigation.DynamicNavigationMesh, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Build/rebuild the entire navigation mesh. Build/rebuild a portion of the navigation mesh. Build/rebuild the entire navigation mesh. Add debug geometry to the debug renderer. Visualize the component as debug geometry. Return whether to draw Obstacles. Or Draw debug geometry for Obstacles. Return the maximum number of layers permitted to build. Or Set the maximum number of layers that navigation construction can create. Return the maximum number of obstacles allowed. Or Set the maximum number of obstacles allowed. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Register with engine context. Remove all tiles from navigation mesh. The handler to invoke when this event is raised. Subscribes to the NavigationObstacleAdded event raised by the DynamicNavigationMesh. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the NavigationObstacleRemoved event raised by the DynamicNavigationMesh. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Construct. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Navigation.NavArea, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Get the area id for this volume. Or Set the area id for this volume. Get the bounding box of this navigation area, in local space. Render debug geometry for the bounds. Register object factory and attributes. Set the bounding box of this area, in local space. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Get the bounds of this navigation area in world space. Component which tags geometry for inclusion in the navigation mesh. Optionally auto-includes geometry from child nodes. Constructs a new instance of Urho.Navigation.Navigable which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Navigation.Navigable, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Navigation.Navigable linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Set whether geometry is automatically collected from child nodes. Default true. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Event arguments for the NavigationMesh's NavigationAreaRebuilt event Navigation mesh component. Collects the navigation geometry from child nodes with the Navigable component and responds to path queries. Constructs a new instance of Urho.Navigation.NavigationMesh which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Navigation.NavigationMesh, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Navigation.NavigationMesh linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return navigation agent height. Or Set navigation agent height. Return navigation agent max vertical climb. Or Set navigation agent max vertical climb. Return navigation agent max slope. Or Set navigation agent max slope. Return navigation agent radius. Or Set navigation agent radius. Return local space bounding box of the navigation mesh. Rebuild the navigation mesh. Return true if successful. Rebuild part of the navigation mesh contained by the world-space bounding box. Return true if successful. Rebuild the navigation mesh. Return true if successful. Return cell height. Or Set cell height. Return cell size. Or Set cell size. Return detail sampling distance. Or Set detail sampling distance. Return detail sampling maximum error. Or Set detail sampling maximum error. Add debug geometry to the debug renderer. Visualize the component as debug geometry. Return whether to draw NavArea components. Or Draw debug geometry for NavArea components. Return whether to draw OffMeshConnection components. Or Draw debug geometry for OffMeshConnection components. Return edge max error. Or Set edge max error. Return edge max length. Or Set edge max length. Find the nearest point on the navigation mesh to a given point. Extents specifies how far out from the specified point to check along each axis. Get the current cost of an area Return distance to wall from a point. Maximum search radius must be specified. Return a random point on the navigation mesh. Return a random point on the navigation mesh within a circle. The circle radius is only a guideline and in practice the returned point may be further away. Return whether has been initialized with valid navigation data. Return the given name of this navigation mesh. Try to move along the surface from one point to another. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return number of tiles. Return navigation mesh bounding box padding. Or Set padding of the navigation mesh bounding box. Having enough padding allows to add geometry on the extremities of the navigation mesh when doing partial rebuilds. Return Partition Type. Or Set the partition type used for polygon generation. Perform a walkability raycast on the navigation mesh between start and end and return the point where a wall was hit, or the end point if no walls. Return region merge size. Or Set region merge size. Return region minimum size. Or Set region minimum size. Register object factory. Remove all tiles from navigation mesh. Set the cost of an area. Set the name of this navigation mesh. The handler to invoke when this event is raised. Subscribes to the NavigationAreaRebuilt event raised by the NavigationMesh. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the NavigationMeshRebuilt event raised by the NavigationMesh. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Return tile size. Or Set tile size. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return world space bounding box of the navigation mesh. Event arguments for the NavigationMesh's NavigationMeshRebuilt event Event arguments for the DynamicNavigationMesh's NavigationObstacleAdded event Event arguments for the DynamicNavigationMesh's NavigationObstacleRemoved event Obstacle for dynamic navigation mesh. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Navigation.Obstacle, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Simplified rendering of debug information for script usage. Render debug information. Get the height of this obstacle. Or Set the height of this obstacle. Get the internal obstacle ID. Update the owning mesh when enabled status has changed. Get the blocking radius of this obstacle. Or Set the blocking radius of this obstacle. Register Obstacle with engine context. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. A link between otherwise unconnected regions of the navigation mesh. Constructs a new instance of Urho.Navigation.OffMeshConnection which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Navigation.OffMeshConnection, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Navigation.OffMeshConnection linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Apply attribute changes that can not be applied immediately. Called after scene load or a network update. Return the user assigned area ID Or Sets the assigned area Id for the connection Sets bidirectional flag. Visualize the component as debug geometry. Return endpoint node. Or Set endpoint node. Return the user assigned mask Or Set a user assigned mask Return radius. Or Set radius. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Event arguments for the Network's ClientConnected event Event arguments for the Network's ClientDisconnected event Event arguments for the Connection's ClientIdentity event Event arguments for the Connection's ClientSceneLoaded event Event arguments for the Network's ConnectFailed event Connection to a remote network host. On the client, this object is retrieved after a successful connection from the  property.   On the server, a new instance of this object is created for every connected client. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Network.Connection, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return remote address. Return bytes received per second. Return bytes sent per second. Return whether is a client connection. Event raised on the server after the connection and contains the client identity information.   The default is to accept all connections. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Set network simulation parameters. Called by Network. Return whether is fully connected. Return whether connection is pending. Disconnect. If wait time is non-zero, will block while waiting for disconnect to finish. Return name of current package download, or empty if no downloads. Return progress of current package download, or 1.0 if no downloads. Return the time since last received data from the remote host in milliseconds. Return whether to log data in/out statistics. Or Set whether to log data in/out statistics. Return number of package downloads remaining. Return packets received per second. Return packets sent per second. Return remote port. Return the observer position sent by the client for interest management. Or Set the observer position for interest management, to be sent to the server. Process pending latest data for nodes and components. Return the observer rotation sent by the client for interest management. Or Set the observer rotation for interest management, to be sent to the server. Note: not used by the NetworkPriority component. Return the connection's round trip time in milliseconds. Return the scene used by this connection. Or Assign scene. On the server, this will cause the client to load it. Return whether the scene is loaded and ready to receive server updates. Send latest controls from the client. Called by Network. Sends a message over the connection. Sends a message over the connection. Send package files to client. Called by network. Trigger client connection to download a package file from the server. Can be used to download additional resource packages when client is already joined in a scene. The package must have been added as a requirement to the scene the client is joined in, or else the eventual download will fail. Send queued remote events. Called by Network. Send scene update messages. Called by Network. The handler to invoke when this event is raised. Subscribes to the ClientIdentity event raised by the Connection. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ClientSceneLoaded event raised by the Connection. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Return the controls timestamp, sent from client to server along each control update. Return an address:port string. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. An HTTP connection with response data stream. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Network.HttpRequest, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return amount of bytes in the read buffer. Return whether all response data has been read. Return error. Only non-empty in the error state. Return whether connection is in the open state. Read response data from the HTTP connection and return number of bytes actually read. While the connection is open, will block while trying to read the specified size. To avoid blocking, only read up to as many bytes as GetAvailableSize() returns. Set position from the beginning of the stream. Not supported. Return connection state. Process the connection in the worker thread until closed. Return URL used in the request. Return verb used in the request. Default GET if empty verb specified on construction. HTTP connection state Network subsystem. Manages client-server communications using the UDP protocol. Use the  subsystem to start a server, or to connect to a server. To start a server, call the  method, to connect to a server, use the  method. Constructs a new instance of Urho.Network.Network which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Network.Network, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Network.Network linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Broadcast a message with content ID to all client connections. Return whether a remote event is allowed to be received. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Disconnect the connection to the server. If wait time is non-zero, will block while waiting for disconnect to finish. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return the package download cache directory. Or Set the package download cache directory. Send outgoing messages after frame logic. Called by HandleRenderUpdate. Register a remote event as allowed to be received. There is also a fixed blacklist of events that can not be allowed in any case, such as ConsoleCommand. Trigger all client connections in the specified scene to download a package file from the server. Can be used to download additional resource packages when clients are already joined in the scene. The package must have been added as a requirement to the scene, or else the eventual download will fail. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return the connection to the server. Null if not connected. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return whether the server is running. Return simulated latency in milliseconds. Or Set simulated latency in milliseconds. This adds a fixed delay before sending each packet. Return simulated packet loss probability. Or Set simulated packet loss probability between 0.0 - 1.0. Start a server on a port using UDP protocol. Return true if successful. Stop the server. The handler to invoke when this event is raised. Subscribes to the ClientConnected event raised by the Network. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ClientDisconnected event raised by the Network. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ConnectFailed event raised by the Network. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the NetworkMessage event raised by the Network. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the NetworkSceneLoadFailed event raised by the Network. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the NetworkUpdate event raised by the Network. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the NetworkUpdateSent event raised by the Network. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ServerConnected event raised by the Network. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ServerDisconnected event raised by the Network. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Unregister all remote events. Unregister a remote event as allowed to received. Process incoming messages from connections. Called by HandleBeginFrame. Return network update FPS. Or Set network update FPS. Event arguments for the Network's NetworkMessage event %Network interest management settings component. Constructs a new instance of Urho.Network.NetworkPriority which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Network.NetworkPriority, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Network.NetworkPriority linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return whether updates to owner should be sent always at full rate. Or Set whether updates to owner should be sent always at full rate. Default true. Return base priority. Or Set base priority. Default 100 (send updates at full frequency.) Return priority reduction distance factor. Or Set priority reduction distance factor. Default 0 (no effect.) Return minimum priority. Or Set minimum priority. Default 0 (no updates when far away enough.) Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Event arguments for the Network's NetworkSceneLoadFailed event Event arguments for the Network's NetworkUpdate event Event arguments for the Network's NetworkUpdateSent event Send modes for observer position/rotation. Activated by the client setting either position or rotation. Event arguments for the Network's ServerConnected event Event arguments for the Network's ServerDisconnected event Contains the information about a physics collision event. The data in this structure is the result of a collision event between scene nodes and rigit bodies. Distance, negative when interpenetrating Impulse applied in collision Normal vector. World space position Returns a human readable description of the collision. Rigid body collision event signaling mode. Physics collision shape component. Use the collision shape component to configure the geometrical shape of the node. You configure the CollisionShape by calling one of the Set methods to configure the shape, the supported shapes are: Box shape, configure with  Capsule shape, configure with  Cone shape, configure with  Convex hull shape, configure with:  or  Cylinder shape, configure with  Triangle mesh, configure with  Sphere shape, configure with  Cylinder shape, configure with  Static plane, configure with  Heighfield terrain, configure with  (this requires a  component on the same node). Constructs a new instance of Urho.Physics.CollisionShape which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Physics.CollisionShape, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Physics.CollisionShape linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Apply attribute changes that can not be applied immediately. Called after scene load or a network update. Visualize the component as debug geometry. sadfasdfa sfas das asdf asdf Return model LOD level. Or Set model LOD level. Return collision margin. Or Set collision margin. Return triangle mesh / convex hull model. Or Set triangle mesh / convex hull model. Return model attribute. Update the new collision shape to the RigidBody. Handle enabled/disabled state change. Return physics world. Return offset position. Or Set offset position. Register object factory. Release the collision shape. Return offset rotation. Or Set offset rotation. Set as a box. Set as a capsule. Set as a cone. Set as a convex hull from Model. Set as a convex hull from CustomGeometry. Set as a triangle mesh from CustomGeometry. Set as a cylinder. Set as a sphere. Set as a static plane. Set as a terrain. Only works if the same scene node contains a Terrain component. Set offset transform. Set as a triangle mesh from Model. If you update a model's geometry and want to reapply the shape, call physicsWorld->RemoveCachedGeometry(model) first. Return shape type. Or Set shape type. Return shape size. Or Set shape size. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return world-space bounding box. Physics constraint component. Connects two rigid bodies together, or one rigid body to a static point. Constructs a new instance of Urho.Physics.Constraint which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Physics.Constraint, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Physics.Constraint linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Apply attribute changes that can not be applied immediately. Called after scene load or a network update. Apply constraint frames. Return constraint force mixing parameter. Or Set constraint force mixing parameter. Zero = leave to default. Return constraint type. Or Set constraint type and recreate the constraint. Return whether collisions between connected bodies are disabled. Or Set whether to disable collisions between connected bodies. Visualize the component as debug geometry. Return constraint error reduction parameter. Or Set constraint error reduction parameter. Zero = leave to default. Return high limit. Or Set high limit. Interpretation is constraint type specific. Return low limit. Or Set low limit. Interpretation is constraint type specific. Handle enabled/disabled state change. Return the other rigid body. May be null if connected to the static world. Or Set other body to connect to. Set to null to connect to the static world. Return constraint position relative to other body. Or Set constraint position relative to the other body. If connected to the static world, is a world space position. Return constraint rotation relative to other body. Or Set constraint rotation relative to the other body. If connected to the static world, is a world space rotation. Return rigid body in own scene node. Return physics world. Return constraint position relative to own body. Or Set constraint position relative to own body. Register object factory. Release the constraint. Return constraint rotation relative to own body. Or Set constraint rotation relative to own body. Set constraint rotation relative to own body by specifying the axis. Set constraint rotation relative to the other body by specifying the axis. Set constraint world space position. Resets both own and other body relative position, ie. zeroes the constraint error. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return constraint world position, calculated from own body. Supported constraint types. Event arguments for the PhysicsWorld's PhysicsCollisionEnd event First rigid body colliding. Second rigid body colliding. The node for the first rigid body. The node for the second rigid body. Returns true if either one of the rigid bodies is acting as a trigger (that is, the rigid body only raises the collision event, but does not apply collision forces). References the world raising this event. Event arguments for the PhysicsWorld's PhysicsCollision event First rigid body colliding. Second rigid body colliding. Collision information between the bodies, containing the position, normal, distance and impulse for each contact. The node for the first rigid body. The node for the second rigid body. Returns true if either one of the rigid bodies is acting as a trigger (that is, the rigid body only raises the collision event, but does not apply collision forces). References the world raising this event. Event arguments for the PhysicsWorld's PhysicsCollisionStart event First rigid body colliding. Second rigid body colliding. Collision information between the bodies, containing the position, normal, distance and impulse for each contact. The node for the first rigid body. The node for the second rigid body. Returns true if either one of the rigid bodies is acting as a trigger (that is, the rigid body only raises the collision event, but does not apply collision forces). References the world raising this event. Event arguments for the PhysicsWorld's PhysicsPostStep event Timestep value for the event. References the world raising this event. Event arguments for the PhysicsWorld's PhysicsPreStep event. Timestep value for the event. References the world raising this event. Physics raycast hit This structure is returned from various  methods that perform ray casts. Rigid body that was hit. Hit distance from ray origin. Hit fraction. Hit worldspace normal. Hit worldspace position. Physics simulation world component. Should be added only to the root scene node. Urho3D implements rigid body physics simulation using the Bullet library. The physics simulation has its own fixed update rate, which by default is 60Hz. When the rendering framerate is higher than the physics update rate, physics motion is interpolated so that it always appears smooth. The update rate can be changed with  property. The physics update rate also determines the frequency of fixed timestep scene logic updates. Hard limit for physics steps per frame or adaptive timestep can be configured with  property. These can help to prevent a "spiral of death" due to the CPU being unable to handle the physics load. However, note that using either can lead to time slowing down (when steps are limited) or inconsistent physics behavior (when using adaptive step.) The other physics components are: : a physics object instance. Its parameters include mass, linear/angular velocities, friction and restitution. : defines physics collision geometry. The supported shapes are box, sphere, cylinder, capsule, cone, triangle mesh, convex hull and heightfield terrain (requires the  component in the same node.) : connects two RigidBodies together, or one  to a static point in the world. Point, hinge, slider and cone twist constraints are supported.

    Movement and Collision

     Both a  and at least one  component must exist in a scene node for it to behave physically (a collision shape by itself does nothing.) Several collision shapes may exist in the same node to create compound shapes. An offset position and rotation relative to the node's transform can be specified for each. Triangle mesh and convex hull geometries require specifying a  resource and the LOD level to use.  provides two APIs for defining the collision geometry. Either setting individual properties such as the shape type or size, or specifying both the shape type and all its properties at once using ,  or  for example. RigidBodies can be either static or moving. A body is static if its mass is 0, and moving if the mass is greater than 0. Note that the triangle mesh collision shape is not supported for moving objects; it will not collide properly due to limitations in the Bullet library. In this case the convex hull shape can be used instead. The collision behaviour of a rigid body is controlled by several variables.  First, the collision layer and mask define which other objects to collide with: see . By default a rigid body is on layer 1; the layer will be ANDed with the other body's collision mask to see if the collision should be reported. A rigid body can also be set to trigger mode to only report collisions without actually applying collision forces. This can be used to implement trigger areas. Finally, the friction, rolling friction and restitution coefficients (between 0 - 1) control how kinetic energy is transferred in the collisions. Note that rolling friction is by default zero, and if you want for example a sphere rolling on the floor to eventually stop, you need to set a non-zero rolling friction on both the sphere and floor rigid bodies. By default rigid bodies can move and rotate about all 3 coordinate axes when forces are applied. To limit the movement, use  and  and set the axes you wish to use to 1 and those you do not wish to use to 0. For example moving humanoid characters are often represented by a capsule shape: to ensure they stay upright and only rotate when you explicitly set the rotation in code, set the angular factor to 0, 0, 0. To prevent tunneling of a fast moving rigid body through obstacles, continuous collision detection can be used. It approximates the object as a swept sphere, but has a performance cost, so it should be used only when necessary. Set the  and  with non-zero values to enable. To prevent false collisions, the body's actual collision shape should completely contain the radius. The motion threshold is the required motion per simulation step for CCD to kick in: for example a box with size 1 should have motion threshold 1 as well. All physics calculations are performed in world space. Nodes containing a  component should preferably be parented to the  (root node) to ensure independent motion. For ragdolls this is not absolute, as retaining proper bone hierarchy is more important, but be aware that the ragdoll bones may drift far from the animated model's root scene node. When several collision shapes are present in the same node, edits to them can cause redundant mass/inertia update computation in the . To optimize performance in these cases, the edits can be enclosed between calls to  and .

    Constraint parameters

     Constraint position (and rotation if relevant) need to be defined in relation to both connected bodies, see  and . If the constraint connects a body to the static world, then the "other body position" and "other body rotation" mean the static end's transform in world space. There is also a helper function  to assign the constraint to a world-space position; this sets both relative positions. Specifying the constraint's motion axis instead of rotation is provided as an alternative as it can be more intuitive, see . However, by explicitly specifying a rotation you can be sure the constraint is oriented precisely as you want. Hinge, slider and cone twist constraints support defining limits for the motion. To be generic, these are encoded slightly unintuitively into Vector2’s. For a hinge constraint, the low and high limit X coordinates define the minimum and maximum angle in degrees. For example -45 to 45. For a slider constraint, the X coordinates define the maximum linear motion in world space units, and the Y coordinates define maximum angular motion in degrees. The cone twist constraint uses only the high limit to define the maximum angles (minimum angle is always -maximum) in the following manner: The X coordinate is the limit of the twist (main) axis, while Y is the limit of the swinging motion about the other axes.

    Physics events

     The physics world sends 8 types of events during its update step: : before the simulation is stepped. : for each new collision during the simulation step. The participating scene nodes will also send event.  for each ongoing collision during the simulation step. The participating scene nodes will also send events.  for each collision which has ceased. The participating scene nodes will also send event.  after the simulation has been stepped. Note that if the rendering framerate is high, the physics might not be stepped at all on each frame: in that case those events will not be sent.

    Reading collision events

     A new or ongoing physics collision event will report the collided scene nodes and rigid bodies, whether either of the bodies is a trigger, and the list of contact points. These are returned in a CollisionData array, from the “Contacts” property of the EventArguments for the various physics events.     Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Physics.PhysicsWorld, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add a collision shape to keep track of. Called by CollisionShape. Add a constraint to keep track of. Called by Constraint. Add a rigid body to keep track of. Called by RigidBody. Return whether node dirtying should be disregarded. Clean up the geometry cache. Perform a physics world swept convex test using a user-supplied collision shape and return the first hit. Add debug geometry to the debug renderer. Visualize the component as debug geometry. Return simulation steps per second. Or Set simulation substeps per second. Return debug draw flags. Return gravity. Return whether Bullet's internal edge utility for trimesh collisions is enabled. Or Set whether to use Bullet's internal edge utility for trimesh collisions. Disabled by default. Return whether interpolation between simulation steps is enabled. Or Set whether to interpolate between simulation steps. Return maximum angular velocity for network replication. Or Set maximum angular velocity for network replication. Return maximum number of physics substeps per frame. Or Set maximum number of physics substeps per frame. 0 (default) is unlimited. Positive values cap the amount. Use a negative value to enable an adaptive timestep. This may cause inconsistent physics behavior. Return number of constraint solver iterations. Or Set number of constraint solver iterations. Event raised for each ongoing collision during the simulation step The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Event raised for each collision which has ceased. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Event raised or each new collision during the simulation step. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Event raised when the physics world has stepped. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Event raised when the physics world is about to be stepped. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Result is returned in this parameter.   If no body is hit by the , the result is set to position zero, normal zero, distance is set to infinity, hitFraction to zero and the body to zero. Ray that will be used to find a body. Maximum distance to raycast. Collision mask to use. Perform a physics world raycast and return the closest hit. Result is returned in this parameter.   If no body is hit by the , the result is set to position zero, normal zero, distance is set to infinity, hitFraction to zero and the body to zero. Ray that will be used to find a body. Maximum distance to raycast. The segment distance to use for each step Collision mask to use. Perform a physics world segmented raycast and return the closest hit. Useful for big scenes with many bodies. Register object factory. Invalidate cached collision geometry for a model. Remove a collision shape. Called by CollisionShape. Remove a constraint. Called by Constraint. Remove a rigid body. Called by RigidBody. Set debug geometry depth test mode. Called both by PhysicsWorld itself and physics components. Set debug draw flags. Set debug renderer to use. Called both by PhysicsWorld itself and physics components. Set gravity. Return whether is currently inside the Bullet substep loop. Perform a physics world swept sphere test and return the closest hit. Return whether split impulse collision mode is enabled. Or Set split impulse collision mode. This is more accurate, but slower. Disabled by default. The handler to invoke when this event is raised. Subscribes to the PhysicsCollision event raised by the PhysicsWorld. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the PhysicsCollisionEnd event raised by the PhysicsWorld. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the PhysicsCollisionStart event raised by the PhysicsWorld. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the PhysicsPostStep event raised by the PhysicsWorld. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the PhysicsPreStep event raised by the PhysicsWorld. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Step the simulation forward. Refresh collisions only without updating dynamics. Return whether physics world will automatically simulate during scene update. Or Enable or disable automatic physics simulation during scene update. Enabled by default. Physics rigid body component. RigidBodies can be either static or moving. A body is static if its mass is 0, and moving if the mass is greater than 0. Note that the triangle mesh collision shape is not supported for moving objects; it will not collide properly due to limitations in the Bullet library. In this case the convex hull shape can be used instead. The collision behaviour of a rigid body is controlled by several variables. First, the collision layer and mask define which other objects to collide with: see and . By default a rigid body is on layer 1; the layer will be ANDed with the other body's collision mask to see if the collision should be reported. A rigid body can also be set to trigger mode to only report collisions without actually applying collision forces. This can be used to implement trigger areas. Use the method to do this. Friction, rolling friction and restitution coefficients control how kinetic energy is transferred in the collisions. These are set with the , and properties. Note that rolling friction is by default zero, and if you want for example a sphere rolling on the floor to eventually stop, you need to set a non-zero rolling friction on both the sphere and floor rigid bodies. By default rigid bodies can move and rotate about all 3 coordinate axes when forces are applied. To limit the movement, use and and set the axes you wish to use to 1 and those you do not wish to use to 0. For example moving humanoid characters are often represented by a capsule shape: to ensure they stay upright and only rotate when you explicitly set the rotation in code, set the angular factor to 0, 0, 0. To prevent tunneling of a fast moving rigid body through obstacles, continuous collision detection (CCD) can be used. It approximates the object as a swept sphere, but has a performance cost, so it should be used only when necessary. Set the and properties to non-zero values to enable. To prevent false collisions, the body's actual collision shape should completely contain the radius. The motion threshold is the required motion per simulation step for CCD to kick in: for example a box with size 1 should have motion threshold 1 as well. All physics calculations are performed in world space. Nodes containing a RigidBody component should preferably be parented to the Scene (root node) to ensure independent motion. For ragdolls this is not absolute, as retaining proper bone hierarchy is more important, but be aware that the ragdoll bones may drift far from the animated model's root scene node. When several collision shapes are present in the same node, edits to them can cause redundant mass/inertia update computation in the RigidBody. To optimize performance in these cases, the edits can be enclosed between calls to and . The following example shows how you setup both the rigid body on a node to be a box shape, and how to set it up so it detects collisions: (); body.Mass = 1; body.SetKinematic (true); var shape = node.CreateComponent (); shape.SetBox (new Vector3(1,1,1), Vector.Zero, Quaternion.Identity); node.NodeCollisionStart += (args) => { Console.WriteLine (“Collision with {0}”, args.OtherNode); }; }]]> Constructs a new instance of Urho.Physics.RigidBody which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Physics.RigidBody, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Physics.RigidBody linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Activate rigid body if it was resting. Return whether rigid body is active (not sleeping). Add a constraint that refers to this rigid body. Return angular velocity damping factor. Or Set angular velocity damping factor. Return angular degrees of freedom. Return angular velocity deactivation threshold. Or Set angular velocity deactivation threshold. Return angular velocity. Return anisotropic friction. Apply attribute changes that can not be applied immediately. Called after scene load or a network update. Apply force to center of mass. Apply force at local position. Apply impulse to center of mass. Apply impulse at local position. Apply torque. Apply torque impulse. Apply new world transform after a simulation step. Called internally. Return continuous collision detection motion-per-simulation-step threshold. Or Set continuous collision detection motion-per-simulation-step threshold. 0 disables, which is the default. Return Continuous Collision Detection (CCD) swept sphere radius. Or Set continuous collision detection swept sphere radius. Return center of mass offset. Return collision event signaling mode. Or Set collision event signaling mode. Default is to signal when rigid bodies are active. Return collision layer. Or Set collision layer. Return collision mask. Or Set collision mask. Return contact processing threshold. Or Set contact processing threshold. Disable mass update. Call this to optimize performance when adding or editing multiple collision shapes in the same node. Visualize the component as debug geometry. Re-enable mass update and recalculate the mass/inertia by calling UpdateMass(). Call when collision shape changes are finished. Return friction coefficient. Or Set friction coefficient. Value is between 0 and 1. Return linear velocity at local point. Return gravity override. If zero (default), uses the physics world's gravity. Or Set gravity override. If zero, uses physics world's gravity. Controls the Kinematic mode. When the kinematic mode is on, forces are not applied to the rigid body. Return linear velocity damping factor. Or Set linear velocity damping factor. Return linear degrees of freedom. Return linear velocity deactivation threshold. Or Set linear velocity deactivation threshold. Return linear velocity. Return mass. Or Set mass. Zero mass makes the body static. Handle enabled/disabled state change. Return physics world. Return rigid body position in world space. Readd rigid body to the physics world to clean up internal state like stale contacts. Register object factory. Remove the rigid body. Remove a constraint that refers to this rigid body. Reset accumulated forces. Return restitution coefficient. Or Set restitution coefficient. Value is between 0 and 1. Return rolling friction coefficient. Or Set rolling friction coefficient. Value is between 0 and 1. Return rigid body rotation in world space. Set angular degrees of freedom. Use 1 to enable an axis or 0 to disable. Default is all axes enabled (1, 1, 1). Set angular velocity. Set anisotropic friction. Set collision group and mask. Set linear degrees of freedom. Use 1 to enable an axis or 0 to disable. Default is all axes enabled (1, 1, 1). Set linear velocity. Set rigid body position in world space. Set rigid body rotation in world space. Set rigid body position and rotation in world space as an atomic operation. Controls the trigger mode (whether collisions are reported, but no forces are applied). In trigger mode collisions are reported but do not apply forces. This can be used to implement trigger areas. Note that sensors can only be triggered by dynamic bodies and also, 2D physics queries do not report triggers To get notified when a sensor is triggered or cease to be triggered, subscribe to  and . Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Update gravity parameters to the Bullet rigid body. Update mass and inertia to the Bullet rigid body. Return whether rigid body uses gravity. Or Set whether gravity is applied to rigid body. Collision shape type. Box type. Capsule type. Cone type. Convexhull type. Cylinder. Sphere shape. Static plane shape. Terrain type. Shape defined by a triangle mesh. Asynchronous loading state of a resource. Supported compressed image formats. Event arguments for the ResourceCache's FileChanged event Interface that provides a serialization API to retrieve state during a load operation. The key to retrieve from storage. Retrieves an object with the given key and with the given type. The valid types for T are string, Vector2, Vector3, Vector4, IntRect, Quaternion, Colors, floats, ints, unsigned ints, bools and doubles. Interface that provides a serialization API to store state during a save operation. A unique value. The types can be strings, Vector2, Vector3, Vector4, IntRect, Quaternion, Colors, floats, ints, unsigned ints, bools and doubles. Serializes the value with the specified key. %Image resource. Save the image to a file. Format of the image is determined by file extension. JPG is saved with maximum quality. Constructs a new instance of Urho.Resources.Image which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Resources.Image, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Resources.Image linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Whether this texture has been detected as a volume, only relevant for DDS. Clean up the mip levels. Clear the image with a color. Clear the image with an integer color. R component is in the 8 lowest bits. Return number of color components. Return whether is compressed. Return compressed format. Return image converted to 4-component (RGBA) to circumvent modern rendering API's not supporting e.g. the luminance-alpha format. Whether this texture is detected as a cubemap, only relevant for DDS. Return pixel data. Return depth. Flip image horizontally. Return true if successful. Flip image vertically. Return true if successful. Return a compressed mip level. Return a 2D pixel color. Return a 3D pixel color. Return a bilinearly sampled 2D pixel color. X and Y have the range 0-1. Return a 2D pixel integer color. R component is in the 8 lowest bits. Return a 3D pixel integer color. R component is in the 8 lowest bits. Return a trilinearly sampled 3D pixel color. X, Y and Z have the range 0-1. Return subimage from the image by the defined rect or null if failed. 3D images are not supported. You must free the subimage yourself. Whether this texture has an alpha channel Return height. Return next mip level by bilinear filtering. Return the next sibling image of an array or cubemap. Return number of compressed mip levels. Precalculate the mip levels. Used by asynchronous texture loading. Register object factory. Resize image by bilinear resampling. Return true if successful. Save the image to a stream. Regardless of original format, the image is saved as png. Compressed image data is not supported. Return true if successful. Save in BMP format. Return true if successful. Save in DDS format. Only uncompressed RGBA images are supported. Return true if successful. Save in JPG format with compression quality. Return true if successful. Save in PNG format. Return true if successful. Save in TGA format. Return true if successful. Set new image data. Set a 2D pixel. Set a 3D pixel. Set a 2D pixel with an integer color. R component is in the 8 lowest bits. Set a 3D pixel with an integer color. R component is in the 8 lowest bits. Set 2D size and number of color components. Old image data will be destroyed and new data is undefined. Return true if successful. Set 3D size and number of color components. Old image data will be destroyed and new data is undefined. Return true if successful. Whether this texture is in sRGB, only relevant for DDS. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return width. JSON document resource. Constructs a new instance of Urho.Resources.JsonFile which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Resources.JsonFile, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Resources.JsonFile linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. JSON number type. JSON value type. Event arguments for the ResourceCache's LoadFailed event Localization subsystem. Stores all the strings in all languages. Constructs a new instance of Urho.Resources.Localization which is tied to the . Constructs a new instance of Urho.Resources.Localization linked to a specific . Return the name of current language. Return the index number of current language. The index is determined by the order of loading. Return the name of current language. Return the index number of current language. The index is determined by the order of loading. Return the number of languages. Clear all loaded strings. The handler to invoke when this event is raised. Subscribes to the ChangeLanguage event raised by the Urho.Resources.Localization (single subscriber). Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Property list (plist). Constructs a new instance of Urho.Resources.PListFile which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Resources.PListFile, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Resources.PListFile linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. PList value types. Event arguments for the Resource's ReloadFailed event Event arguments for the Resource's ReloadFinished event Event arguments for the Resource's ReloadStarted event Base class for resources. Constructs a new instance of Urho.Resources.Resource which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Resources.Resource, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Resources.Resource linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return the asynchronous loading state. Or Set the asynchronous loading state. Called by ResourceCache. Resources in the middle of asynchronous loading are not normally returned to user. Load resource from stream. May be called from a worker thread. Return true if successful. Finish resource loading. Always called from the main thread. Return true if successful. Load resource synchronously. Call both BeginLoad() & EndLoad() and return true if both succeeded. Return memory use in bytes, possibly approximate. Or Set memory use in bytes, possibly approximate. Return name. Or Set name. Return name hash. Resource reloading failed. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Resource reloading finished. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Resource reloading started. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Reset last used timer. Save resource to file. The handler to invoke when this event is raised. Subscribes to the ReloadFailed event raised by the Resource. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ReloadFinished event raised by the Resource. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ReloadStarted event raised by the Resource. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return time since last use in milliseconds. If referred to elsewhere than in the resource cache, returns always zero. Event arguments for the ResourceCache's ResourceBackgroundLoaded event %Resource cache subsystem. Loads resources on demand and stores them for later access. Constructs a new instance of Urho.Resources.ResourceCache which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Resources.ResourceCache, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Resources.ResourceCache linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add a manually created resource. Must be uniquely named. Add a package file for loading resources from by name. Optional priority parameter which will control search order. Add a package file for loading resources from. Optional priority parameter which will control search order. Add a resource load directory. Optional priority parameter which will control search order. Add a resource router object. By default there is none, so the routing process is skipped. Return whether automatic resource reloading is enabled. Or Enable or disable automatic reloading of resources as files are modified. Default false. Name of the resource to load If  this raises the  event. Background load a resource. An event will be sent when complete. Return true if successfully stored to the load queue, false if eg. already exists. Can be called from outside the main thread. Return whether a file exists by name. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return how many milliseconds maximum to spend on finishing background loaded resources. Or Set how many milliseconds maximum per frame to spend on finishing background loaded resources. Name of the resource to load If  this raises the  event. Name of the resource to load If  this raises the  event. Type signature for the resource type to load. Name of the resource to load Fetches an already loaded resource of specific type and name. Returns ther resoruce, or if not found.  Will not load if does not exist. If  this raises the  event. Open and return a file from the resource load paths or from inside a package file. If not found, use a fallback search with absolute path. Return null if fails. Can be called from outside the main thread. If  this raises the  event. Fetches a font stored as a resource. Name of the resource to load If this raises the  event. Loads an image resource by name.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Return either the path itself or its parent, based on which of them has recognized resource subdirectories. Type signature for the resource type to load. Name of the resource to load If  this raises the  event. Return a resource by type and name. Load if not loaded yet. Return null if not found or if fails, unless SetReturnFailedResources(true) has been called. Can be called only from the main thread.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource. Return full absolute file name of resource if possible. The full path name, or an empty string if the resource name does not exist in any of the registered resource directories. Return a resource router by index. Name of the resource to load If  this raises the  event.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event. Load a resource without storing it in the resource cache. Return null if not found or if fails. Can be called from outside the main thread if the resource itself is safe to load completely (it does not possess for example GPU data.)  if not found, or if there is an error.   Unless  has been set to . Name of the resource to load If  this raises the  event. Loads a 2D Texture resource by name.   if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event. Loads a 3D Texture resource by name.   if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event. Loads a Texture Cube resource by name.   if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. Name of the resource to load If  this raises the  event.  if not found, or if there is an error.   Unless  has been set to . It loads the resource if it has not been loaded yet. Should only be called from the main thread. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return number of pending background-loaded resources. Return added package files. Returns a formatted string containing the memory actively used. Release all resources. When called with the force flag false, releases all currently unused resources. Release a resource by name. Release resources of all types by partial name. Release all resources of a specific type. Release resources of a specific type and partial name. Reload a resource. Return true on success. The resource will not be removed from the cache in case of failure. Reload a resource based on filename. Causes also reload of dependent resources if necessary. Remove a package file by name. Optionally release the resources loaded from it. Remove a package file. Optionally release the resources loaded from it. Remove a resource load directory. Remove a resource router object. Reset dependencies for a resource. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Event raised by any of the Get resource methods if the requested resource is not found. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return whether resources that failed to load are returned. Or Enable or disable returning resources that failed to load. Default false. This may be useful in editing to not lose resource ref attributes. Remove unnecessary constructs from a resource directory name and ensure it to be an absolute path. Remove unsupported constructs from the resource name to prevent ambiguity, and normalize absolute filename to resource path relative if possible. Return whether when getting resources should check package files or directories first. Or Define whether when getting resources should check package files or directories first. True for packages, false for directories. Store a dependency for a resource. If a dependency file changes, the resource will be reloaded. The handler to invoke when this event is raised. Subscribes to the FileChanged event raised by the ResourceCache (single subscriber). Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the LoadFailed event raised by the ResourceCache. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ResourceBackgroundLoaded event raised by the ResourceCache. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the ResourceNotFound event raised by the ResourceCache. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the UnknownResourceType event raised by the ResourceCache. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Return total memory use for all resources. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Event arguments for the ResourceCache's ResourceNotFound event Resource request types. Event arguments for the ResourceCache's UnknownResourceType event XMLElement based implementation of IComponentSerializer Element in an XML file. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Resources.XmlElement, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Return bounding box attribute, or empty if missing. Return XML file. Return attribute, or empty if missing. Return attribute in lowercase, or empty if missing. Return attribute in lowercase, or empty if missing. Return bool attribute, or false if missing. Copy buffer attribute into a supplied buffer. Return true if buffer was large enough. Return a color attribute, or default if missing. Return a double attribute, or zero if missing. Return a float attribute, or zero if missing. Return an integer attribute, or zero if missing. Return an IntRect attribute, or default if missing. Return an IntVector2 attribute, or default if missing. Return a Matrix3 attribute, or zero matrix if missing. Return a Matrix3x4 attribute, or zero matrix if missing. Return a Matrix4 attribute, or zero matrix if missing. Return a quaternion attribute, or default if missing. Return a Rect attribute, or default if missing. Return an unsigned integer attribute, or zero if missing. Return a variant attribute with static type. Return any Vector attribute as Vector4. Missing coordinates will be zero. Return a Vector2 attribute, or zero vector if missing. Return a Vector3 attribute, or zero vector if missing. Return a Vector4 attribute, or zero vector if missing. Return a float, Vector or Matrix attribute as Variant. Return whether has an attribute. Return whether has a child element. Return element name (or attribute name if it is an attribute only XPath query result). Return next XPath query result. Only valid when this instance of XMLElement is itself one of the query result in the result set. Return whether refers to an element or an XPath node. Return whether does not refer to an element or an XPath node. Return number of attributes. Return parent element. Remove element from its parent. Remove an attribute by name. Return true if successful. Remove a child element by name. Return true if successful. Remove child elements of certain name, or all child elements if name is empty. Return true if successful. Return a resource reference attribute, or empty if missing. Return a resource reference list attribute, or empty if missing. Set an attribute. Only valid if it is an attribute only XPath query result. Set an attribute. Set a bool attribute. Set a BoundingBox attribute. Set a buffer attribute. Set a color attribute. Set a double attribute. Set a float attribute. Set an integer attribute. Set an IntRect attribute. Set an IntVector2 attribute. Set a quaternion attribute. Set a string attribute. Set an unsigned integer attribute. Set the value for an inner node in the following format value . Set a variant attribute. Set a variant attribute. Set a variant attribute. Set a variant attribute. Set a variant attribute. Set a variant attribute. Set a variant attribute. Set a variant attribute. Set a variant attribute. Set a variant attribute. Set a variant attribute excluding the type. Set a variant attribute excluding the type. Set a variant attribute excluding the type. Set a variant attribute excluding the type. Set a variant attribute excluding the type. Set a variant attribute excluding the type. Set a variant attribute excluding the type. Set a variant attribute excluding the type. Set a variant attribute excluding the type. Set a variant attribute excluding the type. Set a Vector2 attribute. Set a Vector3 attribute. Set a Vector4 attribute. Set a float, Vector or Matrix attribute stored in a variant. Set a float, Vector or Matrix attribute stored in a variant. Set a float, Vector or Matrix attribute stored in a variant. Set a float, Vector or Matrix attribute stored in a variant. Set a float, Vector or Matrix attribute stored in a variant. Set a float, Vector or Matrix attribute stored in a variant. Set a float, Vector or Matrix attribute stored in a variant. Set a float, Vector or Matrix attribute stored in a variant. Set a float, Vector or Matrix attribute stored in a variant. Set a float, Vector or Matrix attribute stored in a variant. Return inner value, or empty if missing for nodes like value Return a variant attribute, or empty if missing. Return current result index. Return XPath query result set. XML document resource. Constructs a new instance of Urho.Resources.XmlFile which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Resources.XmlFile, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Resources.XmlFile linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Deserialize from a string. Return true if successful. Register object factory. Serialize the XML content to a string. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Component that creates a Box. (); box.Color = Color.Blue; }]]> Constructs an instance of the type, for internal use. These types are created by calling Returns the path of the model for this shape, for the shape to work, the MDL file in the CoreData package must exist. Component that creates a Cone. (); cone.Color = Color.Blue; }]]> Constructs an instance of the type, for internal use. These types are created by calling Returns the path of the model for this shape, for the shape to work, the MDL file in the CoreData package must exist. Component that creates a Cylinder. (); cylinder.Color = Color.Blue; }]]> Constructs an instance of the type, for internal use. These types are created by calling Returns the path of the model for this shape, for the shape to work, the MDL file in the CoreData package must exist. Component that creates a Plane. (); plane.Color = Color.Blue; }]]> Constructs an instance of the type, for internal use. These types are created by calling Returns the path of the model for this shape, for the shape to work, the MDL file in the CoreData package must exist. Component that creates a Pyramid. (); pyramid.Color = Color.Blue; }]]> Constructs an instance of the type, for internal use. These types are created by calling Returns the path of the model for this shape, for the shape to work, the MDL file in the CoreData package must exist. Base class for the shapes in the namespace. You can subclass this class if you want to create your own shape.   Shapes are components loaded from a model, and with a convenience  property surfaced that controls the color of the shape.   The color control is implemented by using an  that is bundled in CoreData called Techniques/NoTextureAlpha.xml and the color is applied by setting the the MatDiffColor shader parameter. To create your own shape, override the  property to return the path of the model.   The path should be a file that can be located in the CoreData package for your application. Constructs an instance of the type, for internal use. These types are created by calling Color for the shape. Returns the path of the model for this shape, for the shape to work, the MDL file in the CoreData package must exist. Implements OnAttachedToNode. Deserialization that restores the shape from storage. Serialization that saves the shape from storage. Component that creates a Sphere. (); sphere.Color = Color.Blue; }]]> Constructs an instance of the type, for internal use. These types are created by calling Returns the path of the model for this shape, for the shape to work, the MDL file in the CoreData package must exist. Component that creates a Torus. (); torus.Color = Color.Blue; }]]> Constructs an instance of the type, for internal use. These types are created by calling Returns the path of the model for this shape, for the shape to work, the MDL file in the CoreData package must exist. Component that creates a 3D grid for debug purposes. The DebugGrid creates a 3D geometry using with a fixed step. It helps to align urho objects in a real world. Spatial cursor component. Displays a small static model ( by default) and updates its position each frame according to user's gaze. It sends a raycast each frame update and raises Raycasted event that can be used if you also need to send a raycast in order to avoid doing it twice. The model will be rotated according to a Normal of a geometry touched by the raycast. Runs a quick click animation using SetShaderAnimation method. Enables or disables cursor. Node containing cursor's StaticModel. Cursor's root node. Fired after each recast made by the cursor. Runs a default 'Idle' animation. Contains spatial mesh data. This structure contains all information that can be extracted from SharpReality Spatial Mapping API. See  for more details. Spatial surface timestamp. Array of indices (see IndexBuffer). Spatial surface unique id (Guid). Transform that can be applied to convert to world coordinates. Array of SpatialVertex (see VertexBuffer). Represents a vertex from a spatial mesh. Consists of a position, normal and a color. This structure can be used directly in VertexBuffer in SetData in case if ElementMask is set to 'Position | Normal  | Color'. Vertex color. Vertex Normal. Vertex position. Base class for creating holographics applications for SharpReality. This is the base class that your holographics application should subclass and provide an implementation for the Application.Start. It is important to not that your implementation should start with base.Start() that creates a basic scene for you. The minimal holographics application looks like the following: (); } } ]]> Creates from spatial geometry using with and . Instance of object that can be used in or components. Default directional in the basic scene. Distance between eyes. StereoApplication doesn't set any offset between cameras, instead of doing that it applies View and Projection matrices from SharpReality API for both eyes. With the given data we can calculate the real distance between eyes used by the system. This distance depends on system calibration. For an average person it would be 63mm or (0.063, 0, 0) in Urho. Emulator mode Enables or disables Hold gesture. See https://developer.microsoft.com/en-us/windows/holographic/gestures for details Enables or disables Manipulation gesture. Enables or disables Tapped and Double Tapped gestures. Focus point in World coordinates. Informs the system about a specific point in your scene to prioritize for image stabilization. You should set the focus point near the content that the user is looking at. Creates Model from spatial surfaces. Can be overriden but most likely will be called in a background thread. The default implementation uses . User's current position. The exact position will be between the cameras representing user's eyes. component that represents user's left eye. Fast access to added to the basic scene. Can be used for ray casting. Invokes when user uses double tap gesture. Requires enabled EnableGestureTapped property. Invokes when user cancels Hold gesture. Requires enabled EnableGestureHold property. Invokes when user completes Hold gesture. Requires enabled EnableGestureHold property. Invokes when user starts Hold gesture. Requires enabled EnableGestureHold property. Invokes when user cancels Manipulation gesture. Requires enabled EnableGestureManipulation property. Invokes when user completes Manipulation gesture. Requires enabled EnableGestureManipulation property. Invokes when user starts Manipulation gesture. Requires enabled EnableGestureManipulation property. Invokes when user uses Manipulation gesture. Requires enabled EnableGestureManipulation property. Model created by . Invokes when SharpReality recognizes a new spatial surface or updates any existing.. Set of voice commands. Registers set of voice commands with handlers. Returns false if 'Microphone' device capability was not enabled in the AppManifest. You should enable 'Microphone' device capability in the AppManifest. component that represents user's right eye. Root node of the simple scene created in Start metod. Bounding volume to observe. Vector3(20, 10, 5) means a box that is 20x10x5 meters. Desired accuracy. Starts spatial mapping procedure. Returns 'false' if spatialMapping device capability is not defined in the app's manifest. See  for more details. Make sure 'spatialMapping' device capability is enabled. See  and  for more details. Stops spatial mapping process. You will stop receiving OnSurfaceAddedOrUpdated events. Animated sprite component, it uses to play animation created by Spine (http://www.esotericsoftware.com) and Spriter (http://www.brashmonkey.com/). Constructs a new instance of Urho.Urho2D.AnimatedSprite2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.AnimatedSprite2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.AnimatedSprite2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return animation name. Return animation. Or Set animation set. Return animation set attribute. Return entity name. Or Set entity name (skin name for spine, entity name for spriter). Return loop mode. Or Set loop mode. Handle enabled/disabled state change. Register object factory. Set animation by name and loop mode. Set animation by name. Return speed. Or Set speed. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Spriter animation set, it includes one or more animations, for more information please refer to http://www.esotericsoftware.com and http://www.brashmonkey.com/spriter.htm. Constructs a new instance of Urho.Urho2D.AnimationSet2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.AnimationSet2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.AnimationSet2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Finish resource loading. Always called from the main thread. Return true if successful. Return animation name. Return spriter file sprite. Check has animation. Get number of animations. Register object factory. Return sprite. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Rigid body type. A dynamic body is fully simulated. It can be moved manually by the user, but normally it moves according to forces. A dynamic body can collide with all body types. A dynamic body always has finite, non-zero mass. If you try to set the mass of a dynamic body to zero, it will automatically acquire a mass of one kilogram. Physics queries don't report triggers. To get notified when a sensor is triggered or cease to be triggered, subscribe to  and  physics events. a kinematic body moves under simulation according to its velocity. Kinematic bodies do not respond to forces. They can be moved manually by the user, but normally a kinematic body is moved by setting its velocity. A kinematic body behaves as if it has infinite mass, however, Box2D stores zero for the mass and the inverse mass. Kinematic bodies do not collide with other static or kinematic bodies. a static body does not move under simulation and behaves as if it has infinite mass. Internally, Box2D stores zero for the mass and the inverse mass. Static bodies can be moved manually by the user. A static body has zero velocity. Static bodies do not collide with other static or kinematic bodies. 2D box collision component. Box shapes have an optional position offset (), width and height size () and a rotation angle expressed in degrees ().  Boxes are solid, so if you need a hollow box shape then create one from a  shape. Constructs a new instance of Urho.Urho2D.CollisionBox2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.CollisionBox2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.CollisionBox2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return angle. Or Set angle. Return center. Or Set center. Register object factory. Set center. Set size. Return size. Or Set size. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. 2D chain collision component. The chain shape provides an efficient way to connect many edges together to construct your static game worlds. You can connect chains together using ghost vertices. Self-intersection of chain shapes is not supported. Constructs a new instance of Urho.Urho2D.CollisionChain2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.CollisionChain2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.CollisionChain2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return vertex. Return loop. Or Set loop. Register object factory. Set vertex. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return vertex count. Or Set vertex count. 2D circle collision component. Circle shapes have an optional position offset () and a radius ().  Circles are solid, you cannot make a hollow circle using the circle shape. Constructs a new instance of Urho.Urho2D.CollisionCircle2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.CollisionCircle2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.CollisionCircle2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return center. Or Set center. Return radius. Or Set radius. Register object factory. Set center. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. 2D edge collision component. Edge shapes are line segments defined by 2 vertices  and .  They are provided to assist in making a free-form static environment for your game. A major limitation of edge shapes is that they can collide with circles and polygons but not with themselves. The collision algorithms used by Box2D require that at least one of two colliding shapes have volume. Edge shapes have no volume, so edge-edge collision is not possible. Constructs a new instance of Urho.Urho2D.CollisionEdge2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.CollisionEdge2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.CollisionEdge2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Register object factory. Set vertices. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return vertex 1. Or Set vertex 1. Return vertex 2. Or Set vertex 2. 2D polygon collision component. Polygon shapes are solid convex polygons. A polygon is convex when all line segments connecting two points in the interior do not cross any edge of the polygon. A polygon must have 3 or more vertices. Polygons vertices winding doesn't matter. Constructs a new instance of Urho.Urho2D.CollisionPolygon2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.CollisionPolygon2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.CollisionPolygon2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return vertex. Register object factory. Set vertex. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return vertex count. Or Set vertex count. 2D collision shape component. This implements Box2D fixtures and Collision Filtering.
    Box2D supports collision filtering (restricting which other objects to collide with) using categories and groups:

    Collision categories: First assign the collision shape to a category, using P:Urho.Urho2D.CollisionShape2D.CategoryBits. Sixteen categories are available.

    Then you can specify what other categories the given collision shape can collide with, using&amp;amp;nbsp;P:Urho.Urho2D.CollisionShape2D.MaskBits.

    Collision groups: positive and negative indices assigned using&amp;amp;nbsp;P:Urho.Urho2D.CollisionShape2D.GroupIndex. All collision shapes within the same group index either always collide (positive index) or never collide (negative index).

    Note that:
    • a collision group has higher precedence than collision category
    • a collision shape on a static body can only collide with a dynamic body
    • a collision shape on a kinematic body can only collide with a dynamic body
    • collision shapes on the same body never collide with each other

    A collision shape can be set to trigger mode to only report collisions without actually applying collision forces. This can be used to implement trigger areas. Note that:

    Sensors

    A sensor can be triggered only by dynamic bodies&amp;nbsp;T:Urho.Urho2D.BodyType2D’s Dynamic.

    Physics queries don't report triggers. To get notified when a sensor is triggered or cease to be triggered, subscribe to E:Urho.Urho2D.PhysicsWorld2D.PhysicsBeginContact2D&amp;nbsp;and&amp;nbsp;E:Urho.Urho2D.PhysicsWorld2D.PhysicsEndContact2D&amp;nbsp;physics events.

         Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.CollisionShape2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return filter category bits. Or Set filter category bits. Create fixture. Return density. Or Set density. Return friction. Or Set friction. Return filter group index. Or Set filter group index. Return inertia. Return filter mask bits. Or Set filter mask bits. Return mass. Return mass center. Handle enabled/disabled state change. Register object factory. Release fixture. Return restitution. Or Set restitution . Controls the trigger. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. 2D physics constraint component. Base class for the various 2D physics constraints.  Constraints ('joints' in Box2D terminology) are used to constrain bodies to an anchor point or between themselves. Apply a constraint to a node, called the  and use  to set the other node's body to be constrained to the owner body. See 32_Urho2DConstraints sample for detailed examples and to help selecting the appropriate constraint.  Following are the available constraints classes, with the indication of the corresponding 'joint' in Box2D manual (see Chapter 8 Joints): Constructs a new instance of Urho.Urho2D.Constraint2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.Constraint2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.Constraint2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Apply attribute changes that can not be applied immediately. Called after scene load or a network update. Return attached constraint (for gear). Or Set attached constriant (for gear). Return collide connected. Or Set collide connected. Create Joint. Handle enabled/disabled state change. Return other body. Or Set other rigid body. Return owner body. Register object factory. Release Joint. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. 2D distance constraint component. The distance between two anchor points  and  on two bodies is kept constant.  The constraint can also be made soft, like a spring-damper connection. Softness is achieved by tuning frequency ( is below half of the timestep) and damping ratio (). Constructs a new instance of Urho.Urho2D.ConstraintDistance2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.ConstraintDistance2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.ConstraintDistance2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return damping ratio. Or Set damping ratio. Return frequency Hz. Or Set frequency Hz. Return length. Or Set length. Return other body anchor. Or Set other body anchor. Return owner body anchor. Or Set owner body anchor. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. 2D friction constraint component. This constraint is used for top-down friction. It provides 2D translational friction () and angular friction (). Constructs a new instance of Urho.Urho2D.ConstraintFriction2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.ConstraintFriction2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.ConstraintFriction2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return anchor. Or Set anchor. Set max force. Or Set max force. Set max torque. Or Set max torque. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. 2D gear constraint component. Used to create sophisticated mechanisms and saves from using compound shapes.  This constraint can only connect  and/or . Like the pulley ratio, you can specify a gear ratio. However, in this case the gear ratio can be negative. Constructs a new instance of Urho.Urho2D.ConstraintGear2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.ConstraintGear2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.ConstraintGear2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return other constraint. Or Set other constraint. Return owner constraint. Or Set owner constraint. Return ratio. Or Set ratio. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. 2D motor constraint component. This constraint lets you control the motion of a body by specifying target position ( and rotation offsets ().  You can set the maximum motor force () and torque () that will be applied to reach the target position and rotation. If the body is blocked, it will stop and the contact forces will be proportional to the maximum motor force and torque. Constructs a new instance of Urho.Urho2D.ConstraintMotor2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.ConstraintMotor2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.ConstraintMotor2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return angular offset. Or Set angular offset. Return correction factor. Or Set correction factor. Return linear offset. Or Set linear offset. Return max force. Or Set max force. Return max torque. Or Set max torque. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. 2D mouse constraint component. Used to manipulate bodies with the mouse.   This constraint is almost used in every Box2D tutorial available on the net, to allow interacting with the 2D scene.  It attempts to drive a point on a body towards the current position of the cursor. There is no restriction on rotation. This constraint has a target point, maximum force, frequency, and damping ratio.  The target point  initially coincides with the body’s anchor point. The maximum force  is used to prevent violent reactions when multiple dynamic bodies interact. You can make this as large as you like. The frequency  and damping ratio  are used to create a spring/damper effect similar to the ConstraintDistance2D.  Many users have tried to adapt the ConstraintMouse2D for game play. Users often want to achieve precise positioning and instantaneous response. The ConstraintMouse2D doesn’t work very well in that context. You may wish to consider using kinematic bodies instead. Constructs a new instance of Urho.Urho2D.ConstraintMouse2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.ConstraintMouse2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.ConstraintMouse2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return damping ratio. Or Set damping ratio. Return frequency Hz. Or Set frequency Hz. Return max force. Or Set max force. Register object factory. Return target. Or Set target. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. 2D prismatic constraint component. This constraint allows for relative translation of two bodies along a specified axis . There's no rotation applied. This constraint definition is similar to  description; just substitute translation for angle and force for torque. Constructs a new instance of Urho.Urho2D.ConstraintPrismatic2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.ConstraintPrismatic2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.ConstraintPrismatic2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return anchor. Or Set anchor. Return axis. Or Set axis. Return enable limit. Or Set enable limit. Return enable motor. Or Set enable motor. Return lower translation. Or Set lower translation. Return maxmotor force. Or Set maxmotor force. Return motor speed. Or Set motor speed. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return upper translation. Or Set upper translation. 2D pulley constraint component. The pulley connects two bodies to ground  and  and to each other  and .  As one body goes up, the other goes down. You can supply a ratio  that simulates a block and tackle. This causes one side of the pulley to extend faster than the other. At the same time the constraint force is smaller on one side than the other.  You can use this to create mechanical leverage. Constructs a new instance of Urho.Urho2D.ConstraintPulley2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.ConstraintPulley2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.ConstraintPulley2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return other body anchor. Or Set other body anchor point. return other body ground anchor. Or Set other body ground anchor point. Return owner body anchor. Or Set owner body anchor point. Return owner body ground anchor. Or Set other body ground anchor point. Return ratio. Or Set ratio. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. 2D revolute constraint component. This constraint forces two bodies to share a common hinge anchor point .  You can control the relative rotation of the two bodies (the constraint angle) using a limit and/or a motor. A limit  forces the joint angle to remain between a lower  and upper  bound.  The limit will apply as much torque as needed to make this happen. The limit range should include zero, otherwise the constraint will lurch when the simulation begins. A motor () allows you to specify the constraint speed (the time derivative of the angle). The speed () can be negative or positive.  When the maximum torque () is exceeded, the joint will slow down and can even reverse. You can use a motor to simulate friction. Just set the joint speed to zero, and set the maximum torque to some small, but significant value. The motor will try to prevent the constraint from rotating, but will yield to a significant load. Constructs a new instance of Urho.Urho2D.ConstraintRevolute2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.ConstraintRevolute2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.ConstraintRevolute2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return anchor. Or Set anchor. Return enable limit. Or Set enable limit. Return enable motor. Or Set enable motor. Return lower angle. Or Set lower angle. Return max motor torque. Or Set max motor torque. Return motor speed. Or Set motor speed. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return upper angle. Or Set upper angle. 2D rope constraint component. This constraint restricts the maximum distance  between two points  and . This can be useful to prevent chains of bodies from stretching, even under high load. Constructs a new instance of Urho.Urho2D.ConstraintRope2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.ConstraintRope2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.ConstraintRope2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return max length. Or Set max length. Return other body anchor. Or Set other body anchor. Return owner body anchor. Or Set owner body anchor. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. 2D weld constraint component. This constraint attempts to constrain all relative motion between two bodies. Constructs a new instance of Urho.Urho2D.ConstraintWeld2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.ConstraintWeld2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.ConstraintWeld2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return anchor. Or Set anchor. Return damping ratio. Or Set damping ratio. Return frequency Hz. Or Set frequency Hz. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. 2D wheel constraint component. This constraint restricts a point on bodyB  to a line on bodyA .  It also provides a suspension spring. Constructs a new instance of Urho.Urho2D.ConstraintWheel2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.ConstraintWheel2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.ConstraintWheel2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return anchor. Or Set anchor. Return axis. Or Set axis. Return damping ratio. Or Set damping ratio. Return enable motor. Or Set enable motor. Return frequency Hz. Or Set frequency Hz. Return maxMotor torque. Or Set max motor torque. Return motor speed. Or Set motor speed. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Curve type for the  Base class for 2D visible components. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.Drawable2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return layer. Or Set layer. Handle enabled/disabled state change. Return order in layer. Or Set order in layer. Register object factory. Drawable must be registered first. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. 2D particle emitter types. Loop Mode. Loop mode. Orientation. 2D particle effect resource. Holds the definition from a PEX file defining the behavior and texture of a 2D particle (ParticleEmitter2D). For an example, see bin/Data/Urho2D/greenspiral.pex. Constructs a new instance of Urho.Urho2D.ParticleEffect2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.ParticleEffect2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.ParticleEffect2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return angle. Or Set angle. Return angle variance. Or Set angle variance. Return blend mode. Or Set blend mode. Return duration. Or Set duration. Return emitter type. Or Set emitter type. Finish resource loading. Always called from the main thread. Return true if successful. Return finish color. Or Set finish color. Return finish color variance. Or Set finish color variance. Return finish particle size. Or Set finish particle size. Return finish particle size variance. Or Set finish particle size variance. Return gravity. Or Set gravity. Return max particles. Or Set max particles. Return max radius. Or Set max radius. Return max radius variance. Or Set max radius variance. Return min radius. Or Set min radius. Return min radius variance. Or Set min radius variance. Return particle lifespan. Or Set particle lifespan. Return particle lifespan variance. Or Set particle lifespan variance. Return radial acceleration. Or Set radial acceleration. Return radial acceleration variance. Or Set radial acceleration variance. Register object factory. Drawable2D must be registered first. Return rotate per second. Or Set rotate per second. Return rotate per second variance. Or Set rotate per second variance. Return rotation end. Or Set rotation end. Return rotation end variance. Or Set rotation end variance. Return rotation start. Or Set rotation start. Return rotation start variance. Or Set rotation start variance. Return source position variance. Or Set source position variance. Return speed. Or Set speed. Return speed variance. Or Set speed variance. Return sprite. Or Set sprite. Return start color. Or Set start color. Return start color variance. Or Set start color variance. Return start particle size. Or Set start particle size. Return start particle size variance. Or Set start particle size variance. Return tangential acceleration. Or Set tangential acceleration. Return tangential acceleration variance. Or Set tangential acceleration variance. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. 2D particle emitter component. Used to display a .  Equivalent to a 3D ParticleEmitter.  For a demonstration, check example 25_Urho2DParticle. Constructs a new instance of Urho.Urho2D.ParticleEmitter2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.ParticleEmitter2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.ParticleEmitter2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return blend mode. Or Set blend mode. Return particle effect. Or Set particle effect. Return whether is currently emitting. Or Set whether should be emitting. If the state was changed, also resets the emission period timer. Return max particles. Or Set max particles. Handle enabled/disabled state change. Return particle model attr. Register object factory. drawable2d must be registered first. Return sprite. Or Set sprite. Return sprite attribute. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Event arguments for the PhysicsWorld2D's PhysicsBeginContact2D event Event arguments for the PhysicsWorld2D's PhysicsEndContact2D event 2D physics simulation world component. Should be added only to the root scene node. Constructs a new instance of Urho.Urho2D.PhysicsWorld2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.PhysicsWorld2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.PhysicsWorld2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add rigid body. Return allow sleeping. Or Set allow sleeping. Controls whether node dirtying should be disregarded.. Return auto clear forces. Or Set auto clear forces. Return continuous physics. Or Set continuous physics. Return draw aabb. Or Set draw aabb. Return draw center of mass. Or Set draw center of mass. Add debug geometry to the debug renderer. Visualize the component as debug geometry. Return draw joint. Or Set draw joint. Return draw pair. Or Set draw pair. Return draw shape. Or Set draw shape. Return rigid body at point. Return rigid body at screen point. Return gravity. Or Set gravity. Event raised for RigidBody2D of type dynamic on contact. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Event raised for RigidBody2D of type dynamic on contact end. The event can register multiple callbacks and invoke all of them. If this is not desired, and you only need a single shot callback, you can use the method. That one will force that callback and will ignore any previously set events here. Return position iterations. Or Set position iterations. Register object factory. Remove rigid body. The handler to invoke when this event is raised. Subscribes to the PhysicsBeginContact2D event raised by the PhysicsWorld2D. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. The handler to invoke when this event is raised. Subscribes to the PhysicsEndContact2D event raised by the PhysicsWorld2D. Returns an Urho.Subscription that can be used to cancel the subscription. This method will override any prior subscription, including those assigned to on event handlers. This has the advantage that it does a straight connection and returns a handle that is easy to unsubscribe from. For a more event-like approach, use the event. Return sub stepping. Or Set sub stepping. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Step the simulation forward. Return whether physics world will automatically simulate during scene update. Or Enable or disable automatic physics simulation during scene update. Enabled by default. Return velocity iterations. Or Set velocity iterations. Return warm starting. Or Set warm starting. Property set. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.PropertySet2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return property value. Return has property. 2D renderer component. Constructs a new instance of Urho.Urho2D.Renderer2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.Renderer2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.Renderer2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add Drawable2D. Check visibility. Return material by texture and blend mode. Register object factory. Remove Drawable2D. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return whether a geometry update is necessary, and if it can happen in a worker thread. 2D rigid body component. There are three different kinds of rigid bodies, as defined in . Rigid bodies can be moved/rotated by applying forces and impulses. Linear force, either progressive or gradual can be applied by using  and .  Linear or angular impuse, either as brutal or immediate can be applied by using  and . Torque (angular force) can be controlled by using  You should establish the body type at creation, using the  property, because changing the body type later is expensive. You can also directly set the linear or angular velocity of the body using  or .  To manually move or rotate a body, simply translate or rotate the node to which it belongs to. You should set the  early on, because changing it at a later time is an expensive operation. Constructs a new instance of Urho.Urho2D.RigidBody2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.RigidBody2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.RigidBody2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add collision shape. Add constraint. Sets allow sleep flag. Return angular damping. Or Set angular damping. Return angular velocity. Or Set angular velocity. Apply angular impulse. Direction of the force. Where to apply the force. To improve performance, you can request the body to sleep by setting 'wake' parameter to false. Apply force. Direction of the force. To improve performance, you can request the body to sleep by setting 'wake' parameter to false. Apply force to center. This is the same as ApplyForce, the world point where to apply the force is set to center of mass, which prevents the body from rotating/spinning, Direction of the impulse. Where the impulse is applied. To improve performance, you can request the body to sleep by setting 'wake' parameter to false. Apply linear impulse. To improve performance, you can request the body to sleep by setting 'wake' parameter to false. Apply Torque. Apply world transform. New world position to apply. New world rotation to apply. Applies the specified world osition and rotation. Controls the Awake mode. Return body type. Or Set body type. Controls the bullet mode. Create body. Controls whether rotation is fixed. Return gravity scale. Or Set gravity scale. Return inertia. Or Set inertia. Return linear damping. Or Set linear damping. Return linear velocity. Return mass. Or Set mass. Return mass center. Handle enabled/disabled state change. Register object factory. Release body. Remove collision shape. Remove constraint. Set linear velocity. Set mass center. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return whether to calculate mass and inertia from collision shapes automatically. Or Set whether to automatically calculate mass and inertia from collision shapes. Default true. Sprite loaded from a file. An image defined with texture, texture rectangle and hot spot. Constructs a new instance of Urho.Urho2D.Sprite2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.Sprite2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.Sprite2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Finish resource loading. Always called from the main thread. Return true if successful. Return hot spot. Or Set hot spot. Return offset. Or Set offset. Return rectangle. Or Set rectangle. Register object factory. Save sprite to ResourceRef. Return sprite sheet. Or Set sprite sheet. Return texture. Or Set texture. Texture edge offset in pixels Defaults to zero. This affects the left/right and top/bottom edges equally to prevent edge sampling artifacts. Default 0 Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Sprite sheet - texture atlas image that packs multiple Sprite2D images. Texture atlas image (that packs multiple Sprite2D images). Spritesheets can be created using tools like ShoeBox (http://renderhjs.net/shoebox/), darkFunction Editor (http://darkfunction.com/editor/), SpriteHelper (http://www.gamedevhelper.com/spriteHelper2Info.php), TexturePacker (http://www.codeandweb.com/texturepacker), These tools will generate an image file and a xml file mapping coordinates and size for each individual image. Note that Urho2D uses same xml file format as Sparrow/Starling engines. Constructs a new instance of Urho.Urho2D.SpriteSheet2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.SpriteSheet2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.SpriteSheet2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Define sprite. Finish resource loading. Always called from the main thread. Return true if successful. Return sprite. Register object factory. Return texture. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Static sprite renderer component. Renders static sprites that have been loaded with the single image files () or  spritesheets/texture atlases that are loaded using  class.  Constructs a new instance of Urho.Urho2D.StaticSprite2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.StaticSprite2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.StaticSprite2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return alpha. Or Set alpha. Return blend mode. Or Set blend mode. Return color. Or Set color. Return custom material. Or Set custom material. Return custom material attribute. Return flip X. Or Set flip X. Return flip Y. Or Set flip Y. Return hot spot. Or Set hot spot. Register object factory. Drawable2D must be registered first. Set flip. Return sprite. Or Set sprite. Return sprite attribute. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return whether to use custom-defined draw rectangle. Or Set whether to use custom-defined draw rectangle. Return use hot spot. Or Set use hot spot. Return whether to use custom-defined texture rectangle. Or Set whether to use custom-defined texture rectangle. 2D texture resource. Constructs a new instance of Urho.Urho2D.Texture2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.Texture2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.Texture2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Load resource from stream. May be called from a worker thread. Return true if successful. Finish resource loading. Always called from the main thread. Return true if successful. Get data from a mip level. The destination buffer must be big enough. Return true if successful. Get image data from zero mip level. Only RGB and RGBA textures are supported. Get image data from zero mip level. Only RGB and RGBA textures are supported. Register object factory. Release the texture. Return render surface. Set data from an image. Return true if successful. Optionally make a single channel image alpha-only. Set data either partially or fully on a mip level. Return true if successful. Set size, format, usage and multisampling parameters for rendertargets. Zero size will follow application window size. Return true if successful. Autoresolve true means the multisampled texture will be automatically resolved to 1-sample after being rendered to and before being sampled as a texture.Autoresolve false means the multisampled texture will be read as individual samples in the shader and is not supported on Direct3D9. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Tile define. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.Tile2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return property. Return gid. Return has property. Return sprite. Tile map component. Constructs a new instance of Urho.Urho2D.TileMap2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.TileMap2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.TileMap2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add debug geometry to the debug renderer. Visualize the component as debug geometry. Return tile map layer at index. Return information. Return number of layers. Register object factory. Convert tile index to position. Return tmx file. Or Set tmx file. Return tile map file attribute. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Tile map component. Constructs a new instance of Urho.Urho2D.TileMapLayer2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.TileMapLayer2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.TileMapLayer2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Add debug geometry to the debug renderer. Return draw order. Or Set draw order Return tile map object (for object group only). Return object node (for object group only). Return property. Return tile (for tile layer only). Return tile node (for tile layer only). Return has property Return height (for tile layer only). Return image node (for image layer only). Initialize with tile map and tmx layer. Return layer type. Return number of tile map objects (for object group only). Register object factory. Return tile map. Return tmx layer. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Return visible. Or Set visible. Return width (for tile layer only). Tile map layer type. Tile map object. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.TileMapObject2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return point at index (use for script). Return property value. Return has property. Return name. Return number of points (use for script). Return type. Return position. Return size (for rectangle and ellipse). Return tile Gid. Return tile sprite. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Tile map object type. Tile map file. Constructs a new instance of Urho.Urho2D.TmxFile2D which is tied to the . Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.TmxFile2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. The context that this object will be attached to. Constructs a new instance of Urho.Urho2D.TmxFile2D linked to a specific . Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Finish resource loading. Always called from the main thread. Return true if successful. Return layer at index. Return tile property set by gid, if not exist return 0. Return tile sprite by gid, if not exist return 0. Return information. Return number of layers. Register object factory. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Urho's low-level type name. Stringified low-level type name. Urho's low-level type name, accessible as a static method. Stringified low-level type name. Urho's low-level type, accessible as a static method. This returns the Urho's type and is surface for the low-level Urho code. Tmx image layer. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.TmxImageLayer2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return position. Return source. Return sprite. Tmx layer. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.TmxLayer2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return property value (use for script). Return has property (use for script). Return height. Return name. Return tmx file. Urho's type system type. StringHash representing the type for this C# type. This returns the Urho's type and is surfaced for low-level Urho code. Return is visible. Return width. Tmx image layer. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.TmxObjectGroup2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return tile map object at index. Return number of objects. Tmx tile layer. Pointer to the raw unmanaged Urho object. Constructs a new instance of Urho.Urho2D.TmxTileLayer2D, given a raw pointer to an unmanaged object This creates a new managed wrapper for the type using the raw pointer to an unmanaged object. Objects that are created in this fashion get registered with the UrhoSharp runtime. This is intended to be used by the UrhoSharp runtime, and is not intended to be used by users. Pass UrhoObjectFlag.Empty. Empty constructor, chain to this constructor when you provide your own constructor that sets the handle field. This constructor should be invoked by your code if you provide your own constructor that sets the handle field. This essentially circumvents the default path that creates a new object and sets the handle and does not call RegisterObject on the target, you must do this on your own constructor. You would typically chain to this constructor from your own, and then set the handle to the unmanaged object from your code, and then register your object. Return tile.