/home/root/libopenmetaverse/bin/OpenMetaverseTypes

Same as Queue except Dequeue function blocks until there is an object to return. Note: This class does not need to be synchronized

Create new BlockingQueue.

The System.Collections.ICollection to copy elements from

Create new BlockingQueue.

The initial number of elements that the queue can contain

Create new BlockingQueue.

Gets flag indicating if queue has been closed.

BlockingQueue Destructor (Close queue, resume any waiting thread).

Remove all objects from the Queue.

Remove all objects from the Queue, resume all dequeue threads.

Removes and returns the object at the beginning of the Queue.

Object in queue.

Removes and returns the object at the beginning of the Queue.

time to wait before returning Object in queue.

Removes and returns the object at the beginning of the Queue.

time to wait before returning (in milliseconds) Object in queue.

Adds an object to the end of the Queue

Object to put in queue

Open Queue.

Copy constructor

Circular queue to copy

An 8-bit color structure including an alpha channel

Builds a color from a byte array

Returns the raw bytes for this vector

Byte array containing a 16 byte color Beginning position in the byte array True if the byte array stores inverted values, otherwise false. For example the color black (fully opaque) inverted would be 0xFF 0xFF 0xFF 0x00 True if the alpha value is inverted in addition to whatever the inverted parameter is. Setting inverted true and alphaInverted true will flip the alpha value back to non-inverted, but keep the other color bytes inverted A 16 byte array containing R, G, B, and A

Copy constructor

Color to copy

Red

Green

Blue

Alpha

A Color4 with zero RGB values and fully opaque (alpha 1.0)

A Color4 with full RGB values (1.0) and fully opaque (alpha 1.0)

IComparable.CompareTo implementation

Sorting ends up like this: |--Grayscale--||--Color--|. Alpha is only used when the colors are otherwise equivalent

Builds a color from a byte array

Writes the raw bytes for this color to a byte array

Destination byte array Position in the destination array to start writing. Must be at least 16 bytes before the end of the array

Serializes this color into four bytes in a byte array

Destination byte array Position in the destination array to start writing. Must be at least 4 bytes before the end of the array True to invert the output (1.0 becomes 0 instead of 255)

Writes the raw bytes for this color to a byte array

Destination byte array Position in the destination array to start writing. Must be at least 16 bytes before the end of the array

Ensures that values are in range 0-1

Create an RGB color from a hue, saturation, value combination

Hue Saturation Value An fully opaque RGB color (alpha is 1.0)

Performs linear interpolation between two colors

Color to start at Color to end at Amount to interpolate The interpolated color

Attribute class that allows extra attributes to be attached to ENUMs

Default initializer

Text used when presenting ENUM to user

The different types of grid assets

Unknown asset type

Texture asset, stores in JPEG2000 J2C stream format

Sound asset

Calling card for another avatar

Link to a location in world

Collection of textures and parameters that can be worn by an avatar

Primitive that can contain textures, sounds, scripts and more

Notecard asset

Holds a collection of inventory items

Root inventory folder

Linden scripting language script

LSO bytecode for a script

Uncompressed TGA texture

Collection of textures and shape parameters that can be worn

Trash folder

Snapshot folder

Lost and found folder

Uncompressed sound

Uncompressed TGA non-square image, not to be used as a texture

Compressed JPEG non-square image, not to be used as a texture

Animation

Sequence of animations, sounds, chat, and pauses

Simstate file

Contains landmarks for favorites

Asset is a link to another inventory item

Asset is a link to another inventory folder

Beginning of the range reserved for ensembles

End of the range reserved for ensembles

Folder containing inventory links to wearables and attachments that are part of the current outfit

Folder containing inventory items or links to inventory items of wearables and attachments together make a full outfit

Root folder for the folders of type OutfitFolder

Linden mesh format

Inventory Item Types, eg Script, Notecard, Folder, etc

Unknown

Texture

Sound

Calling Card

Landmark

Notecard

Folder

an LSL Script

Item Sale Status

Not for sale

The original is for sale

Copies are for sale

The contents of the object are for sale

Types of wearable assets

Body shape

Skin textures and attributes

Hair

Eyes

Shirt

Pants

Shoes

Socks

Jacket

Gloves

Undershirt

Underpants

Skirt

Alpha mask to hide parts of the avatar

Tattoo

Invalid wearable asset

Identifier code for primitive types

None

A Primitive

A Avatar

Linden grass

Linden tree

A primitive that acts as the source for a particle stream

A Linden tree

Primary parameters for primitives such as Physics Enabled or Phantom

Deprecated

Whether physics are enabled for this object

Whether this object contains an active touch script

Whether this object can receive payments

Whether this object is phantom (no collisions)

Deprecated

Server flag, will not be sent to clients. Specifies that the object is destroyed when it touches a simulator edge

Server flag, will not be sent to clients. Specifies that the object will be returned to the owner's inventory when it touches a simulator edge

Server flag, will not be sent to clients.

Server flag, will not be sent to client. Specifies that the object is hovering/flying

Sound flags for sounds attached to primitives

Material type for a primitive

Used in a helper function to roughly determine prim shape

Extra parameters for primitives, these flags are for features that have been added after the original ObjectFlags that has all eight bits reserved already

Whether this object has flexible parameters

Whether this object has light parameters

Whether this object is a sculpted prim

Attachment points for objects on avatar bodies

Both InventoryObject and InventoryAttachment types can be attached

Right hand if object was not previously attached

Chest

Skull

Left shoulder

Right shoulder

Left hand

Right hand

Left foot

Right foot

Spine

Pelvis

Mouth

Chin

Left ear

Right ear

Left eyeball

Right eyeball

Nose

Right upper arm

Right forearm

Left upper arm

Left forearm

Right hip

Right upper leg

Right lower leg

Left hip

Left upper leg

Left lower leg

Stomach

Left pectoral

Right pectoral

HUD Center position 2

HUD Top-right

HUD Top

HUD Top-left

HUD Center

HUD Bottom-left

HUD Bottom

HUD Bottom-right

Tree foliage types

Pine1 tree

Oak tree

Tropical Bush1

Palm1 tree

Dogwood tree

Tropical Bush2

Palm2 tree

Cypress1 tree

Cypress2 tree

Pine2 tree

Plumeria

Winter pinetree1

Winter Aspen tree

Winter pinetree2

Eucalyptus tree

Fern

Eelgrass

Sea Sword

Kelp1 plant

Beach grass

Kelp2 plant

Grass foliage types

Action associated with clicking on an object

Touch object

Sit on object

Purchase object or contents

Pay the object

Open task inventory

Play parcel media

Open parcel media

For thread safety

Purges expired objects from the cache. Called automatically by the purge timer.

A thread-safe lockless queue that supports multiple readers and multiple writers

Constructor

Provides a node container for data in a singly linked list

Constructor

Pointer to the next node in list

The data contained by the node

Queue head

Queue tail

Queue item count

Gets the current number of items in the queue. Since this is a lockless collection this value should be treated as a close estimate

Enqueue an item

Item to enqeue

Try to dequeue an item

Dequeued item if the dequeue was successful True if an item was successfully deqeued, otherwise false

A 4x4 matrix containing all zeroes

A 4x4 identity matrix

Convert this matrix to euler rotations

X euler angle Y euler angle Z euler angle

Convert this matrix to a quaternion rotation

A quaternion representation of this rotation matrix

Construct a matrix from euler rotation values in radians

X euler angle in radians Y euler angle in radians Z euler angle in radians

Get a formatted string representation of the vector

A string representation of the vector

Provides helper methods for parallelizing loops

Executes a for loop in which iterations may run in parallel

The loop will be started at this index The loop will be terminated before this index is reached Method body to run for each iteration of the loop

Executes a for loop in which iterations may run in parallel

The number of concurrent execution threads to run The loop will be started at this index The loop will be terminated before this index is reached Method body to run for each iteration of the loop

Executes a foreach loop in which iterations may run in parallel

Object type that the collection wraps An enumerable collection to iterate over Method body to run for each object in the collection

Executes a foreach loop in which iterations may run in parallel

Object type that the collection wraps The number of concurrent execution threads to run An enumerable collection to iterate over Method body to run for each object in the collection

Executes a series of tasks in parallel

A series of method bodies to execute

Executes a series of tasks in parallel

The number of concurrent execution threads to run A series of method bodies to execute

Build a quaternion from normalized float values

X value from -1.0 to 1.0 Y value from -1.0 to 1.0 Z value from -1.0 to 1.0

Constructor, builds a quaternion object from a byte array

Byte array containing four four-byte floats Offset in the byte array to start reading at Whether the source data is normalized or not. If this is true 12 bytes will be read, otherwise 16 bytes will be read.

X value

Y value

Z value

W value

A quaternion with a value of 0,0,0,1

Normalizes the quaternion

Builds a quaternion object from a byte array

The source byte array Offset in the byte array to start reading at Whether the source data is normalized or not. If this is true 12 bytes will be read, otherwise 16 bytes will be read.

Normalize this quaternion and serialize it to a byte array

A 12 byte array containing normalized X, Y, and Z floating point values in order using little endian byte ordering

Writes the raw bytes for this quaternion to a byte array

Destination byte array Position in the destination array to start writing. Must be at least 12 bytes before the end of the array

Convert this quaternion to euler angles

X euler angle Y euler angle Z euler angle

Convert this quaternion to an angle around an axis

Unit vector describing the axis Angle around the axis, in radians

Returns the conjugate (spatial inverse) of a quaternion

Build a quaternion from an axis and an angle of rotation around that axis

Axis of rotation Angle of rotation

Creates a quaternion from a vector containing roll, pitch, and yaw in radians

Vector representation of the euler angles in radians Quaternion representation of the euler angles

Creates a quaternion from roll, pitch, and yaw euler angles in radians

X angle in radians Y angle in radians Z angle in radians Quaternion representation of the euler angles

Conjugates and renormalizes a vector

Spherical linear interpolation between two quaternions

Get a string representation of the quaternion elements with up to three decimal digits and separated by spaces only

Raw string representation of the quaternion

Determines the appropriate events to set, leaves the locks, and sets the events.

A routine for lazily creating a event outside the lock (so if errors happen they are outside the lock and that we don't do much work while holding a spin lock). If all goes well, reenter the lock and set 'waitEvent'

Waits on 'waitEvent' with a timeout of 'millisceondsTimeout. Before the wait 'numWaiters' is incremented and is restored before leaving this routine.

A hierarchical token bucket for bandwidth throttling. See http://en.wikipedia.org/wiki/Token_bucket for more information

Default constructor

Parent bucket if this is a child bucket, or null if this is a root bucket Maximum size of the bucket in bytes, or zero if this bucket has no maximum capacity Rate that the bucket fills, in bytes per second. If zero, the bucket always remains full

Parent bucket to this bucket, or null if this is a root bucket

Size of the bucket in bytes. If zero, the bucket has infinite capacity

Rate that the bucket fills, in bytes per millisecond. If zero, the bucket always remains full

Number of tokens currently in the bucket

Time of the last drip, in system ticks

The parent bucket of this bucket, or null if this bucket has no parent. The parent bucket will limit the aggregate bandwidth of all of its children buckets

Maximum burst rate in bytes per second. This is the maximum number of tokens that can accumulate in the bucket at any one time

The speed limit of this bucket in bytes per second. This is the number of tokens that are added to the bucket per second

Tokens are added to the bucket any time is called, at the granularity of the system tick interval (typically around 15-22ms)

The number of bytes that can be sent at this moment. This is the current number of tokens in the bucket If this bucket has a parent bucket that does not have enough tokens for a request, will return false regardless of the content of this bucket

Remove a given number of tokens from the bucket

Number of tokens to remove from the bucket True if the requested number of tokens were removed from the bucket, otherwise false

Remove a given number of tokens from the bucket

Number of tokens to remove from the bucket True if tokens were added to the bucket during this call, otherwise false True if the requested number of tokens were removed from the bucket, otherwise false

Add tokens to the bucket over time. The number of tokens added each call depends on the length of time that has passed since the last call to Drip

True if tokens were added to the bucket, otherwise false

A 128-bit Universally Unique Identifier, used throughout the Second Life networking protocol

Constructor that takes a string UUID representation

A string representation of a UUID, case insensitive and can either be hyphenated or non-hyphenated UUID("11f8aa9c-b071-4242-836b-13b7abe0d489")

Constructor that takes a System.Guid object

A Guid object that contains the unique identifier to be represented by this UUID

Constructor that takes a byte array containing a UUID

Byte array containing a 16 byte UUID Beginning offset in the array

Constructor that takes an unsigned 64-bit unsigned integer to convert to a UUID

64-bit unsigned integer to convert to a UUID

Copy constructor

UUID to copy

The System.Guid object this struct wraps around

An UUID with a value of all zeroes

A cache of UUID.Zero as a string to optimize a common path

IComparable.CompareTo implementation

Assigns this UUID from 16 bytes out of a byte array

Byte array containing the UUID to assign this UUID to Starting position of the UUID in the byte array

Returns a copy of the raw bytes for this UUID

A 16 byte array containing this UUID

Writes the raw bytes for this UUID to a byte array

Destination byte array Position in the destination array to start writing. Must be at least 16 bytes before the end of the array

Calculate an LLCRC (cyclic redundancy check) for this UUID

The CRC checksum for this UUID

Create a 64-bit integer representation from the second half of this UUID

An integer created from the last eight bytes of this UUID

Generate a UUID from a string

A string representation of a UUID, case insensitive and can either be hyphenated or non-hyphenated UUID.Parse("11f8aa9c-b071-4242-836b-13b7abe0d489")

Generate a UUID from a string

A string representation of a UUID, case insensitive and can either be hyphenated or non-hyphenated Will contain the parsed UUID if successful, otherwise null True if the string was successfully parse, otherwise false UUID.TryParse("11f8aa9c-b071-4242-836b-13b7abe0d489", result)

Combine two UUIDs together by taking the MD5 hash of a byte array containing both UUIDs

First UUID to combine Second UUID to combine The UUID product of the combination

Return a hash code for this UUID, used by .NET for hash tables

An integer composed of all the UUID bytes XORed together

Comparison function

An object to compare to this UUID True if the object is a UUID and both UUIDs are equal

Comparison function

UUID to compare to True if the UUIDs are equal, otherwise false

Get a hyphenated string representation of this UUID

A string representation of this UUID, lowercase and with hyphens 11f8aa9c-b071-4242-836b-13b7abe0d489

Equals operator

First UUID for comparison Second UUID for comparison True if the UUIDs are byte for byte equal, otherwise false

Not equals operator

First UUID for comparison Second UUID for comparison True if the UUIDs are not equal, otherwise true

XOR operator

First UUID Second UUID A UUID that is a XOR combination of the two input UUIDs

String typecasting operator

A UUID in string form. Case insensitive, hyphenated or non-hyphenated A UUID built from the string representation

Operating system

Unknown

Microsoft Windows

Microsoft Windows CE

Linux

Apple OSX

Runtime platform

.NET runtime

Mono runtime: http://www.mono-project.com/

Used for converting degrees to radians

Used for converting radians to degrees

Provide a single instance of the CultureInfo class to help parsing in situations where the grid assumes an en-us culture

UNIX epoch in DateTime format

Provide a single instance of the MD5 class to avoid making duplicate copies and handle thread safety

Provide a single instance of the SHA-1 class to avoid making duplicate copies and handle thread safety

Provide a single instance of a random number generator to avoid making duplicate copies and handle thread safety

Clamp a given value between a range

Value to clamp Minimum allowable value Maximum allowable value A value inclusively between lower and upper

Clamp a given value between a range

Value to clamp Minimum allowable value Maximum allowable value A value inclusively between lower and upper

Clamp a given value between a range

Value to clamp Minimum allowable value Maximum allowable value A value inclusively between lower and upper

Round a floating-point value to the nearest integer

Floating point number to round Integer

Test if a single precision float is a finite number

Test if a double precision float is a finite number

Get the distance between two floating-point values

First value Second value The distance between the two values

Compute the MD5 hash for a byte array

Byte array to compute the hash for MD5 hash of the input data

Compute the SHA1 hash for a byte array

Byte array to compute the hash for SHA1 hash of the input data

Calculate the SHA1 hash of a given string

The string to hash The SHA1 hash as a string

Compute the SHA256 hash for a byte array

Byte array to compute the hash for SHA256 hash of the input data

Calculate the SHA256 hash of a given string

The string to hash The SHA256 hash as a string

Calculate the MD5 hash of a given string

The password to hash An MD5 hash in string format, with $1$ prepended

Calculate the MD5 hash of a given string

The string to hash The MD5 hash as a string

Generate a random double precision floating point value

Random value of type double

Get the current running platform

Enumeration of the current platform we are running on

Get the current running runtime

Enumeration of the current runtime we are running on

Convert the first two bytes starting in the byte array in little endian ordering to a signed short integer

An array two bytes or longer A signed short integer, will be zero if a short can't be read at the given position

Convert the first two bytes starting at the given position in little endian ordering to a signed short integer

An array two bytes or longer Position in the array to start reading A signed short integer, will be zero if a short can't be read at the given position

Convert the first four bytes starting at the given position in little endian ordering to a signed integer

An array four bytes or longer Position to start reading the int from A signed integer, will be zero if an int can't be read at the given position

Convert the first four bytes of the given array in little endian ordering to a signed integer

An array four bytes or longer A signed integer, will be zero if the array contains less than four bytes

Convert the first eight bytes of the given array in little endian ordering to a signed long integer

An array eight bytes or longer A signed long integer, will be zero if the array contains less than eight bytes

Convert the first eight bytes starting at the given position in little endian ordering to a signed long integer

An array eight bytes or longer Position to start reading the long from A signed long integer, will be zero if a long can't be read at the given position

Convert the first two bytes starting at the given position in little endian ordering to an unsigned short

Byte array containing the ushort Position to start reading the ushort from An unsigned short, will be zero if a ushort can't be read at the given position

Convert two bytes in little endian ordering to an unsigned short

Byte array containing the ushort An unsigned short, will be zero if a ushort can't be read

Convert the first four bytes starting at the given position in little endian ordering to an unsigned integer

Byte array containing the uint Position to start reading the uint from An unsigned integer, will be zero if a uint can't be read at the given position

Convert the first four bytes of the given array in little endian ordering to an unsigned integer

An array four bytes or longer An unsigned integer, will be zero if the array contains less than four bytes

Convert the first eight bytes of the given array in little endian ordering to an unsigned 64-bit integer

An array eight bytes or longer An unsigned 64-bit integer, will be zero if the array contains less than eight bytes

Convert four bytes in little endian ordering to a floating point value

Byte array containing a little ending floating point value Starting position of the floating point value in the byte array Single precision value

Convert an integer to a byte array in little endian format

The integer to convert A four byte little endian array

Convert an integer to a byte array in big endian format

The integer to convert A four byte big endian array

Convert a 64-bit integer to a byte array in little endian format

The value to convert An 8 byte little endian array

Convert a 64-bit unsigned integer to a byte array in little endian format

The value to convert An 8 byte little endian array

Convert a floating point value to four bytes in little endian ordering

A floating point value A four byte array containing the value in little endian ordering

Converts an unsigned integer to a hexadecimal string

An unsigned integer to convert to a string A hexadecimal string 10 characters long 0x7fffffff

Convert a variable length UTF8 byte array to a string

The UTF8 encoded byte array to convert The decoded string

Converts a byte array to a string containing hexadecimal characters

The byte array to convert to a string The name of the field to prepend to each line of the string A string containing hexadecimal characters on multiple lines. Each line is prepended with the field name

Converts a byte array to a string containing hexadecimal characters

The byte array to convert to a string Number of bytes in the array to parse A string to prepend to each line of the hex dump A string containing hexadecimal characters on multiple lines. Each line is prepended with the field name

Convert a string to a UTF8 encoded byte array

The string to convert A null-terminated UTF8 byte array

Converts a string containing hexadecimal characters to a byte array

String containing hexadecimal characters If true, gracefully handles null, empty and uneven strings as well as stripping unconvertable characters The converted byte array

Returns true is c is a hexadecimal digit (A-F, a-f, 0-9)

Character to test true if hex digit, false if not

Converts 1 or 2 character string into equivalant byte value

1 or 2 character string byte

Convert a float value to a byte given a minimum and maximum range

Value to convert to a byte Minimum value range Maximum value range A single byte representing the original float value

Convert a byte to a float value given a minimum and maximum range

Byte array to get the byte from Position in the byte array the desired byte is at Minimum value range Maximum value range A float value inclusively between lower and upper

Convert a byte to a float value given a minimum and maximum range

Byte to convert to a float value Minimum value range Maximum value range A float value inclusively between lower and upper

Attempts to parse a floating point value from a string, using an EN-US number format

String to parse Resulting floating point number True if the parse was successful, otherwise false

Attempts to parse a floating point value from a string, using an EN-US number format

String to parse Resulting floating point number True if the parse was successful, otherwise false

Tries to parse an unsigned 32-bit integer from a hexadecimal string

String to parse Resulting integer True if the parse was successful, otherwise false

Returns text specified in EnumInfo attribute of the enumerator To add the text use [EnumInfo(Text = "Some nice text here")] before declaration of enum values

Enum value Text representation of the enum

Takes an AssetType and returns the string representation

The source The string version of the AssetType

Translate a string name of an AssetType into the proper Type

A string containing the AssetType name The AssetType which matches the string name, or AssetType.Unknown if no match was found

Convert an InventoryType to a string

The to convert A string representation of the source

Convert a string into a valid InventoryType

A string representation of the InventoryType to convert A InventoryType object which matched the type

Convert a SaleType to a string

The to convert A string representation of the source

Convert a string into a valid SaleType

A string representation of the SaleType to convert A SaleType object which matched the type

Converts a string used in LLSD to AttachmentPoint type

String representation of AttachmentPoint to convert AttachmentPoint enum

Copy a byte array

Byte array to copy A copy of the given byte array

Packs to 32-bit unsigned integers in to a 64-bit unsigned integer

The left-hand (or X) value The right-hand (or Y) value A 64-bit integer containing the two 32-bit input values

Unpacks two 32-bit unsigned integers from a 64-bit unsigned integer

The 64-bit input integer The left-hand (or X) output value The right-hand (or Y) output value

Convert an IP address object to an unsigned 32-bit integer

IP address to convert 32-bit unsigned integer holding the IP address bits

Gets a unix timestamp for the current time

An unsigned integer representing a unix timestamp for now

Convert a UNIX timestamp to a native DateTime object

An unsigned integer representing a UNIX timestamp A DateTime object containing the same time specified in the given timestamp

Convert a UNIX timestamp to a native DateTime object

A signed integer representing a UNIX timestamp A DateTime object containing the same time specified in the given timestamp

Convert a native DateTime object to a UNIX timestamp

A DateTime object you want to convert to a timestamp An unsigned integer representing a UNIX timestamp

Swap two values

Type of the values to swap First value Second value

Try to parse an enumeration value from a string

Enumeration type String value to parse Enumeration value on success True if the parsing succeeded, otherwise false

Swaps the high and low words in a byte. Converts aaaabbbb to bbbbaaaa

Byte to swap the words in Byte value with the words swapped

Attempts to convert a string representation of a hostname or IP address to a

Hostname to convert to an IPAddress Converted IP address object, or null if the conversion failed

A two-dimensional vector with floating-point values

X value

Y value

A vector with a value of 0,0

A vector with a value of 1,1

A vector with a value of 1,0

A vector with a value of 0,1

Test if this vector is equal to another vector, within a given tolerance range

Vector to test against The acceptable magnitude of difference between the two vectors True if the magnitude of difference between the two vectors is less than the given tolerance, otherwise false

Test if this vector is composed of all finite numbers

IComparable.CompareTo implementation

Builds a vector from a byte array

Byte array containing two four-byte floats Beginning position in the byte array

Returns the raw bytes for this vector

An eight-byte array containing X and Y

Writes the raw bytes for this vector to a byte array

Destination byte array Position in the destination array to start writing. Must be at least 8 bytes before the end of the array

Parse a vector from a string

A string representation of a 2D vector, enclosed in arrow brackets and separated by commas

Interpolates between two vectors using a cubic equation

Get a formatted string representation of the vector

A string representation of the vector

Get a string representation of the vector elements with up to three decimal digits and separated by spaces only

Raw string representation of the vector

A three-dimensional vector with floating-point values

Constructor, builds a vector from a byte array

Byte array containing three four-byte floats Beginning position in the byte array

X value

Y value

Z value

A vector with a value of 0,0,0

A vector with a value of 1,1,1

A unit vector facing forward (X axis), value 1,0,0

A unit vector facing left (Y axis), value 0,1,0

A unit vector facing up (Z axis), value 0,0,1

Test if this vector is equal to another vector, within a given tolerance range

Vector to test against The acceptable magnitude of difference between the two vectors True if the magnitude of difference between the two vectors is less than the given tolerance, otherwise false

IComparable.CompareTo implementation

Test if this vector is composed of all finite numbers

Builds a vector from a byte array

Byte array containing a 12 byte vector Beginning position in the byte array

Returns the raw bytes for this vector

A 12 byte array containing X, Y, and Z

Writes the raw bytes for this vector to a byte array

Destination byte array Position in the destination array to start writing. Must be at least 12 bytes before the end of the array

Parse a vector from a string

A string representation of a 3D vector, enclosed in arrow brackets and separated by commas

Calculate the rotation between two vectors

Normalized directional vector (such as 1,0,0 for forward facing) Normalized target vector

Interpolates between two vectors using a cubic equation

Get a formatted string representation of the vector

A string representation of the vector

Get a string representation of the vector elements with up to three decimal digits and separated by spaces only

Raw string representation of the vector

Cross product between two vectors

A three-dimensional vector with doubleing-point values

Constructor, builds a vector from a byte array

Byte array containing three eight-byte doubles Beginning position in the byte array

X value

Y value

Z value

A vector with a value of 0,0,0

A vector with a value of 1,1,1

A unit vector facing forward (X axis), value of 1,0,0

A unit vector facing left (Y axis), value of 0,1,0

A unit vector facing up (Z axis), value of 0,0,1

Test if this vector is equal to another vector, within a given tolerance range

Vector to test against The acceptable magnitude of difference between the two vectors True if the magnitude of difference between the two vectors is less than the given tolerance, otherwise false

IComparable.CompareTo implementation

Test if this vector is composed of all finite numbers

Builds a vector from a byte array

Byte array containing a 24 byte vector Beginning position in the byte array

Returns the raw bytes for this vector

A 24 byte array containing X, Y, and Z

Writes the raw bytes for this vector to a byte array

Destination byte array Position in the destination array to start writing. Must be at least 24 bytes before the end of the array

Parse a vector from a string

A string representation of a 3D vector, enclosed in arrow brackets and separated by commas

Interpolates between two vectors using a cubic equation

Get a formatted string representation of the vector

A string representation of the vector

Get a string representation of the vector elements with up to three decimal digits and separated by spaces only

Raw string representation of the vector

Cross product between two vectors

Constructor, builds a vector from a byte array

Byte array containing four four-byte floats Beginning position in the byte array

X value

Y value

Z value

W value

A vector with a value of 0,0,0,0

A vector with a value of 1,1,1,1

A vector with a value of 1,0,0,0

A vector with a value of 0,1,0,0

A vector with a value of 0,0,1,0

A vector with a value of 0,0,0,1

Test if this vector is equal to another vector, within a given tolerance range

Vector to test against The acceptable magnitude of difference between the two vectors True if the magnitude of difference between the two vectors is less than the given tolerance, otherwise false

IComparable.CompareTo implementation

Test if this vector is composed of all finite numbers

Builds a vector from a byte array

Byte array containing a 16 byte vector Beginning position in the byte array

Returns the raw bytes for this vector

A 16 byte array containing X, Y, Z, and W

Writes the raw bytes for this vector to a byte array

Destination byte array Position in the destination array to start writing. Must be at least 16 bytes before the end of the array

Get a string representation of the vector elements with up to three decimal digits and separated by spaces only

Raw string representation of the vector