Vector3D

isFinite

get isFinite(): boolean

var isFinite: Bool { get }

isNaN

get isNaN(): boolean

var isNaN: Bool { get }

isZero

get isZero(): boolean

var isZero: Bool { get }

zero

static get zero(): Vector3D

static let zero: Vector3D

infinity

static get infinity(): Vector3D

static let infinity: Vector3D

vector

get vector(): SDKHandle

var vector: simd_double3 { get set }

vector

set vector(value: SDKHandle)

var vector: simd_double3 { get set }

x

get x(): number

var x: Double { get set }

x

set x(value: number)

var x: Double { get set }

y

get y(): number

var y: Double { get set }

y

set y(value: number)

var y: Double { get set }

z

get z(): number

var z: Double { get set }

z

set z(value: number)

var z: Double { get set }

init

static initVector(vector: SDKHandle): Vector3D

init(vector: simd_double3)

normalized

get normalized(): Vector3D

var normalized: Vector3D { get }

Returns this vector with a length of `1`.

smoothstep

static smoothstep(edge0: Vector3D, edge1: Vector3D, x: Vector3D): Vector3D

static func smoothstep(edge0: Vector3D, edge1: Vector3D, x: Vector3D) -> Vector3D

Returns a Spatial vector that represents the smooth interpolation at `x` between two vectors. - Parameter edge0: The lower edge of the interpolation function. - Parameter edge1: The upper edge of the interpolation function. - Parameter x: The value that the function interpolates at. - Returns: A new vector with each element set to `0` if `x <= edge0`, `1` if `x >= edge1`, and a Hermite interpolation between `0` and `1` if `edge0 < x < edge1`.

unapplying

unapplying(scaledPose: ScaledPose3D): Vector3D

func unapplying(_ scaledPose: ScaledPose3D) -> Vector3D

Returns the primitive that results from unapplying a scaled pose to the primitive. - Parameter pose: The scaled pose. - Returns The transformed primitive.

unapplying

unapplying1261(transform: AffineTransform3D): Vector3D

func unapplying(_ transform: AffineTransform3D) -> Vector3D

Returns the vector that results from unapplying an affine transform to the vector. - Parameter transform: The affine transform. - Returns The transformed primitive.

unapplying

unapplying96568(transform: ProjectiveTransform3D): Vector3D

func unapplying(_ transform: ProjectiveTransform3D) -> Vector3D

Returns the vector that results from unapplying a projective transform to the vector. - Parameter transform: The projective transform. - Returns The transformed primitive.

unapplying

unapplying1497(pose: Pose3D): Vector3D

func unapplying(_ pose: Pose3D) -> Vector3D

Returns the primitive that results from applying a pose to the primitive. - Parameter pose: The pose. - Returns The transformed primitive.

description

get description(): string

var description: String { get }

A textual representation of this instance. Calling this property directly is discouraged. Instead, convert an instance of any type to a string by using the `String(describing:)` initializer. This initializer works with any type, and uses the custom `description` property for types that conform to `CustomStringConvertible`: struct Point: CustomStringConvertible { let x: Int, y: Int var description: String { return "(\(x), \(y))" } } let p = Point(x: 21, y: 30) let s = String(describing: p) print(s) // Prints "(21, 30)" The conversion of `p` to a string in the assignment to `s` uses the `Point` type's `description` property.

customMirror

get customMirror(): SDKHandle

var customMirror: Mirror { get }

The custom mirror for this instance.

lengthSquared

get lengthSquared(): number

var lengthSquared: Double { get }

uniformlyScaled

uniformlyScaled(scale: number): Vector3D

func uniformlyScaled(by scale: Double) -> Vector3D

Returns the entity uniformly scaled by the specified scalar value. - Parameter scale: The value that defines that scale. - Returns The scaled vector.

init

static initXYZ(x?: number, y?: number, z?: number): Vector3D

init(x: Double = 0, y: Double = 0, z: Double = 0)

Returns a vector from the specified values. - Parameter x: The first element of the vector. - Parameter y: The second element of the vector. - Parameter z: The third element of the vector.

init

static initXYZ86701(x: number, y: number, z: number): Vector3D

init<T>(x: T, y: T, z: T) where T : BinaryFloatingPoint

Returns a new vector from the floating-point values. - note: This function is provided as a convenience. All Spatial storage and calculations are double-precision.

up

static get up(): Vector3D

static let up: Vector3D

A vector with values `[0, 1, 0]`.

dot

dot(other: Vector3D): number

func dot(_ other: Vector3D) -> Double

Returns the dot product of this vector and the specified vector.

lerp

static lerp(from: Vector3D, to: Vector3D, t: Vector3D): Vector3D

static func lerp(from: Vector3D, to: Vector3D, t: Vector3D) -> Vector3D

Returns a Spatial vector that represents the linear interpolation at `t` between two vectors. - Parameter from: The starting vector. - Parameter to: The ending vector. - Parameter t: The value, between `0` and `1`, that the function interpolates at. - Returns: A new rotation. When `t=0`, the result is the `from` vector. When `t=1.0`, the result is the `to` vector. For any other value of `t`, the result is a linear linear interpolation between the two vectors.

cross

cross(other: Vector3D): Vector3D

func cross(_ other: Vector3D) -> Vector3D

Returns the cross product of this vector and the specified vector.

right

static get right(): Vector3D

static let right: Vector3D

A vector with values `[1, 0, 0]`.

length

get length(): number

var length: Double { get }

scaled

scaled(size: Size3D): Vector3D

func scaled(by size: Size3D) -> Vector3D

Returns the vector scaled by the specified size. - Parameter size: The size structure that defines that scale. - Returns The scaled vector.

forward

static get forward(): Vector3D

static let forward: Vector3D

A vector with values `[0, 0, 1]`.

rotated

rotatedBy(quaternion: SDKHandle): Vector3D

func rotated(by quaternion: simd_quatd) -> Vector3D

Returns the vector rotated by the specified quaternion around the origin. - Parameter quaternion: The quaternion that defines the rotation. - Returns The rotated vector.

rotated

rotatedBy32266(rotation: Rotation3D): Vector3D

func rotated(by rotation: Rotation3D) -> Vector3D

Returns the vector rotated by the specified rotation around the origin. - Parameter rotation: The rotation. - Returns The rotated vector.

sheared

sheared(shear: AxisWithFactors): Vector3D

func sheared(_ shear: AxisWithFactors) -> Vector3D

Returns a sheared vector. - Parameter shear: The axis and shear factors. - Returns The sheared vector.

applying

applying(scaledPose: ScaledPose3D): Vector3D

func applying(_ scaledPose: ScaledPose3D) -> Vector3D

Returns the primitive that results from applying a scaled pose to the primitive. - Parameter pose: The scaled pose. - Returns The transformed primitive.

applying

applying33501(transform: AffineTransform3D): Vector3D

func applying(_ transform: AffineTransform3D) -> Vector3D

Returns the vector that results from applying an affine transform to the vector. - Parameter transform: The affine transform. - Returns The transformed primitive.

applying

applying26088(transform: ProjectiveTransform3D): Vector3D

func applying(_ transform: ProjectiveTransform3D) -> Vector3D

Returns the vector that results from applying a projective transform to the vector. - Parameter transform: The projective transform. - Returns The transformed primitive.

applying

applying9385(pose: Pose3D): Vector3D

func applying(_ pose: Pose3D) -> Vector3D

Returns the primitive that results from applying a pose to the primitive. - Parameter pose: The pose. - Returns The transformed primitive.

rotation

rotation(other: Vector3D): Rotation3D

func rotation(to other: Vector3D) -> Rotation3D

Returns the rotation from the normalized first vector to the normalized second vector.

scaledBy

scaledBy(x?: number, y?: number, z?: number): Vector3D

func scaledBy(x: Double = 1, y: Double = 1, z: Double = 1) -> Vector3D

Returns the vector scaled by the specified values. - Parameter x: The scale factor on the `x` dimension. - Parameter y: The scale factor on the `y` dimension. - Parameter z: The scale factor on the `z` dimension. - Returns The scaled vector.

normalize

normalize(): void

mutating func normalize()

Normalizes the vector.

projected

projected(other: Vector3D): Vector3D

func projected(_ other: Vector3D) -> Vector3D

Returns this vector projected onto the specified vector.

reflected

reflected(normal: Vector3D): Vector3D

func reflected(_ normal: Vector3D) -> Vector3D

Returns the reflection direction of this incident vector and the specified unit normal vector.

init

static init(vector: Vector3DFloat): Vector3D

init(_ vector: Vector3DFloat)

Returns a double-precision vector from a single-precision vector.

init

static init65124(axis: RotationAxis3D): Vector3D

init(_ axis: RotationAxis3D)

Returns a new vector from a rotation axis. - Parameter axis: The source rotation axis.

init

static init57812(coords: SphericalCoordinates3D): Vector3D

init(_ coords: SphericalCoordinates3D)

Creates a new vector structure that contains the spherical coordinates converted to Cartesian coordinates. - Parameter coords: The spherical coordinates.

init

static init96699(size: Size3D): Vector3D

init(_ size: Size3D)

Returns a new vector from a size. - Parameter size: The source size.

init

static init26545(point: Point3D): Vector3D

init(_ point: Point3D)

Returns a new vector from a point. - Parameter point: The source point.

init

static init51462(xyz: SDKHandle): Vector3D

init(_ xyz: simd_double3)

Returns a new vector from a double-precision vector. - Parameter xyz: The source vector.

init

static init78140(xyz: SDKHandle): Vector3D

init(_ xyz: simd_float3)

Returns a vector point from a single-precision vector. - note: This function is provided as a convenience. All Spatial storage and calculations are double-precision.

init

static init28359(source: SDKHandle): Vector3D

init(_ source: simd_packed_double4)

Creates a Spatial vector from a simd packed vector.

init

static init65919(): Vector3D

init()