AffineTransform3DFloat

concatenating

concatenating(t2: AffineTransform3DFloat): AffineTransform3DFloat

func concatenating(_ t2: AffineTransform3DFloat) -> AffineTransform3DFloat

matrix3x3

get matrix3x3(): SDKHandle

var matrix3x3: simd_float3x3 { get }

matrix4x4

get matrix4x4(): SDKHandle

var matrix4x4: simd_float4x4 { get }

scale

get scale(): Size3DFloat

var scale: Size3DFloat { get }

isIdentity

get isIdentity(): boolean

var isIdentity: Bool { get }

isInvertible

get isInvertible(): boolean

var isInvertible: Bool { get }

isRectilinear

get isRectilinear(): boolean

var isRectilinear: Bool { get }

isTranslation

get isTranslation(): boolean

var isTranslation: Bool { get }

isUniform

get isUniform(): boolean

var isUniform: Bool { get }

init

static initRotation(rotation: Rotation3DFloat): AffineTransform3DFloat

init(rotation: Rotation3DFloat)

init

static initScale(scale: Size3DFloat): AffineTransform3DFloat

init(scale: Size3DFloat)

init

static initTranslation(offset: Vector3DFloat): AffineTransform3DFloat

init(translation offset: Vector3DFloat)

init

static init(matrix: SDKHandle): AffineTransform3DFloat

init(_ matrix: simd_float4x3)

init

static initTruncating(matrix: SDKHandle): AffineTransform3DFloat

init(truncating matrix: simd_float4x4)

init

static initTruncating93513(transform: ProjectiveTransform3DFloat): AffineTransform3DFloat

init(truncating transform: ProjectiveTransform3DFloat)

rotated

rotatedBy(rotation: Rotation3DFloat): AffineTransform3DFloat

func rotated(by rotation: Rotation3DFloat) -> AffineTransform3DFloat

rotated

rotatedBy78002(quaternion: SDKHandle): AffineTransform3DFloat

func rotated(by quaternion: simd_quatf) -> AffineTransform3DFloat

scaled

scaled(scale: Size3DFloat): AffineTransform3DFloat

func scaled(by scale: Size3DFloat) -> AffineTransform3DFloat

uniformlyScaled

uniformlyScaled(scale: number): AffineTransform3DFloat

func uniformlyScaled(by scale: Float) -> AffineTransform3DFloat

translated

translated(offset: Vector3DFloat): AffineTransform3DFloat

func translated(by offset: Vector3DFloat) -> AffineTransform3DFloat

matrix

get matrix(): SDKHandle

var matrix: simd_float4x3

matrix

set matrix(value: SDKHandle)

var matrix: simd_float4x3

identity

static get identity(): AffineTransform3DFloat

static let identity: AffineTransform3DFloat

init

static initMatrix(matrix: SDKHandle): AffineTransform3DFloat

init(matrix: simd_float4x3)

init

static initScaledPose(scaledPose: ScaledPose3DFloat): AffineTransform3DFloat

init(scaledPose: ScaledPose3DFloat)

Returns a new transform from the specified scaled pose. - Parameter pose: The source pose

init

static initTruncating9639(matrix: SDKHandle): AffineTransform3DFloat

init(truncating matrix: simd_double4x4)

Returns a new affine transform from a double-precision 4 x 4 matrix truncated to a 4 x 3 matrix. - Parameter matrix: The source matrix. - note: This function is provided as a convenience. All Spatial storage and calculations are single-precision.

changeBasis

changeBasis(from: AffineTransform3DFloat, to: AffineTransform3DFloat): (AffineTransform3DFloat) | null

func changeBasis(from: AffineTransform3DFloat = .identity, to: AffineTransform3DFloat) -> AffineTransform3DFloat?

Returns a new affine transform structure by applying a change-of-basis. - Parameter from: The old basis. - Parameter to: The new basis. - returns: A new affine transform structure.

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.

translation

get translation(): Vector3DFloat

var translation: Vector3DFloat { get set }

The translation component

translation

set translation(value: Vector3DFloat)

var translation: Vector3DFloat { get set }

The translation component

customMirror

get customMirror(): SDKHandle

var customMirror: Mirror { get }

The custom mirror for this instance.

isApproximatelyEqual

isApproximatelyEqual(other: AffineTransform3DFloat, tolerance?: number): boolean

func isApproximatelyEqual(to other: AffineTransform3DFloat, tolerance: Float = sqrt(.ulpOfOne)) -> Bool

Returns a Boolean value that indicates whether two transforms are equal within a specified tolerance. - Parameter transform: The second transform. - Parameter tolerance: The tolerance of the comparison.

flip

flip(axis: Axis3D): void

mutating func flip(along axis: Axis3D)

Flips the transform along the specified axis. - Parameter axis: The axis of the flip operation.

init

static initPose(pose: Pose3DFloat): AffineTransform3DFloat

init(pose: Pose3DFloat)

Returns a new transform from the specified pose. - Parameter pose: The source pose

init

static initScaleRotationTranslation(scale?: Size3DFloat, rotation?: Rotation3DFloat, translation?: Vector3DFloat): AffineTransform3DFloat

init(scale: Size3DFloat = Size3DFloat(width: 1.0, height: 1, depth: 1), rotation: Rotation3DFloat = .identity, translation: Vector3DFloat = .zero)

Returns a new scale, rotate, translate transform. - Parameter scale: The scale. - Parameter rotation: The rotation. - Parameter translation: The translation.

init

static initShear(shear: AxisWithFactorsFloat): AffineTransform3DFloat

init(shear: AxisWithFactorsFloat)

Returns a new shear transform - Parameter shear: The shear.

columns

get columns(): [Vector3DFloat, Vector3DFloat, Vector3DFloat, Vector3DFloat]

var columns: (Vector3DFloat, Vector3DFloat, Vector3DFloat, Vector3DFloat) { get }

The columns of the underlying matrix.

flipped

flipped(axis: Axis3D): AffineTransform3DFloat

func flipped(along axis: Axis3D) -> AffineTransform3DFloat

Returns the transform flipped along the specified axis. - Parameter axis: The axis of the flip operation.

inverse

get inverse(): (AffineTransform3DFloat) | null

var inverse: AffineTransform3DFloat? { get }

The affine transform's inverse. If the source transform isn't invertible, this value is `nil`.

sheared

sheared(shear: AxisWithFactorsFloat): AffineTransform3DFloat

func sheared(_ shear: AxisWithFactorsFloat) -> AffineTransform3DFloat

Returns the transform sheared by the specified shear. - Parameter shear: The axis and shear factors. - Returns The sheared transform.

rotation

get rotation(): (Rotation3DFloat) | null

var rotation: Rotation3DFloat? { get }

The affine transform's rotation. This function can't extract rotation from a non-scale-rotate-translate affine transform. In that case, the function returns `nil`.

scaledBy

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

func scaledBy(x: Float = 1, y: Float = 1, z: Float = 1) -> AffineTransform3DFloat

Returns the transform 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 transform.

isUniform

isUniformOverDimensions(overDimensions: Dimension3DSet): boolean

func isUniform(overDimensions: Dimension3DSet) -> Bool

Returns `true` if the transform is uniform over the specified dimensions. - Parameter overDimensions: The dimensions that the function tests are uniform. If you specify `overDimensions` as `Dimension3DFloatSet.all`, the function returns the same result as `Transform3DFloat.getter:isUniform`. If you specify as `overDimensions` with zero or one dimension, the function returns the same result as `Transform3DFloat.getter:isRectilinear`.

init

static init54764(): AffineTransform3DFloat

init()

Returns a new identity affine transform.

init

static init50539(transform: AffineTransform3D): AffineTransform3DFloat

init(_ transform: AffineTransform3D)

Returns a single-precision affine transformation from a double-precision affine transformation.

init

static init31936(matrix: SDKHandle): AffineTransform3DFloat

init(_ matrix: simd_double4x3)

Returns a new affine transform structure from the specified double-precision 4 x 3 matrix. - note: This function is provided as a convenience. All Spatial storage and calculations are single-precision.

init

static init25726(): AffineTransform3DFloat

init()

Returns a new identity affine transform.