Rect3D

applying

applying(transform: AffineTransform3D): Rect3D

func applying(_ transform: AffineTransform3D) -> Rect3D

applying

applying92335(transform: ProjectiveTransform3D): Rect3D

func applying(_ transform: ProjectiveTransform3D) -> Rect3D

contains

containsPoint(other: Point3D): boolean

func contains(point other: Point3D) -> Bool

contains

contains(other: Rect3D): boolean

func contains(_ other: Rect3D) -> Bool

center

get center(): Point3D

var center: Point3D { get }

max

get max(): Point3D

var max: Point3D { get }

min

get min(): Point3D

var min: Point3D { get }

inset

inset(dXYZ: Size3D): Rect3D

func inset(by dXYZ: Size3D) -> Rect3D

integral

get integral(): Rect3D

var integral: Rect3D { get }

intersects

intersects(other: Rect3D): boolean

func intersects(_ other: Rect3D) -> Bool

isEmpty

get isEmpty(): boolean

var isEmpty: Bool { get }

isFinite

get isFinite(): boolean

var isFinite: Bool { get }

isNaN

get isNaN(): boolean

var isNaN: Bool { get }

isZero

get isZero(): boolean

var isZero: Bool { get }

init

static initCenterSize(center: Point3D, size: Size3D): Rect3D

init(center: Point3D, size: Size3D)

init

static initOriginSize(origin: Point3D, size: Size3D): Rect3D

init(origin: Point3D, size: Size3D)

rotated

rotatedBy(rotation: Rotation3D): Rect3D

func rotated(by rotation: Rotation3D) -> Rect3D

rotated

rotatedByAround(rotation: Rotation3D, pivot: Point3D): Rect3D

func rotated(by rotation: Rotation3D, around pivot: Point3D) -> Rect3D

rotated

rotatedBy83504(quaternion: SDKHandle): Rect3D

func rotated(by quaternion: simd_quatd) -> Rect3D

rotated

rotatedByAround39598(quaternion: SDKHandle, pivot: Point3D): Rect3D

func rotated(by quaternion: simd_quatd, around pivot: Point3D) -> Rect3D

scaled

scaled(scale: Size3D): Rect3D

func scaled(by scale: Size3D) -> Rect3D

uniformlyScaled

uniformlyScaled(scale: number): Rect3D

func uniformlyScaled(by scale: Double) -> Rect3D

standardized

get standardized(): Rect3D

var standardized: Rect3D { get }

translated

translatedBy(offset: Vector3D): Rect3D

func translated(by offset: Vector3D) -> Rect3D

union

union(other: Rect3D): Rect3D

func union(_ other: Rect3D) -> Rect3D

origin

get origin(): Point3D

var origin: Point3D

origin

set origin(value: Point3D)

var origin: Point3D

size

get size(): Size3D

var size: Size3D

size

set size(value: Size3D)

var size: Size3D

infinity

static get infinity(): Rect3D

static let infinity: Rect3D

zero

static get zero(): Rect3D

static let zero: Rect3D

init

static initOriginSize65198(origin: Point3D, size: Size3D): Rect3D

init(origin: Point3D, size: Size3D)

translated

translatedBy59021(size: Size3D): Rect3D

func translated(by size: Size3D) -> Rect3D

Returns the entity translated by the specified size. - Parameter size: The size structure that defines that translation.

unapplying

unapplying(scaledPose: ScaledPose3D): Rect3D

func unapplying(_ scaledPose: ScaledPose3D) -> Rect3D

Returns the primitive that results from applying a scaled pose to the primitive. - Parameter pose: The scaled pose. - Returns The transformed primitive. - Note: The pose's rotation angle must be zero, otherwise this function returns `self`.

unapplying

unapplying3453(transform: AffineTransform3D): Rect3D

func unapplying(_ transform: AffineTransform3D) -> Rect3D

Unapplies an affine transform. - Parameter transform: The affine transform. - Note: The transform must be rectilinear otherwise this function returns `self`.

unapplying

unapplying35784(transform: ProjectiveTransform3D): Rect3D

func unapplying(_ transform: ProjectiveTransform3D) -> Rect3D

Unapplies a projective transform. - Parameter transform: The projective transform. - Note: The transform must be rectilinear otherwise this function returns `self`.

unapplying

unapplying39689(pose: Pose3D): Rect3D

func unapplying(_ pose: Pose3D) -> Rect3D

Returns the primitive that results from applying a pose to the primitive. - Parameter pose: The pose. - Returns The transformed primitive. - Note: The pose's rotation angle must be zero, otherwise this function returns `self`.

containsAny

containsAny(points: Array<Point3D>): boolean

func containsAny(of points: [Point3D]) -> Bool

Returns a Boolean value that indicates whether this volume contains any of the specified points. - Parameter points: An array of points. - Returns A Boolean value that indicates whether `self` contains any of the specified points.

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.

cornerPoints

get cornerPoints(): Array<Point3D>

var cornerPoints: [Point3D] { get }

Returns the corner points of the rectangle. This function returns the vertices in a clockwise direction, starting from the origin: 5-----6 | | 1-----2 | | | | | y z | 4--|--7 | / | | |/ 0-----3 +-- x For example, `points[0]` equals `rect.origin`, and `points[6]` is at `rect.origin` offset by `rect.size`.

customMirror

get customMirror(): SDKHandle

var customMirror: Mirror { get }

The custom mirror for this instance.

intersection

intersection(other: Rect3D): (Rect3D) | null

func intersection(_ other: Rect3D) -> Rect3D?

Returns the intersection of two rectangles. - Parameter other: The second rectangle. - Returns The intersection of `self` and `other`.

maxX

get maxX(): number

var maxX: Double { get }

Returns the largest value of the x-coordinate for the rectangle.

maxY

get maxY(): number

var maxY: Double { get }

Returns the largest value of the y-coordinate for the rectangle.

maxZ

get maxZ(): number

var maxZ: Double { get }

Returns the largest value of the z-coordinate for the rectangle.

midX

get midX(): number

var midX: Double { get }

Returns the x-coordinate that establishes the center of a rectangle.

midY

get midY(): number

var midY: Double { get }

Returns the y-coordinate that establishes the center of a rectangle.

midZ

get midZ(): number

var midZ: Double { get }

Returns the z-coordinate that establishes the center of a rectangle.

minX

get minX(): number

var minX: Double { get }

Returns the smallest value for the x-coordinate of the rectangle.

minY

get minY(): number

var minY: Double { get }

Returns the smallest value for the y-coordinate of the rectangle.

minZ

get minZ(): number

var minZ: Double { get }

Returns the smallest value for the z-coordinate of the rectangle.

init

static initCenterSize80186(center: Vector3D, size: Vector3D): Rect3D

init(center: Vector3D = .zero, size: Vector3D)

Creates a rectangle from Spatial vectors that describe the center and size. - Parameter center: The center of the rectangle. - Parameter size: The size of the rectangle.

init

static initCenterSize67077(center: SDKHandle, size: SDKHandle): Rect3D

init(center: simd_double3 = .zero, size: simd_double3)

Creates a rectangle from simd vectors that describe the center and size. - Parameter center: The center of the rectangle. - Parameter size: The size of the rectangle.

init

static initCenterSize55647(center: SDKHandle, size: SDKHandle): Rect3D

init(center: simd_float3 = .zero, size: simd_float3)

Creates a rectangle from single-precision vectors that describe the center and size. - Parameter center: The center of the rectangle. - Parameter size: The size of the rectangle. - note: This function is provided as a convenience. All Spatial storage and calculations are double-precision.

init

static initOriginSize30819(origin: Vector3D, size: Vector3D): Rect3D

init(origin: Vector3D = .zero, size: Vector3D)

Creates a rectangle from Spatial vectors that describe the origin and size. - Parameter origin: The origin of the rectangle. - Parameter size: The size of the rectangle.

init

static initOriginSize72206(origin: SDKHandle, size: SDKHandle): Rect3D

init(origin: simd_double3 = .zero, size: simd_double3)

Creates a rectangle from simd vectors that describe the origin and size. - Parameter origin: The origin of the rectangle. - Parameter size: The size of the rectangle.

init

static initOriginSize91456(origin: SDKHandle, size: SDKHandle): Rect3D

init(origin: simd_float3 = .zero, size: simd_float3)

Creates a rectangle from single-precision vectors that describe the origin and size. - Parameter origin: The origin of the rectangle. - Parameter size: The size of the rectangle. - note: This function is provided as a convenience. All Spatial storage and calculations are double-precision.

init

static initPoints(points: Array<Point3D>): Rect3D

init(points: [Point3D])

Creates a rectangle that's the bounding box of the specified points. - Parameter points: The array of points. - Precondition: The `points` array must contain at least one element.

sheared

sheared(shear: AxisWithFactors): Rect3D

func sheared(_ shear: AxisWithFactors) -> Rect3D

Returns a sheared rectangle. - Parameter shear: The axis and shear factors. - Returns The sheared rectangle. Because affine transforms do not preserve rectangles in general, this function returns the smallest rectangle that contains the transformed corner points of the rect parameter.

applying

applying22312(scaledPose: ScaledPose3D): Rect3D

func applying(_ scaledPose: ScaledPose3D) -> Rect3D

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

applying

applying23769(pose: Pose3D): Rect3D

func applying(_ pose: Pose3D) -> Rect3D

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

contains

containsAnyOf(points: Array<Point3D>): boolean

func contains(anyOf points: [Point3D]) -> Bool

Returns a Boolean value that indicates whether this volume contains any of the specified points. - Parameter points: An array of points. - Returns A Boolean value that indicates whether `self` contains any of the specified points.

distance

distance(other: Rect3D): number

func distance(to other: Rect3D) -> Double

Returns the distance between the origins of two rectangle.

rotation

rotation(other: Rect3D): Rotation3D

func rotation(to other: Rect3D) -> Rotation3D

Returns the rotation around @p (0,0,0) from the first rectangle to the second rectangle.

scaledBy

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

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

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

formInset

formInset(dXYZ: Size3D): void

mutating func formInset(by dXYZ: Size3D)

Insets the rectangle by the specified size. - Parameter dXYZ: The inset amount. This function insets the rectangle by the specified values on each axis. The origin value is offset by the distance specified by the `dXYZ` parameter. The size is adjusted by `(2*dXYZ)`, relative to the source rectangle. If the width, height, or depth are positive values, then the rectangle’s size is decreased on that dimension. If width, height, or depth are negative values, the rectangle’s size is increased on that dimension.

init

static init(rect: Rect3DFloat): Rect3D

init(_ rect: Rect3DFloat)

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

init

static init80175(): Rect3D

init()