@ringozz/godot 0.1.0

package/gen/value-types/Color.ts

@@ -0,0 +1,282 @@
+// 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 type { GodotArray, GodotDictionary, PackedColorArray, Variant } from '../heap-types/index.ts';
+
+/**
+ * A color represented in RGBA format by a red ({@link r}), green ({@link g}), blue ({@link b}), and alpha ({@link a}) component. Each component is a 32-bit floating-point value, usually ranging from `0.0` to `1.0`. Some properties (such as {@link CanvasItem.modulate}) may support values greater than `1.0`, for overbright or HDR (High Dynamic Range) colors.
+ * Colors can be created in a number of ways: By the various {@link Color} constructors, by static methods such as {@link fromHsv}, and by using a name from the set of standardized colors based on [X11 color names](https://en.wikipedia.org/wiki/X11_color_names) with the addition of {@link TRANSPARENT}.
+ * [Color constants cheatsheet](https://raw.githubusercontent.com/godotengine/godot-docs/master/img/color_constants.png)
+ * Although {@link Color} may be used to store values of any encoding, the red ({@link r}), green ({@link g}), and blue ({@link b}) properties of {@link Color} are expected by Godot to be encoded using the [nonlinear sRGB transfer function](https://en.wikipedia.org/wiki/SRGB#Transfer_function_(%22gamma%22)) unless otherwise stated. This color encoding is used by many traditional art and web tools, making it easy to match colors between Godot and these tools. Godot uses [Rec. ITU-R BT.709](https://en.wikipedia.org/wiki/Rec._709) color primaries, which are used by the sRGB standard.
+ * All physical simulation, such as lighting calculations, and colorimetry transformations, such as {@link getLuminance}, must be performed on linearly encoded values to produce correct results. When performing these calculations, convert {@link Color} to and from linear encoding using {@link srgbToLinear} and {@link linearToSrgb}.
+ * **Note:** In a boolean context, a Color will evaluate to `false` if it is equal to `Color(0, 0, 0, 1)` (opaque black). Otherwise, a Color will always evaluate to `true`.
+ * **Note:** In C#, color constants are defined in the `Colors` static class instead of {@link code skip-lint}Color. Additionally, named colors use `PascalCase` syntax instead of `UPPER_SNAKE_CASE`. For example, {@link code skip-lint}Color.ALICE_BLUE in GDScript is {@link code skip-lint}Colors.AliceBlue in C#.
+ */
+export class Color extends GodotVar {
+    /**
+     * The color's red component, typically on the range of 0 to 1.
+     */
+    get r(): number { return _get(this, 9700) as number; }
+    set r(v: number) { _set(this, 9700, v); }
+
+    /**
+     * The color's green component, typically on the range of 0 to 1.
+     */
+    get g(): number { return _get(this, 3624) as number; }
+    set g(v: number) { _set(this, 3624, v); }
+
+    /**
+     * The color's blue component, typically on the range of 0 to 1.
+     */
+    get b(): number { return _get(this, 1686) as number; }
+    set b(v: number) { _set(this, 1686, v); }
+
+    /**
+     * The color's alpha component, typically on the range of 0 to 1. A value of 0 means that the color is fully transparent. A value of 1 means that the color is fully opaque.
+     * **Note:** The alpha channel is always stored with linear encoding, regardless of the encoding of the other color channels. The {@link linearToSrgb} and {@link srgbToLinear} methods do not affect the alpha channel.
+     */
+    get a(): number { return _get(this, 1048) as number; }
+    set a(v: number) { _set(this, 1048, v); }
+
+    constructor();
+    constructor(from: Color);
+    constructor(from: Color, alpha: number);
+    constructor(r: number, g: number, b: number);
+    constructor(r: number, g: number, b: number, a: number);
+    constructor(code: string);
+    constructor(code: string, alpha: number);
+    constructor(...args: any[]) { super(20, ...args); }
+
+    /**
+     * Returns the color converted to a 32-bit integer in ARGB format (each component is 8 bits). ARGB is more compatible with DirectX.
+     *
+     *
+     * ```gdscript
+     *
+     * var color = Color(1, 0.5, 0.2)
+     * print(color.to_argb32()) # Prints 4294934323
+     *
+     * ```
+     */
+    toArgb32(): number { return _C(this, 14286) as number; }
+
+    /**
+     * Returns the color converted to a 32-bit integer in ABGR format (each component is 8 bits). ABGR is the reversed version of the default RGBA format.
+     *
+     *
+     * ```gdscript
+     *
+     * var color = Color(1, 0.5, 0.2)
+     * print(color.to_abgr32()) # Prints 4281565439
+     *
+     * ```
+     */
+    toAbgr32(): number { return _C(this, 14284) as number; }
+
+    /**
+     * Returns the color converted to a 32-bit integer in RGBA format (each component is 8 bits). RGBA is Godot's default format. This method is the inverse of {@link hex}.
+     *
+     *
+     * ```gdscript
+     *
+     * var color = Color(1, 0.5, 0.2)
+     * print(color.to_rgba32()) # Prints 4286526463
+     *
+     * ```
+     */
+    toRgba32(): number { return _C(this, 14309) as number; }
+
+    /**
+     * Returns the color converted to a 64-bit integer in ARGB format (each component is 16 bits). ARGB is more compatible with DirectX.
+     *
+     *
+     * ```gdscript
+     *
+     * var color = Color(1, 0.5, 0.2)
+     * print(color.to_argb64()) # Prints -2147470541
+     *
+     * ```
+     */
+    toArgb64(): number { return _C(this, 14287) as number; }
+
+    /**
+     * Returns the color converted to a 64-bit integer in ABGR format (each component is 16 bits). ABGR is the reversed version of the default RGBA format.
+     *
+     *
+     * ```gdscript
+     *
+     * var color = Color(1, 0.5, 0.2)
+     * print(color.to_abgr64()) # Prints -225178692812801
+     *
+     * ```
+     */
+    toAbgr64(): number { return _C(this, 14285) as number; }
+
+    /**
+     * Returns the color converted to a 64-bit integer in RGBA format (each component is 16 bits). RGBA is Godot's default format. This method is the inverse of {@link hex64}.
+     *
+     *
+     * ```gdscript
+     *
+     * var color = Color(1, 0.5, 0.2)
+     * print(color.to_rgba64()) # Prints -140736629309441
+     *
+     * ```
+     */
+    toRgba64(): number { return _C(this, 14310) as number; }
+
+    /**
+     * Returns the color converted to an HTML hexadecimal color {@link String} in RGBA format, without the hash (`#`) prefix.
+     * Setting `withAlpha` to `false`, excludes alpha from the hexadecimal string, using RGB format instead of RGBA format.
+     *
+     *
+     * ```gdscript
+     *
+     * var white = Color(1, 1, 1, 0.5)
+     * var with_alpha = white.to_html() # Returns "ffffff7f"
+     * var without_alpha = white.to_html(false) # Returns "ffffff"
+     *
+     * ```
+     */
+    toHtml(withAlpha?: boolean /* = true */): string { return _C(this, 14297, withAlpha) as string; }
+
+    /**
+     * Returns a new color with all components clamped between the components of `min` and `max`, by running {@link clamp} on each component.
+     */
+    clamp(min?: Color /* = Color(0, 0, 0, 0) */, max?: Color /* = Color(1, 1, 1, 1) */): Color { return _C(this, 2202, min, max) as Color; }
+
+    /**
+     * Returns the color with its {@link r}, {@link g}, and {@link b} components inverted (`(1 - r, 1 - g, 1 - b, a)`).
+     *
+     *
+     * ```gdscript
+     *
+     * var black = Color.WHITE.inverted()
+     * var color = Color(0.3, 0.4, 0.9)
+     * var inverted_color = color.inverted() # Equivalent to `Color(0.7, 0.6, 0.1)`
+     *
+     * ```
+     */
+    inverted(): Color { return _C(this, 7723) as Color; }
+
+    /**
+     * Returns the linear interpolation between this color's components and `to`'s components. The interpolation factor `weight` should be between 0.0 and 1.0 (inclusive). See also {@link lerp}.
+     *
+     *
+     * ```gdscript
+     *
+     * var red = Color(1.0, 0.0, 0.0)
+     * var aqua = Color(0.0, 1.0, 0.8)
+     *
+     * red.lerp(aqua, 0.2) # Returns Color(0.8, 0.2, 0.16)
+     * red.lerp(aqua, 0.5) # Returns Color(0.5, 0.5, 0.4)
+     * red.lerp(aqua, 1.0) # Returns Color(0.0, 1.0, 0.8)
+     *
+     * ```
+     */
+    lerp(to: Color, weight: number): Color { return _C(this, 8548, to, weight) as Color; }
+
+    /**
+     * Returns a new color resulting from making this color lighter by the specified `amount`, which should be a ratio from 0.0 to 1.0. See also {@link darkened}.
+     *
+     *
+     * ```gdscript
+     *
+     * var green = Color(0.0, 1.0, 0.0)
+     * var light_green = green.lightened(0.2) # 20% lighter than regular green
+     *
+     * ```
+     */
+    lightened(amount: number): Color { return _C(this, 8592, amount) as Color; }
+
+    /**
+     * Returns a new color resulting from making this color darker by the specified `amount` (ratio from 0.0 to 1.0). See also {@link lightened}.
+     *
+     *
+     * ```gdscript
+     *
+     * var green = Color(0.0, 1.0, 0.0)
+     * var darkgreen = green.darkened(0.2) # 20% darker than regular green
+     *
+     * ```
+     */
+    darkened(amount: number): Color { return _C(this, 2651, amount) as Color; }
+
+    /**
+     * Returns a new color resulting from overlaying this color over the given color. In a painting program, you can imagine it as the `over` color painted over this color (including alpha).
+     *
+     *
+     * ```gdscript
+     *
+     * var bg = Color(0.0, 1.0, 0.0, 0.5) # Green with alpha of 50%
+     * var fg = Color(1.0, 0.0, 0.0, 0.5) # Red with alpha of 50%
+     * var blended_color = bg.blend(fg) # Brown with alpha of 75%
+     *
+     * ```
+     */
+    blend(over: Color): Color { return _C(this, 1787, over) as Color; }
+
+    /**
+     * Returns the light intensity of the color, as a value between 0.0 and 1.0 (inclusive). This is useful when determining light or dark color. Colors with a luminance smaller than 0.5 can be generally considered dark.
+     * **Note:** {@link getLuminance} relies on the color using linear encoding to return an accurate relative luminance value. If the color uses the default nonlinear sRGB encoding, use {@link srgbToLinear} to convert it to linear encoding first.
+     */
+    getLuminance(): number { return _C(this, 5427) as number; }
+
+    /**
+     * Returns a copy of the color that uses linear encoding. This method requires the original color to be encoded using the [nonlinear sRGB transfer function](https://en.wikipedia.org/wiki/SRGB). See also {@link linearToSrgb} which performs the opposite operation.
+     * **Note:** The color's alpha channel ({@link a}) is not affected. The alpha channel is always stored with linear encoding, regardless of the color space of the other color channels.
+     */
+    srgbToLinear(): Color { return _C(this, 13806) as Color; }
+
+    /**
+     * Returns a copy of the color that is encoded using the [nonlinear sRGB transfer function](https://en.wikipedia.org/wiki/SRGB). This method requires the original color to use linear encoding. See also {@link srgbToLinear} which performs the opposite operation.
+     * **Note:** The color's alpha channel ({@link a}) is not affected. The alpha channel is always stored with linear encoding, regardless of the color space of the other color channels.
+     */
+    linearToSrgb(): Color { return _C(this, 8634) as Color; }
+
+    /**
+     * Returns `true` if this color and `to` are approximately equal, by running {@link isEqualApprox} on each component.
+     */
+    isEqualApprox(to: Color): boolean { return _C(this, 7938, to) as boolean; }
+
+    equals(other: Variant | Color): boolean { return _C(this, -1, other) as boolean; }
+
+    notEquals(other: Variant | Color): boolean { return _C(this, -2, other) as boolean; }
+
+    /**
+     * Inverts the given color. This is equivalent to `Color.WHITE - c` or `Color(1 - c.r, 1 - c.g, 1 - c.b, 1 - c.a)`. Unlike with {@link inverted}, the {@link a} component is inverted, too.
+     */
+    neg(): Color { return _C(this, -11, undefined) as Color; }
+
+    /**
+     * Returns the same value as if the `+` was not there. Unary `+` does nothing, but sometimes it can make your code more readable.
+     */
+    pos(): Color { return _C(this, -12, undefined) as Color; }
+
+    not(): boolean { return _C(this, -24, undefined) as boolean; }
+
+    /**
+     * Multiplies each component of the {@link Color} by the given {@link int}.
+     */
+    mul(other: number | Color): Color { return _C(this, -9, other) as Color; }
+
+    /**
+     * Divides each component of the {@link Color} by the given {@link int}.
+     */
+    div(other: number | Color): Color { return _C(this, -10, other) as Color; }
+
+    /**
+     * Adds each component of the {@link Color} with the components of the given {@link Color}.
+     */
+    add(other: Color): Color { return _C(this, -7, other) as Color; }
+
+    /**
+     * Subtracts each component of the {@link Color} by the components of the given {@link Color}.
+     */
+    sub(other: Color): Color { return _C(this, -8, other) as Color; }
+
+    contains(other: GodotDictionary | GodotArray | PackedColorArray): boolean { return _C(this, -25, other) as boolean; }
+
+    static readonly name = _R(20, Color);
+}

package/gen/value-types/Plane.ts

@@ -0,0 +1,134 @@
+// 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 type { GodotArray, GodotDictionary, Variant } from '../heap-types/index.ts';
+import type { Transform3D, Vector3 } from '../value-types/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);
+}

package/gen/value-types/Projection.ts

@@ -0,0 +1,137 @@
+// 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 type { GodotArray, GodotDictionary, Variant } from '../heap-types/index.ts';
+import type { Plane, Transform3D, Vector2, Vector4 } from '../value-types/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.
+ * For purely linear transformations (translation, rotation, and scale), it is recommended to use {@link Transform3D}, as it is more performant and requires less memory.
+ * 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);
+}