@ringozz/godot 4.7.2-583 → 4.7.2-592

package/gen/value-types/Plane.ts

@@ -1,134 +1,130 @@
 // Auto-generated from extension_api.json - DO NOT EDIT
 // Generated by dev/codegen.ts
 
-import { GodotVar, _C, _R, _get, _set } from '../../src/runtime.ts';
+import { _V } from '../../src/runtime.ts';
 import type { GodotArray, GodotDictionary, Variant } from '../heap-types/index.ts';
-import type { Transform3D, Vector3 } from '../value-types/index.ts';
+import type { Transform3D, Vector3 } from './index.ts';
 
 /**
  * Represents a normalized plane equation. {@link normal} is the normal of the plane (a, b, c normalized), and {@link d} is the distance from the origin to the plane (in the direction of "normal"). "Over" or "Above" the plane is considered the side of the plane towards where the normal is pointing.
  * **Note:** In a boolean context, a plane will evaluate to `false` if all its components equal `0`. Otherwise, a plane will always evaluate to `true`.
  */
-export class Plane extends GodotVar {
-    /**
-     * The X component of the plane's {@link normal} vector.
-     */
-    get x(): number { return _get(this, 14941) as number; }
-    set x(v: number) { _set(this, 14941, v); }
-
-    /**
-     * The Y component of the plane's {@link normal} vector.
-     */
-    get y(): number { return _get(this, 14952) as number; }
-    set y(v: number) { _set(this, 14952, v); }
-
-    /**
-     * The Z component of the plane's {@link normal} vector.
-     */
-    get z(): number { return _get(this, 14956) as number; }
-    set z(v: number) { _set(this, 14956, v); }
-
-    /**
-     * The distance from the origin to the plane, expressed in terms of {@link normal} (according to its direction and magnitude). Actual absolute distance from the origin to the plane can be calculated as `abs(d) / normal.length()` (if {@link normal} has zero length then this {@link Plane} does not represent a valid plane).
-     * In the scalar equation of the plane `ax + by + cz = d`, this is {@link code skip-lint}d, while the `(a, b, c)` coordinates are represented by the {@link normal} property.
-     */
-    get d(): number { return _get(this, 2641) as number; }
-    set d(v: number) { _set(this, 2641, v); }
-
-    /**
-     * The normal of the plane, typically a unit vector. Shouldn't be a zero vector as {@link Plane} with such {@link normal} does not represent a valid plane.
-     * In the scalar equation of the plane `ax + by + cz = d`, this is the vector `(a, b, c)`, where {@link code skip-lint}d is the {@link d} property.
-     */
-    get normal(): Vector3 { return _get(this, 9094) as Vector3; }
-    set normal(v: Vector3) { _set(this, 9094, v); }
-
-    constructor();
-    constructor(from: Plane);
-    constructor(normal: Vector3);
-    constructor(normal: Vector3, d: number);
-    constructor(normal: Vector3, point: Vector3);
-    constructor(point1: Vector3, point2: Vector3, point3: Vector3);
-    constructor(a: number, b: number, c: number, d: number);
-    constructor(...args: any[]) { super(14, ...args); }
-
-    /**
-     * Returns a copy of the plane, with normalized {@link normal} (so it's a unit vector). Returns `Plane(0, 0, 0, 0)` if {@link normal} can't be normalized (it has zero length).
-     */
-    normalized(): Plane { return _C(this, 9103) as Plane; }
-
-    /**
-     * Returns the center of the plane.
-     */
-    getCenter(): Vector3 { return _C(this, 4121) as Vector3; }
-
-    /**
-     * Returns `true` if this plane and `toPlane` are approximately equal, by running {@link isEqualApprox} on each component.
-     */
-    isEqualApprox(toPlane: Plane): boolean { return _C(this, 7938, toPlane) as boolean; }
-
-    /**
-     * Returns `true` if this plane is finite, by calling {@link isFinite} on each component.
-     */
-    isFinite(): boolean { return _C(this, 7951) as boolean; }
-
-    /**
-     * Returns `true` if `point` is located above the plane.
-     */
-    isPointOver(point: Vector3): boolean { return _C(this, 8188, point) as boolean; }
-
-    /**
-     * Returns the shortest distance from the plane to the position `point`. If the point is above the plane, the distance will be positive. If below, the distance will be negative.
-     */
-    distanceTo(point: Vector3): number { return _C(this, 2850, point) as number; }
-
-    /**
-     * Returns `true` if `point` is inside the plane. Comparison uses a custom minimum `tolerance` threshold.
-     */
-    hasPoint(point: Vector3, tolerance?: number /* = 1e-05 */): boolean { return _C(this, 7430, point, tolerance) as boolean; }
-
-    /**
-     * Returns the orthogonal projection of `point` into a point in the plane.
-     */
-    project(point: Vector3): Vector3 { return _C(this, 9589, point) as Vector3; }
-
-    /**
-     * Returns the intersection point of the three planes `b`, `c` and this plane. If no intersection is found, `null` is returned.
-     */
-    intersect3(b: Plane, c: Plane): Variant { return _C(this, 7698, b, c) as Variant; }
-
-    /**
-     * Returns the intersection point of a ray consisting of the position `from` and the direction normal `dir` with this plane. If no intersection is found, `null` is returned.
-     */
-    intersectsRay(from: Vector3, dir: Vector3): Variant { return _C(this, 7709, from, dir) as Variant; }
-
-    /**
-     * Returns the intersection point of a segment from position `from` to position `to` with this plane. If no intersection is found, `null` is returned.
-     */
-    intersectsSegment(from: Vector3, to: Vector3): Variant { return _C(this, 7710, from, to) as Variant; }
-
-    equals(other: Variant | Plane): boolean { return _C(this, -1, other) as boolean; }
-
-    notEquals(other: Variant | Plane): boolean { return _C(this, -2, other) as boolean; }
-
-    /**
-     * Returns the negative value of the {@link Plane}. This is the same as writing `Plane(-p.normal, -p.d)`. This operation flips the direction of the normal vector and also flips the distance value, resulting in a Plane that is in the same place, but facing the opposite direction.
-     */
-    neg(): Plane { return _C(this, -11, undefined) as Plane; }
-
-    /**
-     * Returns the same value as if the `+` was not there. Unary `+` does nothing, but sometimes it can make your code more readable.
-     */
-    pos(): Plane { return _C(this, -12, undefined) as Plane; }
-
-    not(): boolean { return _C(this, -24, undefined) as boolean; }
-
-    /**
-     * Inversely transforms (multiplies) the {@link Plane} by the given {@link Transform3D} transformation matrix.
-     * `plane * transform` is equivalent to `transform.affine_inverse() * plane`. See {@link Transform3D.affineInverse}.
-     */
-    mul(other: Transform3D): Plane { return _C(this, -9, other) as Plane; }
-
-    contains(other: GodotDictionary | GodotArray): boolean { return _C(this, -25, other) as boolean; }
-
-    static readonly name = _R(14, Plane);
-}
+export type Plane = [x: number, y: number, z: number, d: number];
+
+/**
+ * Returns a copy of the plane, with normalized {@link normal} (so it's a unit vector). Returns `Plane(0, 0, 0, 0)` if {@link normal} can't be normalized (it has zero length).
+ */
+export function normalized(self: Plane): Plane { return _V(14, 9103, self) as Plane; }
+
+/**
+ * Returns the center of the plane.
+ */
+export function getCenter(self: Plane): Vector3 { return _V(14, 4121, self) as Vector3; }
+
+/**
+ * Returns `true` if this plane and `toPlane` are approximately equal, by running {@link isEqualApprox} on each component.
+ */
+export function isEqualApprox(self: Plane, toPlane: Plane): boolean { return _V(14, 7938, self, toPlane) as boolean; }
+
+/**
+ * Returns `true` if this plane is finite, by calling {@link isFinite} on each component.
+ */
+export function isFinite(self: Plane): boolean { return _V(14, 7951, self) as boolean; }
+
+/**
+ * Returns `true` if `point` is located above the plane.
+ */
+export function isPointOver(self: Plane, point: Vector3): boolean { return _V(14, 8188, self, point) as boolean; }
+
+/**
+ * Returns the shortest distance from the plane to the position `point`. If the point is above the plane, the distance will be positive. If below, the distance will be negative.
+ */
+export function distanceTo(self: Plane, point: Vector3): number { return _V(14, 2850, self, point) as number; }
+
+/**
+ * Returns `true` if `point` is inside the plane. Comparison uses a custom minimum `tolerance` threshold.
+ */
+export function hasPoint(self: Plane, point: Vector3, tolerance?: number /* = 1e-05 */): boolean { return _V(14, 7430, self, point, tolerance) as boolean; }
+
+/**
+ * Returns the orthogonal projection of `point` into a point in the plane.
+ */
+export function project(self: Plane, point: Vector3): Vector3 { return _V(14, 9589, self, point) as Vector3; }
+
+/**
+ * Returns the intersection point of the three planes `b`, `c` and this plane. If no intersection is found, `null` is returned.
+ */
+export function intersect3(self: Plane, b: Plane, c: Plane): Variant { return _V(14, 7698, self, b, c) as Variant; }
+
+/**
+ * Returns the intersection point of a ray consisting of the position `from` and the direction normal `dir` with this plane. If no intersection is found, `null` is returned.
+ */
+export function intersectsRay(self: Plane, from: Vector3, dir: Vector3): Variant { return _V(14, 7709, self, from, dir) as Variant; }
+
+/**
+ * Returns the intersection point of a segment from position `from` to position `to` with this plane. If no intersection is found, `null` is returned.
+ */
+export function intersectsSegment(self: Plane, from: Vector3, to: Vector3): Variant { return _V(14, 7710, self, from, to) as Variant; }
+
+export function equals(a: Plane, b: Variant | Plane): boolean { return _V(14, -1, a, b) as boolean; }
+
+export function notEquals(a: Plane, b: Variant | Plane): boolean { return _V(14, -2, a, b) as boolean; }
+
+/**
+ * Returns the negative value of the {@link Plane}. This is the same as writing `Plane(-p.normal, -p.d)`. This operation flips the direction of the normal vector and also flips the distance value, resulting in a Plane that is in the same place, but facing the opposite direction.
+ */
+export function neg(self: Plane): Plane { return _V(14, -11, self, undefined) as Plane; }
+
+/**
+ * Returns the same value as if the `+` was not there. Unary `+` does nothing, but sometimes it can make your code more readable.
+ */
+export function pos(self: Plane): Plane { return _V(14, -12, self, undefined) as Plane; }
+
+export function not(self: Plane): boolean { return _V(14, -24, self, undefined) as boolean; }
+
+/**
+ * Inversely transforms (multiplies) the {@link Plane} by the given {@link Transform3D} transformation matrix.
+ * `plane * transform` is equivalent to `transform.affine_inverse() * plane`. See {@link Transform3D.affineInverse}.
+ */
+export function mul(a: Plane, b: Transform3D): Plane { return _V(14, -9, a, b) as Plane; }
+
+export function contains(a: Plane, b: GodotDictionary | GodotArray): boolean { return _V(14, -25, a, b) as boolean; }
+
+/**
+ * Constructs a default-initialized {@link Plane} with all components set to `0`.
+ */
+export function create(): Plane { return _V(14, -4096, 0) as Plane; }
+
+/**
+ * Constructs a {@link Plane} as a copy of the given {@link Plane}.
+ */
+export function fromPlane(from: Plane): Plane { return _V(14, -4096, 1, from) as Plane; }
+
+/**
+ * Creates a plane from the normal vector. The plane will intersect the origin.
+ * The `normal` of the plane must be a unit vector.
+ */
+export function fromNormal(normal: Vector3): Plane { return _V(14, -4096, 2, normal) as Plane; }
+
+/**
+ * Creates a plane from the normal vector and the plane's distance from the origin.
+ * The `normal` of the plane must be a unit vector.
+ */
+export function fromNormalD(normal: Vector3, d: number): Plane { return _V(14, -4096, 3, normal, d) as Plane; }
+
+/**
+ * Creates a plane from the normal vector and a point on the plane.
+ * The `normal` of the plane must be a unit vector.
+ */
+export function fromNormalPoint(normal: Vector3, point: Vector3): Plane { return _V(14, -4096, 4, normal, point) as Plane; }
+
+/**
+ * Creates a plane from the three points, given in clockwise order.
+ */
+export function fromPoint1Point2Point3(point1: Vector3, point2: Vector3, point3: Vector3): Plane { return _V(14, -4096, 5, point1, point2, point3) as Plane; }
+
+/**
+ * Creates a plane from the four parameters. The three components of the resulting plane's {@link normal} are `a`, `b` and `c`, and the plane has a distance of `d` from the origin.
+ */
+export function fromABCD(a: number, b: number, c: number, d: number): Plane { return _V(14, -4096, 6, a, b, c, d) as Plane; }
+

package/gen/value-types/Projection.ts

@@ -1,9 +1,9 @@
 // Auto-generated from extension_api.json - DO NOT EDIT
 // Generated by dev/codegen.ts
 
-import { GodotVar, _C, _R, _get, _set } from '../../src/runtime.ts';
+import { _V } from '../../src/runtime.ts';
 import type { GodotArray, GodotDictionary, Variant } from '../heap-types/index.ts';
-import type { Plane, Transform3D, Vector2, Vector4 } from '../value-types/index.ts';
+import type { AABB, Plane, Rect2, Transform3D, Vector2, Vector4 } from './index.ts';
 
 /**
  * A 4×4 matrix used for 3D projective transformations. It can represent transformations such as translation, rotation, scaling, shearing, and perspective division. It consists of four {@link Vector4} columns.
@@ -11,127 +11,179 @@ import type { Plane, Transform3D, Vector2, Vector4 } from '../value-types/index.
  * Used internally as {@link Camera3D}'s projection matrix.
  * **Note:** In a boolean context, a projection will evaluate to `false` if it's equal to {@link IDENTITY}. Otherwise, a projection will always evaluate to `true`.
  */
-export class Projection extends GodotVar {
-    /**
-     * The projection matrix's X vector (column 0). Equivalent to array index `0`.
-     */
-    get x(): Vector4 { return _get(this, 14941) as Vector4; }
-    set x(v: Vector4) { _set(this, 14941, v); }
-
-    /**
-     * The projection matrix's Y vector (column 1). Equivalent to array index `1`.
-     */
-    get y(): Vector4 { return _get(this, 14952) as Vector4; }
-    set y(v: Vector4) { _set(this, 14952, v); }
-
-    /**
-     * The projection matrix's Z vector (column 2). Equivalent to array index `2`.
-     */
-    get z(): Vector4 { return _get(this, 14956) as Vector4; }
-    set z(v: Vector4) { _set(this, 14956, v); }
-
-    /**
-     * The projection matrix's W vector (column 3). Equivalent to array index `3`.
-     */
-    get w(): Vector4 { return _get(this, 14833) as Vector4; }
-    set w(v: Vector4) { _set(this, 14833, v); }
-
-    constructor();
-    constructor(from: Projection);
-    constructor(from: Transform3D);
-    constructor(xAxis: Vector4, yAxis: Vector4, zAxis: Vector4, wAxis: Vector4);
-    constructor(...args: any[]) { super(19, ...args); }
-
-    /**
-     * Returns a scalar value that is the signed factor by which areas are scaled by this matrix. If the sign is negative, the matrix flips the orientation of the area.
-     * The determinant can be used to calculate the invertibility of a matrix or solve linear systems of equations involving the matrix, among other applications.
-     */
-    determinant(): number { return _C(this, 2773) as number; }
-
-    /**
-     * Returns a {@link Projection} with the near clipping distance adjusted to be `newZnear`.
-     * **Note:** The original {@link Projection} must be a perspective projection.
-     */
-    perspectiveZnearAdjusted(newZnear: number): Projection { return _C(this, 9398, newZnear) as Projection; }
-
-    /**
-     * Returns the clipping plane of this {@link Projection} whose index is given by `plane`.
-     * `plane` should be equal to one of {@link PLANE_NEAR}, {@link PLANE_FAR}, {@link PLANE_LEFT}, {@link PLANE_TOP}, {@link PLANE_RIGHT}, or {@link PLANE_BOTTOM}.
-     */
-    getProjectionPlane(plane: number): Plane { return _C(this, 6046, plane) as Plane; }
-
-    /**
-     * Returns a copy of this {@link Projection} with the signs of the values of the Y column flipped.
-     */
-    flippedY(): Projection { return _C(this, 3334) as Projection; }
-
-    /**
-     * Returns a {@link Projection} with the X and Y values from the given {@link Vector2} added to the first and second values of the final column respectively.
-     */
-    jitterOffseted(offset: Vector2): Projection { return _C(this, 8472, offset) as Projection; }
-
-    /**
-     * Returns the distance for this {@link Projection} beyond which positions are clipped.
-     */
-    getZFar(): number { return _C(this, 7179) as number; }
-
-    /**
-     * Returns the distance for this {@link Projection} before which positions are clipped.
-     */
-    getZNear(): number { return _C(this, 7181) as number; }
-
-    /**
-     * Returns the X:Y aspect ratio of this {@link Projection}'s viewport.
-     */
-    getAspect(): number { return _C(this, 3800) as number; }
-
-    /**
-     * Returns the horizontal field of view of the projection (in degrees).
-     */
-    getFov(): number { return _C(this, 4865) as number; }
-
-    /**
-     * Returns `true` if this {@link Projection} performs an orthogonal projection.
-     */
-    isOrthogonal(): boolean { return _C(this, 8157) as boolean; }
-
-    /**
-     * Returns the dimensions of the viewport plane that this {@link Projection} projects positions onto, divided by two.
-     */
-    getViewportHalfExtents(): Vector2 { return _C(this, 7082) as Vector2; }
-
-    /**
-     * Returns the dimensions of the far clipping plane of the projection, divided by two.
-     */
-    getFarPlaneHalfExtents(): Vector2 { return _C(this, 4759) as Vector2; }
-
-    /**
-     * Returns a {@link Projection} that performs the inverse of this {@link Projection}'s projective transformation.
-     */
-    inverse(): Projection { return _C(this, 7714) as Projection; }
-
-    /**
-     * Returns `forPixelWidth` divided by the viewport's width measured in meters on the near plane, after this {@link Projection} is applied.
-     */
-    getPixelsPerMeter(forPixelWidth: number): number { return _C(this, 5915, forPixelWidth) as number; }
-
-    /**
-     * Returns the factor by which the visible level of detail is scaled by this {@link Projection}.
-     */
-    getLodMultiplier(): number { return _C(this, 5411) as number; }
-
-    equals(other: Variant | Projection): boolean { return _C(this, -1, other) as boolean; }
-
-    notEquals(other: Variant | Projection): boolean { return _C(this, -2, other) as boolean; }
-
-    not(): boolean { return _C(this, -24, undefined) as boolean; }
-
-    /**
-     * Projects (multiplies) the given {@link Vector4} by this {@link Projection} matrix.
-     */
-    mul(other: Vector4 | Projection): Vector4 { return _C(this, -9, other) as Vector4; }
-
-    contains(other: GodotDictionary | GodotArray): boolean { return _C(this, -25, other) as boolean; }
-
-    static readonly name = _R(19, Projection);
-}
+export type Projection = [x: Vector4, y: Vector4, z: Vector4, w: Vector4];
+
+/**
+ * Creates a new {@link Projection} that projects positions from a depth range of `-1` to `1` to one that ranges from `0` to `1`, and flips the projected positions vertically, according to `flipY`.
+ */
+export function createDepthCorrection(flipY: boolean): Projection { return _V(19, 2521, undefined, flipY) as Projection; }
+
+/**
+ * Creates a new {@link Projection} that projects positions into the given {@link Rect2}.
+ */
+export function createLightAtlasRect(rect: Rect2): Projection { return _V(19, 2547, undefined, rect) as Projection; }
+
+/**
+ * Creates a new {@link Projection} that projects positions using a perspective projection with the given Y-axis field of view (in degrees), X:Y aspect ratio, and clipping planes.
+ * `flipFov` determines whether the projection's field of view is flipped over its diagonal.
+ */
+export function createPerspective(fovy: number, aspect: number, zNear: number, zFar: number, flipFov?: boolean /* = false */): Projection { return _V(19, 2561, undefined, fovy, aspect, zNear, zFar, flipFov) as Projection; }
+
+/**
+ * Creates a new {@link Projection} that projects positions using a perspective projection with the given Y-axis field of view (in degrees), X:Y aspect ratio, and clipping distances. The projection is adjusted for a head-mounted display with the given distance between eyes and distance to a point that can be focused on.
+ * `eye` creates the projection for the left eye when set to 1, or the right eye when set to 2.
+ * `flipFov` determines whether the projection's field of view is flipped over its diagonal.
+ */
+export function createPerspectiveHmd(fovy: number, aspect: number, zNear: number, zFar: number, flipFov: boolean, eye: number, intraocularDist: number, convergenceDist: number): Projection { return _V(19, 2562, undefined, fovy, aspect, zNear, zFar, flipFov, eye, intraocularDist, convergenceDist) as Projection; }
+
+/**
+ * Creates a new {@link Projection} for projecting positions onto a head-mounted display with the given X:Y aspect ratio, distance between eyes, display width, distance to lens, oversampling factor, and depth clipping planes.
+ * `eye` creates the projection for the left eye when set to 1, or the right eye when set to 2.
+ */
+export function createForHmd(eye: number, aspect: number, intraocularDist: number, displayWidth: number, displayToLens: number, oversample: number, zNear: number, zFar: number): Projection { return _V(19, 2527, undefined, eye, aspect, intraocularDist, displayWidth, displayToLens, oversample, zNear, zFar) as Projection; }
+
+/**
+ * Creates a new {@link Projection} that projects positions using an orthogonal projection with the given clipping planes.
+ */
+export function createOrthogonal(left: number, right: number, bottom: number, top: number, zNear: number, zFar: number): Projection { return _V(19, 2557, undefined, left, right, bottom, top, zNear, zFar) as Projection; }
+
+/**
+ * Creates a new {@link Projection} that projects positions using an orthogonal projection with the given size, X:Y aspect ratio, and clipping planes.
+ * `flipFov` determines whether the projection's field of view is flipped over its diagonal.
+ */
+export function createOrthogonalAspect(size: number, aspect: number, zNear: number, zFar: number, flipFov?: boolean /* = false */): Projection { return _V(19, 2558, undefined, size, aspect, zNear, zFar, flipFov) as Projection; }
+
+/**
+ * Creates a new {@link Projection} that projects positions in a frustum with the given clipping planes.
+ */
+export function createFrustum(left: number, right: number, bottom: number, top: number, zNear: number, zFar: number): Projection { return _V(19, 2539, undefined, left, right, bottom, top, zNear, zFar) as Projection; }
+
+/**
+ * Creates a new {@link Projection} that projects positions in a frustum with the given size, X:Y aspect ratio, offset, and clipping planes.
+ * `flipFov` determines whether the projection's field of view is flipped over its diagonal.
+ */
+export function createFrustumAspect(size: number, aspect: number, offset: Vector2, zNear: number, zFar: number, flipFov?: boolean /* = false */): Projection { return _V(19, 2540, undefined, size, aspect, offset, zNear, zFar, flipFov) as Projection; }
+
+/**
+ * Creates a new {@link Projection} that scales a given projection to fit around a given {@link AABB} in projection space.
+ */
+export function createFitAabb(aabb: AABB): Projection { return _V(19, 2524, undefined, aabb) as Projection; }
+
+/**
+ * Returns a scalar value that is the signed factor by which areas are scaled by this matrix. If the sign is negative, the matrix flips the orientation of the area.
+ * The determinant can be used to calculate the invertibility of a matrix or solve linear systems of equations involving the matrix, among other applications.
+ */
+export function determinant(self: Projection): number { return _V(19, 2773, self) as number; }
+
+/**
+ * Returns a {@link Projection} with the near clipping distance adjusted to be `newZnear`.
+ * **Note:** The original {@link Projection} must be a perspective projection.
+ */
+export function perspectiveZnearAdjusted(self: Projection, newZnear: number): Projection { return _V(19, 9398, self, newZnear) as Projection; }
+
+/**
+ * Returns the clipping plane of this {@link Projection} whose index is given by `plane`.
+ * `plane` should be equal to one of {@link PLANE_NEAR}, {@link PLANE_FAR}, {@link PLANE_LEFT}, {@link PLANE_TOP}, {@link PLANE_RIGHT}, or {@link PLANE_BOTTOM}.
+ */
+export function getProjectionPlane(self: Projection, plane: number): Plane { return _V(19, 6046, self, plane) as Plane; }
+
+/**
+ * Returns a copy of this {@link Projection} with the signs of the values of the Y column flipped.
+ */
+export function flippedY(self: Projection): Projection { return _V(19, 3334, self) as Projection; }
+
+/**
+ * Returns a {@link Projection} with the X and Y values from the given {@link Vector2} added to the first and second values of the final column respectively.
+ */
+export function jitterOffseted(self: Projection, offset: Vector2): Projection { return _V(19, 8472, self, offset) as Projection; }
+
+/**
+ * Returns the vertical field of view of the projection (in degrees) associated with the given horizontal field of view (in degrees) and aspect ratio.
+ * **Note:** Unlike most methods of {@link Projection}, `aspect` is expected to be 1 divided by the X:Y aspect ratio.
+ */
+export function getFovy(fovx: number, aspect: number): number { return _V(19, 4870, undefined, fovx, aspect) as number; }
+
+/**
+ * Returns the distance for this {@link Projection} beyond which positions are clipped.
+ */
+export function getZFar(self: Projection): number { return _V(19, 7179, self) as number; }
+
+/**
+ * Returns the distance for this {@link Projection} before which positions are clipped.
+ */
+export function getZNear(self: Projection): number { return _V(19, 7181, self) as number; }
+
+/**
+ * Returns the X:Y aspect ratio of this {@link Projection}'s viewport.
+ */
+export function getAspect(self: Projection): number { return _V(19, 3800, self) as number; }
+
+/**
+ * Returns the horizontal field of view of the projection (in degrees).
+ */
+export function getFov(self: Projection): number { return _V(19, 4865, self) as number; }
+
+/**
+ * Returns `true` if this {@link Projection} performs an orthogonal projection.
+ */
+export function isOrthogonal(self: Projection): boolean { return _V(19, 8157, self) as boolean; }
+
+/**
+ * Returns the dimensions of the viewport plane that this {@link Projection} projects positions onto, divided by two.
+ */
+export function getViewportHalfExtents(self: Projection): Vector2 { return _V(19, 7082, self) as Vector2; }
+
+/**
+ * Returns the dimensions of the far clipping plane of the projection, divided by two.
+ */
+export function getFarPlaneHalfExtents(self: Projection): Vector2 { return _V(19, 4759, self) as Vector2; }
+
+/**
+ * Returns a {@link Projection} that performs the inverse of this {@link Projection}'s projective transformation.
+ */
+export function inverse(self: Projection): Projection { return _V(19, 7714, self) as Projection; }
+
+/**
+ * Returns `forPixelWidth` divided by the viewport's width measured in meters on the near plane, after this {@link Projection} is applied.
+ */
+export function getPixelsPerMeter(self: Projection, forPixelWidth: number): number { return _V(19, 5915, self, forPixelWidth) as number; }
+
+/**
+ * Returns the factor by which the visible level of detail is scaled by this {@link Projection}.
+ */
+export function getLodMultiplier(self: Projection): number { return _V(19, 5411, self) as number; }
+
+export function equals(a: Projection, b: Variant | Projection): boolean { return _V(19, -1, a, b) as boolean; }
+
+export function notEquals(a: Projection, b: Variant | Projection): boolean { return _V(19, -2, a, b) as boolean; }
+
+export function not(self: Projection): boolean { return _V(19, -24, self, undefined) as boolean; }
+
+/**
+ * Projects (multiplies) the given {@link Vector4} by this {@link Projection} matrix.
+ */
+export function mul(a: Projection, b: Vector4 | Projection): Vector4 { return _V(19, -9, a, b) as Vector4; }
+
+export function contains(a: Projection, b: GodotDictionary | GodotArray): boolean { return _V(19, -25, a, b) as boolean; }
+
+/**
+ * Constructs a default-initialized {@link Projection} identical to {@link IDENTITY}.
+ * **Note:** In C#, this constructs a {@link Projection} identical to {@link ZERO}.
+ */
+export function create(): Projection { return _V(19, -4096, 0) as Projection; }
+
+/**
+ * Constructs a {@link Projection} as a copy of the given {@link Projection}.
+ */
+export function fromProjection(from: Projection): Projection { return _V(19, -4096, 1, from) as Projection; }
+
+/**
+ * Constructs a Projection as a copy of the given {@link Transform3D}.
+ */
+export function fromTransform3D(from: Transform3D): Projection { return _V(19, -4096, 2, from) as Projection; }
+
+/**
+ * Constructs a Projection from four {@link Vector4} values (matrix columns).
+ */
+export function fromXAxisYAxisZAxisWAxis(xAxis: Vector4, yAxis: Vector4, zAxis: Vector4, wAxis: Vector4): Projection { return _V(19, -4096, 3, xAxis, yAxis, zAxis, wAxis) as Projection; }
+