@ringozz/godot 0.1.0

package/gen/classes/Geometry2D.ts

@@ -0,0 +1,249 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { GodotArray, GodotDictionary, PackedInt32Array, PackedVector2Array, Variant } from '../heap-types/index.ts';
+import type { Vector2, Vector2i } from '../value-types/index.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 310));
+
+/**
+ * Provides a set of helper functions to create geometric shapes, compute intersections between shapes, and process various other geometric operations in 2D.
+ */
+export class Geometry2D extends GodotVar {
+
+    /**
+     * Returns `true` if `point` is inside the circle or if it's located exactly *on* the circle's boundary, otherwise returns `false`.
+     */
+    static isPointInCircle(point: Vector2, circlePosition: Vector2, circleRadius: number): boolean { return _C($(), 8185, point, circlePosition, circleRadius) as boolean; }
+
+    /**
+     * Given the 2D segment (`segmentFrom`, `segmentTo`), returns the position on the segment (as a number between 0 and 1) at which the segment hits the circle that is located at position `circlePosition` and has radius `circleRadius`. If the segment does not intersect the circle, -1 is returned (this is also the case if the line extending the segment would intersect the circle, but the segment does not).
+     */
+    static segmentIntersectsCircle(segmentFrom: Vector2, segmentTo: Vector2, circlePosition: Vector2, circleRadius: number): number { return _C($(), 10345, segmentFrom, segmentTo, circlePosition, circleRadius) as number; }
+
+    /**
+     * Checks if two line segments intersect, with line `a` between `fromA` and `toA` and line `b` between `fromB` and `toB`. If the line segments intersect, the point of intersection is returned as a {@link Vector2}. If no intersection takes place, `null` is returned.
+     */
+    static segmentIntersectsSegment(fromA: Vector2, toA: Vector2, fromB: Vector2, toB: Vector2): Variant { return _C($(), 10348, fromA, toA, fromB, toB) as Variant; }
+
+    /**
+     * Returns the point of intersection between the two lines (`fromA`, `dirA`) and (`fromB`, `dirB`). Returns a {@link Vector2}, or `null` if the lines are parallel.
+     * `from` and `dir` are *not* endpoints of a line segment or ray but the slope (`dir`) and a known point (`from`) on that line. To get the intersection between two line segments, use {@link segmentIntersectsSegment}.
+     *
+     *
+     * ```gdscript
+     *
+     * var from_a = Vector2.ZERO
+     * var dir_a = Vector2.RIGHT
+     * var from_b = Vector2.DOWN
+     *
+     * # Returns Vector2(1, 0)
+     * Geometry2D.line_intersects_line(from_a, dir_a, from_b, Vector2(1, -1))
+     * # Returns Vector2(-1, 0)
+     * Geometry2D.line_intersects_line(from_a, dir_a, from_b, Vector2(-1, -1))
+     * # Returns null
+     * Geometry2D.line_intersects_line(from_a, dir_a, from_b, Vector2.RIGHT)
+     *
+     * ```
+     */
+    static lineIntersectsLine(fromA: Vector2, dirA: Vector2, fromB: Vector2, dirB: Vector2): Variant | null { return _C($(), 8620, fromA, dirA, fromB, dirB) as Variant | null; }
+
+    /**
+     * Given the two 2D segments (`p1`, `q1`) and (`p2`, `q2`), finds those two points on the two segments that are closest to each other. Returns a {@link PackedVector2Array} that contains this point on (`p1`, `q1`) as well the accompanying point on (`p2`, `q2`).
+     */
+    static getClosestPointsBetweenSegments(p1: Vector2, q1: Vector2, p2: Vector2, q2: Vector2): PackedVector2Array { return _C($(), 4177, p1, q1, p2, q2) as PackedVector2Array; }
+
+    /**
+     * Returns the 2D point on the 2D segment (`s1`, `s2`) that is closest to `point`. The returned point will always be inside the specified segment.
+     */
+    static getClosestPointToSegment(point: Vector2, s1: Vector2, s2: Vector2): Vector2 { return _C($(), 4175, point, s1, s2) as Vector2; }
+
+    /**
+     * Returns the 2D point on the 2D line defined by (`s1`, `s2`) that is closest to `point`. The returned point can be inside the segment (`s1`, `s2`) or outside of it, i.e. somewhere on the line extending from the segment.
+     */
+    static getClosestPointToSegmentUncapped(point: Vector2, s1: Vector2, s2: Vector2): Vector2 { return _C($(), 4176, point, s1, s2) as Vector2; }
+
+    /**
+     * Returns if `point` is inside the triangle specified by `a`, `b` and `c`.
+     */
+    static pointIsInsideTriangle(point: Vector2, a: Vector2, b: Vector2, c: Vector2): boolean { return _C($(), 9468, point, a, b, c) as boolean; }
+
+    /**
+     * Returns `true` if `polygon`'s vertices are ordered in clockwise order, otherwise returns `false`.
+     * **Note:** Assumes a Cartesian coordinate system where `+x` is right and `+y` is up. If using screen coordinates (`+y` is down), the result will need to be flipped (i.e. a `true` result will indicate counter-clockwise).
+     */
+    static isPolygonClockwise(polygon: PackedVector2Array): boolean { return _C($(), 8191, polygon) as boolean; }
+
+    /**
+     * Returns `true` if `point` is inside `polygon` or if it's located exactly *on* polygon's boundary, otherwise returns `false`.
+     */
+    static isPointInPolygon(point: Vector2, polygon: PackedVector2Array): boolean { return _C($(), 8186, point, polygon) as boolean; }
+
+    /**
+     * Triangulates the polygon specified by the points in `polygon`. Returns a {@link PackedInt32Array} where each triangle consists of three consecutive point indices into `polygon` (i.e. the returned array will have `n * 3` elements, with `n` being the number of found triangles). Output triangles will always be counter clockwise, and the contour will be flipped if it's clockwise. If the triangulation did not succeed, an empty {@link PackedInt32Array} is returned.
+     */
+    static triangulatePolygon(polygon: PackedVector2Array): PackedInt32Array { return _C($(), 14418, polygon) as PackedInt32Array; }
+
+    /**
+     * Triangulates the area specified by discrete set of `points` such that no point is inside the circumcircle of any resulting triangle. Returns a {@link PackedInt32Array} where each triangle consists of three consecutive point indices into `points` (i.e. the returned array will have `n * 3` elements, with `n` being the number of found triangles). If the triangulation did not succeed, an empty {@link PackedInt32Array} is returned.
+     */
+    static triangulateDelaunay(points: PackedVector2Array): PackedInt32Array { return _C($(), 14417, points) as PackedInt32Array; }
+
+    /**
+     * Given an array of {@link Vector2}s, returns the convex hull as a list of points in counterclockwise order. The last point is the same as the first one.
+     */
+    static convexHull(points: PackedVector2Array): PackedVector2Array { return _C($(), 2482, points) as PackedVector2Array; }
+
+    /**
+     * Decomposes the `polygon` into multiple convex hulls and returns an array of {@link PackedVector2Array}.
+     */
+    static decomposePolygonInConvex(polygon: PackedVector2Array): GodotArray<PackedVector2Array> { return _C($(), 2700, polygon) as GodotArray<PackedVector2Array>; }
+
+    /**
+     * Merges (combines) `polygonA` and `polygonB` and returns an array of merged polygons. This performs {@link OPERATION_UNION} between polygons.
+     * The operation may result in an outer polygon (boundary) and multiple inner polygons (holes) produced which could be distinguished by calling {@link isPolygonClockwise}.
+     */
+    static mergePolygons(polygonA: PackedVector2Array, polygonB: PackedVector2Array): GodotArray<PackedVector2Array> { return _C($(), 8854, polygonA, polygonB) as GodotArray<PackedVector2Array>; }
+
+    /**
+     * Clips `polygonA` against `polygonB` and returns an array of clipped polygons. This performs {@link OPERATION_DIFFERENCE} between polygons. Returns an empty array if `polygonB` completely overlaps `polygonA`.
+     * If `polygonB` is enclosed by `polygonA`, returns an outer polygon (boundary) and inner polygon (hole) which could be distinguished by calling {@link isPolygonClockwise}.
+     */
+    static clipPolygons(polygonA: PackedVector2Array, polygonB: PackedVector2Array): GodotArray<PackedVector2Array> { return _C($(), 2320, polygonA, polygonB) as GodotArray<PackedVector2Array>; }
+
+    /**
+     * Intersects `polygonA` with `polygonB` and returns an array of intersected polygons. This performs {@link OPERATION_INTERSECTION} between polygons. In other words, returns common area shared by polygons. Returns an empty array if no intersection occurs.
+     * The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling {@link isPolygonClockwise}.
+     */
+    static intersectPolygons(polygonA: PackedVector2Array, polygonB: PackedVector2Array): GodotArray<PackedVector2Array> { return _C($(), 7700, polygonA, polygonB) as GodotArray<PackedVector2Array>; }
+
+    /**
+     * Mutually excludes common area defined by intersection of `polygonA` and `polygonB` (see {@link intersectPolygons}) and returns an array of excluded polygons. This performs {@link OPERATION_XOR} between polygons. In other words, returns all but common area between polygons.
+     * The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling {@link isPolygonClockwise}.
+     */
+    static excludePolygons(polygonA: PackedVector2Array, polygonB: PackedVector2Array): GodotArray<PackedVector2Array> { return _C($(), 3177, polygonA, polygonB) as GodotArray<PackedVector2Array>; }
+
+    /**
+     * Clips `polyline` against `polygon` and returns an array of clipped polylines. This performs {@link OPERATION_DIFFERENCE} between the polyline and the polygon. This operation can be thought of as cutting a line with a closed shape.
+     */
+    static clipPolylineWithPolygon(polyline: PackedVector2Array, polygon: PackedVector2Array): GodotArray<PackedVector2Array> { return _C($(), 2321, polyline, polygon) as GodotArray<PackedVector2Array>; }
+
+    /**
+     * Intersects `polyline` with `polygon` and returns an array of intersected polylines. This performs {@link OPERATION_INTERSECTION} between the polyline and the polygon. This operation can be thought of as chopping a line with a closed shape.
+     */
+    static intersectPolylineWithPolygon(polyline: PackedVector2Array, polygon: PackedVector2Array): GodotArray<PackedVector2Array> { return _C($(), 7701, polyline, polygon) as GodotArray<PackedVector2Array>; }
+
+    /**
+     * Inflates or deflates `polygon` by `delta` units (pixels). If `delta` is positive, makes the polygon grow outward. If `delta` is negative, shrinks the polygon inward. Returns an array of polygons because inflating/deflating may result in multiple discrete polygons. Returns an empty array if `delta` is negative and the absolute value of it approximately exceeds the minimum bounding rectangle dimensions of the polygon.
+     * Each polygon's vertices will be rounded as determined by `joinType`.
+     * The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling {@link isPolygonClockwise}.
+     * **Note:** To translate the polygon's vertices specifically, multiply them to a {@link Transform2D}:
+     *
+     *
+     * ```gdscript
+     *
+     * var polygon = PackedVector2Array([Vector2(0, 0), Vector2(100, 0), Vector2(100, 100), Vector2(0, 100)])
+     * var offset = Vector2(50, 50)
+     * polygon = Transform2D(0, offset) * polygon
+     * print(polygon) # Prints [(50.0, 50.0), (150.0, 50.0), (150.0, 150.0), (50.0, 150.0)]
+     *
+     * ```
+     */
+    static offsetPolygon(polygon: PackedVector2Array, delta: number, joinType?: PolyJoinType /* = 0 */): GodotArray<PackedVector2Array> { return _C($(), 9157, polygon, delta, joinType) as GodotArray<PackedVector2Array>; }
+
+    /**
+     * Inflates or deflates `polyline` by `delta` units (pixels), producing polygons. If `delta` is positive, makes the polyline grow outward. Returns an array of polygons because inflating/deflating may result in multiple discrete polygons. If `delta` is negative, returns an empty array.
+     * Each polygon's vertices will be rounded as determined by `joinType`.
+     * Each polygon's endpoints will be rounded as determined by `endType`.
+     * The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling {@link isPolygonClockwise}.
+     */
+    static offsetPolyline(polyline: PackedVector2Array, delta: number, joinType?: PolyJoinType /* = 0 */, endType?: PolyEndType /* = 3 */): GodotArray<PackedVector2Array> { return _C($(), 9158, polyline, delta, joinType, endType) as GodotArray<PackedVector2Array>; }
+
+    /**
+     * Given an array of {@link Vector2}s representing tiles, builds an atlas. The returned dictionary has two keys: `points` is a {@link PackedVector2Array} that specifies the positions of each tile, `size` contains the overall size of the whole atlas as {@link Vector2i}.
+     */
+    static makeAtlas(sizes: PackedVector2Array): GodotDictionary { return _C($(), 8725, sizes) as GodotDictionary; }
+
+    /**
+     * Returns the [Bresenham line](https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm) between the `from` and `to` points. A Bresenham line is a series of pixels that draws a line and is always 1-pixel thick on every row and column of the drawing (never more, never less).
+     * Example code to draw a line between two {@link Marker2D} nodes using a series of {@link CanvasItem.drawRect} calls:
+     *
+     * ```text
+     *
+     * func _draw():
+     * 	for pixel in Geometry2D.bresenham_line($MarkerA.position, $MarkerB.position):
+     * 		draw_rect(Rect2(pixel, Vector2.ONE), Color.WHITE)
+     *
+     * ```
+     */
+    static bresenhamLine(from: Vector2i, to: Vector2i): GodotArray<Vector2i> { return _C($(), 1913, from, to) as GodotArray<Vector2i>; }
+
+    static readonly name = _R(310, Geometry2D);
+}
+
+export const PolyBooleanOperation = {
+    /**
+     * Create regions where either subject or clip polygons (or both) are filled.
+     */
+    OPERATION_UNION: 0,
+    /**
+     * Create regions where subject polygons are filled except where clip polygons are filled.
+     */
+    OPERATION_DIFFERENCE: 1,
+    /**
+     * Create regions where both subject and clip polygons are filled.
+     */
+    OPERATION_INTERSECTION: 2,
+    /**
+     * Create regions where either subject or clip polygons are filled but not where both are filled.
+     */
+    OPERATION_XOR: 3,
+} as const;
+
+export type PolyBooleanOperation = (typeof PolyBooleanOperation)[keyof typeof PolyBooleanOperation];
+
+export const PolyJoinType = {
+    /**
+     * Squaring is applied uniformally at all convex edge joins at `1 * delta`.
+     */
+    JOIN_SQUARE: 0,
+    /**
+     * While flattened paths can never perfectly trace an arc, they are approximated by a series of arc chords.
+     */
+    JOIN_ROUND: 1,
+    /**
+     * There's a necessary limit to mitered joins since offsetting edges that join at very acute angles will produce excessively long and narrow "spikes". For any given edge join, when miter offsetting would exceed that maximum distance, "square" joining is applied.
+     */
+    JOIN_MITER: 2,
+} as const;
+
+export type PolyJoinType = (typeof PolyJoinType)[keyof typeof PolyJoinType];
+
+export const PolyEndType = {
+    /**
+     * Endpoints are joined using the {@link PolyJoinType} value and the path filled as a polygon.
+     */
+    END_POLYGON: 0,
+    /**
+     * Endpoints are joined using the {@link PolyJoinType} value and the path filled as a polyline.
+     */
+    END_JOINED: 1,
+    /**
+     * Endpoints are squared off with no extension.
+     */
+    END_BUTT: 2,
+    /**
+     * Endpoints are squared off and extended by `delta` units.
+     */
+    END_SQUARE: 3,
+    /**
+     * Endpoints are rounded off and extended by `delta` units.
+     */
+    END_ROUND: 4,
+} as const;
+
+export type PolyEndType = (typeof PolyEndType)[keyof typeof PolyEndType];
+

package/gen/classes/Geometry3D.ts

@@ -0,0 +1,94 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { GodotArray, PackedInt32Array, PackedVector3Array, Variant } from '../heap-types/index.ts';
+import type { Plane, Vector3 } from '../value-types/index.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 311));
+
+/**
+ * Provides a set of helper functions to create geometric shapes, compute intersections between shapes, and process various other geometric operations in 3D.
+ */
+export class Geometry3D extends GodotVar {
+
+    /**
+     * Calculates and returns all the vertex points of a convex shape defined by an array of `planes`.
+     */
+    static computeConvexMeshPoints(planes: GodotArray<Plane>): PackedVector3Array { return _C($(), 2413, planes) as PackedVector3Array; }
+
+    /**
+     * Returns an array with 6 {@link Plane}s that describe the sides of a box centered at the origin. The box size is defined by `extents`, which represents one (positive) corner of the box (i.e. half its actual size).
+     */
+    static buildBoxPlanes(extents: Vector3): GodotArray<Plane> { return _C($(), 1932, extents) as GodotArray<Plane>; }
+
+    /**
+     * Returns an array of {@link Plane}s closely bounding a faceted cylinder centered at the origin with radius `radius` and height `height`. The parameter `sides` defines how many planes will be generated for the round part of the cylinder. The parameter `axis` describes the axis along which the cylinder is oriented (0 for X, 1 for Y, 2 for Z).
+     */
+    static buildCylinderPlanes(radius: number, height: number, sides: number, axis?: number /* = 2 */): GodotArray<Plane> { return _C($(), 1934, radius, height, sides, axis) as GodotArray<Plane>; }
+
+    /**
+     * Returns an array of {@link Plane}s closely bounding a faceted capsule centered at the origin with radius `radius` and height `height`. The parameter `sides` defines how many planes will be generated for the side part of the capsule, whereas `lats` gives the number of latitudinal steps at the bottom and top of the capsule. The parameter `axis` describes the axis along which the capsule is oriented (0 for X, 1 for Y, 2 for Z).
+     */
+    static buildCapsulePlanes(radius: number, height: number, sides: number, lats: number, axis?: number /* = 2 */): GodotArray<Plane> { return _C($(), 1933, radius, height, sides, lats, axis) as GodotArray<Plane>; }
+
+    /**
+     * Given the two 3D segments (`p1`, `p2`) and (`q1`, `q2`), finds those two points on the two segments that are closest to each other. Returns a {@link PackedVector3Array} that contains this point on (`p1`, `p2`) as well the accompanying point on (`q1`, `q2`).
+     */
+    static getClosestPointsBetweenSegments(p1: Vector3, p2: Vector3, q1: Vector3, q2: Vector3): PackedVector3Array { return _C($(), 4177, p1, p2, q1, q2) as PackedVector3Array; }
+
+    /**
+     * Returns the 3D point on the 3D segment (`s1`, `s2`) that is closest to `point`. The returned point will always be inside the specified segment.
+     */
+    static getClosestPointToSegment(point: Vector3, s1: Vector3, s2: Vector3): Vector3 { return _C($(), 4175, point, s1, s2) as Vector3; }
+
+    /**
+     * Returns the 3D point on the 3D line defined by (`s1`, `s2`) that is closest to `point`. The returned point can be inside the segment (`s1`, `s2`) or outside of it, i.e. somewhere on the line extending from the segment.
+     */
+    static getClosestPointToSegmentUncapped(point: Vector3, s1: Vector3, s2: Vector3): Vector3 { return _C($(), 4176, point, s1, s2) as Vector3; }
+
+    /**
+     * Returns a {@link Vector3} containing weights based on how close a 3D position (`point`) is to a triangle's different vertices (`a`, `b` and `c`). This is useful for interpolating between the data of different vertices in a triangle. One example use case is using this to smoothly rotate over a mesh instead of relying solely on face normals.
+     * [Here is a more detailed explanation of barycentric coordinates.](https://en.wikipedia.org/wiki/Barycentric_coordinate_system)
+     */
+    static getTriangleBarycentricCoords(point: Vector3, a: Vector3, b: Vector3, c: Vector3): Vector3 { return _C($(), 6909, point, a, b, c) as Vector3; }
+
+    /**
+     * Tests if the 3D ray starting at `from` with the direction of `dir` intersects the triangle specified by `a`, `b` and `c`. If yes, returns the point of intersection as {@link Vector3}. If no intersection takes place, returns `null`.
+     */
+    static rayIntersectsTriangle(from: Vector3, dir: Vector3, a: Vector3, b: Vector3, c: Vector3): Variant | null { return _C($(), 9743, from, dir, a, b, c) as Variant | null; }
+
+    /**
+     * Tests if the segment (`from`, `to`) intersects the triangle `a`, `b`, `c`. If yes, returns the point of intersection as {@link Vector3}. If no intersection takes place, returns `null`.
+     */
+    static segmentIntersectsTriangle(from: Vector3, to: Vector3, a: Vector3, b: Vector3, c: Vector3): Variant | null { return _C($(), 10350, from, to, a, b, c) as Variant | null; }
+
+    /**
+     * Checks if the segment (`from`, `to`) intersects the sphere that is located at `spherePosition` and has radius `sphereRadius`. If no, returns an empty {@link PackedVector3Array}. If yes, returns a {@link PackedVector3Array} containing the point of intersection and the sphere's normal at the point of intersection.
+     */
+    static segmentIntersectsSphere(from: Vector3, to: Vector3, spherePosition: Vector3, sphereRadius: number): PackedVector3Array { return _C($(), 10349, from, to, spherePosition, sphereRadius) as PackedVector3Array; }
+
+    /**
+     * Checks if the segment (`from`, `to`) intersects the cylinder with height `height` that is centered at the origin and has radius `radius`. If no, returns an empty {@link PackedVector3Array}. If an intersection takes place, the returned array contains the point of intersection and the cylinder's normal at the point of intersection.
+     */
+    static segmentIntersectsCylinder(from: Vector3, to: Vector3, height: number, radius: number): PackedVector3Array { return _C($(), 10347, from, to, height, radius) as PackedVector3Array; }
+
+    /**
+     * Given a convex hull defined though the {@link Plane}s in the array `planes`, tests if the segment (`from`, `to`) intersects with that hull. If an intersection is found, returns a {@link PackedVector3Array} containing the point the intersection and the hull's normal. Otherwise, returns an empty array.
+     */
+    static segmentIntersectsConvex(from: Vector3, to: Vector3, planes: GodotArray<Plane>): PackedVector3Array { return _C($(), 10346, from, to, planes) as PackedVector3Array; }
+
+    /**
+     * Clips the polygon defined by the points in `points` against the `plane` and returns the points of the clipped polygon.
+     */
+    static clipPolygon(points: PackedVector3Array, plane: Plane): PackedVector3Array { return _C($(), 2319, points, plane) as PackedVector3Array; }
+
+    /**
+     * Tetrahedralizes the volume specified by a discrete set of `points` in 3D space, ensuring that no point lies within the circumsphere of any resulting tetrahedron. The method returns a {@link PackedInt32Array} where each tetrahedron consists of four consecutive point indices into the `points` array (resulting in an array with `n * 4` elements, where `n` is the number of tetrahedra found). If the tetrahedralization is unsuccessful, an empty {@link PackedInt32Array} is returned.
+     */
+    static tetrahedralizeDelaunay(points: PackedVector3Array): PackedInt32Array { return _C($(), 14150, points) as PackedInt32Array; }
+
+    static readonly name = _R(311, Geometry3D);
+}

package/gen/classes/GeometryInstance3D.ts

@@ -0,0 +1,223 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualInstance3D } from './VisualInstance3D.ts';
+import type { StringName, Variant } from '../heap-types/index.ts';
+import type { AABB } from '../value-types/index.ts';
+import type { Material } from './Material.ts';
+
+/**
+ * Base node for geometry-based visual instances. Shares some common functionality like visibility and custom materials.
+ */
+export class GeometryInstance3D extends VisualInstance3D {
+    constructor(name = 312) { super(name); }
+
+    /**
+     * Set the value of a shader uniform for this instance only ([per-instance uniform]($DOCS_URL/tutorials/shaders/shader_reference/shading_language.html#per-instance-uniforms)). See also {@link ShaderMaterial.setShaderParameter} to assign a uniform on all instances using the same {@link ShaderMaterial}.
+     * **Note:** For a shader uniform to be assignable on a per-instance basis, it *must* be defined with `instance uniform ...` rather than `uniform ...` in the shader code.
+     * **Note:** `name` is case-sensitive and must match the name of the uniform in the code exactly (not the capitalized name in the inspector).
+     * **Note:** Per-instance shader uniforms are only available in Spatial and CanvasItem shaders, but not for Fog, Sky, or Particles shaders.
+     */
+    setInstanceShaderParameter(name: StringName, value: Variant): void { _C(this, 11729, name, value); }
+
+    /**
+     * Get the value of a shader parameter as set on this instance.
+     */
+    getInstanceShaderParameter(name: StringName): Variant { return _C(this, 5138, name) as Variant; }
+
+    /**
+     * The material override for the whole geometry.
+     * If a material is assigned to this property, it will be used instead of any material set in any material slot of the mesh.
+     */
+    get materialOverride(): Material { return _C(this, 5454) as Material; }
+    set materialOverride(v: Material) { _C(this, 11980, v); }
+
+    /**
+     * The material overlay for the whole geometry.
+     * If a material is assigned to this property, it will be rendered on top of any other active material for all the surfaces.
+     */
+    get materialOverlay(): Material { return _C(this, 5453) as Material; }
+    set materialOverlay(v: Material) { _C(this, 11979, v); }
+
+    /**
+     * The transparency applied to the whole geometry (as a multiplier of the materials' existing transparency). `0.0` is fully opaque, while `1.0` is fully transparent. Values greater than `0.0` (exclusive) will force the geometry's materials to go through the transparent pipeline, which is slower to render and can exhibit rendering issues due to incorrect transparency sorting. However, unlike using a transparent material, setting {@link transparency} to a value greater than `0.0` (exclusive) will *not* disable shadow rendering.
+     * In spatial shaders, `1.0 - transparency` is set as the default value of the `ALPHA` built-in.
+     * **Note:** {@link transparency} is clamped between `0.0` and `1.0`, so this property cannot be used to make transparent materials more opaque than they originally are.
+     * **Note:** Only supported when using the Forward+ rendering method. When using the Mobile or Compatibility rendering method, {@link transparency} is ignored and is considered as always being `0.0`.
+     */
+    get transparency(): number { return _C(this, 6899) as number; }
+    set transparency(v: number) { _C(this, 13148, v); }
+
+    /**
+     * The mode used to cast shadows from this instance.
+     */
+    get castShadow(): ShadowCastingSetting { return _C(this, 4096) as ShadowCastingSetting; }
+    set castShadow(v: ShadowCastingSetting) { _C(this, 10810, v); }
+
+    /**
+     * The extra distance added to the GeometryInstance3D's bounding box ({@link AABB}) to increase its cull box.
+     */
+    get extraCullMargin(): number { return _C(this, 4720) as number; }
+    set extraCullMargin(v: number) { _C(this, 11340, v); }
+
+    /**
+     * Overrides the bounding box of this node with a custom one. This can be used to avoid the expensive {@link AABB} recalculation that happens when a skeleton is used with a {@link MeshInstance3D} or to have precise control over the {@link MeshInstance3D}'s bounding box. To use the default AABB, set value to an {@link AABB} with all fields set to `0.0`. To avoid frustum culling, set {@link customAabb} to a very large AABB that covers your entire game world such as `AABB(-10000, -10000, -10000, 20000, 20000, 20000)`. To disable all forms of culling (including occlusion and layer culling), call {@link RenderingServer.instanceSetIgnoreCulling} on the {@link GeometryInstance3D}'s {@link RID}.
+     */
+    get customAabb(): AABB { return _C(this, 4375) as AABB; }
+    set customAabb(v: AABB) { _C(this, 10999, v); }
+
+    /**
+     * Changes how quickly the mesh transitions to a lower level of detail. A value of 0 will force the mesh to its lowest level of detail, a value of 1 will use the default settings, and larger values will keep the mesh in a higher level of detail at farther distances.
+     * Useful for testing level of detail transitions in the editor.
+     */
+    get lodBias(): number { return _C(this, 5410) as number; }
+    set lodBias(v: number) { _C(this, 11947, v); }
+
+    /**
+     * If `true`, disables occlusion culling for this instance. Useful for gizmos that must be rendered even when occlusion culling is in use.
+     * **Note:** {@link ignoreOcclusionCulling} does not affect frustum culling (which is what happens when an object is not visible given the camera's angle). To avoid frustum culling, set {@link customAabb} to a very large AABB that covers your entire game world such as `AABB(-10000, -10000, -10000, 20000, 20000, 20000)`.
+     */
+    get ignoreOcclusionCulling(): boolean { return _C(this, 8005) as boolean; }
+    set ignoreOcclusionCulling(v: boolean) { _C(this, 11665, v); }
+
+    /**
+     * The global illumination mode to use for the whole geometry. To avoid inconsistent results, use a mode that matches the purpose of the mesh during gameplay (static/dynamic).
+     * **Note:** Lights' bake mode will also affect the global illumination rendering. See {@link Light3D.lightBakeMode}.
+     */
+    get giMode(): GIMode { return _C(this, 4919) as GIMode; }
+    set giMode(v: GIMode) { _C(this, 11511, v); }
+
+    /**
+     * The texel density to use for lightmapping in {@link LightmapGI}. Greater scale values provide higher resolution in the lightmap, which can result in sharper shadows for lights that have both direct and indirect light baked. However, greater scale values will also increase the space taken by the mesh in the lightmap texture, which increases the memory, storage, and bake time requirements. When using a single mesh at different scales, consider adjusting this value to keep the lightmap texel density consistent across meshes.
+     * For example, doubling {@link giLightmapTexelScale} doubles the lightmap texture resolution for this object *on each axis*, so it will *quadruple* the texel count.
+     */
+    get giLightmapTexelScale(): number { return _C(this, 5345) as number; }
+    set giLightmapTexelScale(v: number) { _C(this, 11902, v); }
+
+    /**
+     * The texel density to use for lightmapping in {@link LightmapGI}.
+     */
+    get giLightmapScale(): LightmapScale { return _C(this, 5343) as LightmapScale; }
+    set giLightmapScale(v: LightmapScale) { _C(this, 11900, v); }
+
+    /**
+     * Starting distance from which the GeometryInstance3D will be visible, taking {@link visibilityRangeBeginMargin} into account as well. The default value of 0 is used to disable the range check.
+     */
+    get visibilityRangeBegin(): number { return _C(this, 7095) as number; }
+    set visibilityRangeBegin(v: number) { _C(this, 13324, v); }
+
+    /**
+     * Margin for the {@link visibilityRangeBegin} threshold. The GeometryInstance3D will only change its visibility state when it goes over or under the {@link visibilityRangeBegin} threshold by this amount.
+     * If {@link visibilityRangeFadeMode} is {@link VISIBILITY_RANGE_FADE_DISABLED}, this acts as a hysteresis distance. If {@link visibilityRangeFadeMode} is {@link VISIBILITY_RANGE_FADE_SELF} or {@link VISIBILITY_RANGE_FADE_DEPENDENCIES}, this acts as a fade transition distance and must be set to a value greater than `0.0` for the effect to be noticeable.
+     */
+    get visibilityRangeBeginMargin(): number { return _C(this, 7096) as number; }
+    set visibilityRangeBeginMargin(v: number) { _C(this, 13325, v); }
+
+    /**
+     * Distance from which the GeometryInstance3D will be hidden, taking {@link visibilityRangeEndMargin} into account as well. The default value of 0 is used to disable the range check.
+     */
+    get visibilityRangeEnd(): number { return _C(this, 7097) as number; }
+    set visibilityRangeEnd(v: number) { _C(this, 13326, v); }
+
+    /**
+     * Margin for the {@link visibilityRangeEnd} threshold. The GeometryInstance3D will only change its visibility state when it goes over or under the {@link visibilityRangeEnd} threshold by this amount.
+     * If {@link visibilityRangeFadeMode} is {@link VISIBILITY_RANGE_FADE_DISABLED}, this acts as a hysteresis distance. If {@link visibilityRangeFadeMode} is {@link VISIBILITY_RANGE_FADE_SELF} or {@link VISIBILITY_RANGE_FADE_DEPENDENCIES}, this acts as a fade transition distance and must be set to a value greater than `0.0` for the effect to be noticeable.
+     */
+    get visibilityRangeEndMargin(): number { return _C(this, 7098) as number; }
+    set visibilityRangeEndMargin(v: number) { _C(this, 13327, v); }
+
+    /**
+     * Controls which instances will be faded when approaching the limits of the visibility range.
+     */
+    get visibilityRangeFadeMode(): VisibilityRangeFadeMode { return _C(this, 7099) as VisibilityRangeFadeMode; }
+    set visibilityRangeFadeMode(v: VisibilityRangeFadeMode) { _C(this, 13328, v); }
+
+    static readonly name = _R(312, GeometryInstance3D);
+}
+
+export const ShadowCastingSetting = {
+    /**
+     * Will not cast any shadows. Use this to improve performance for small geometry that is unlikely to cast noticeable shadows (such as debris).
+     */
+    SHADOW_CASTING_SETTING_OFF: 0,
+    /**
+     * Will cast shadows from all visible faces in the GeometryInstance3D.
+     * Will take culling into account, so faces not being rendered will not be taken into account when shadow casting.
+     */
+    SHADOW_CASTING_SETTING_ON: 1,
+    /**
+     * Will cast shadows from all visible faces in the GeometryInstance3D.
+     * Will not take culling into account, so all faces will be taken into account when shadow casting.
+     */
+    SHADOW_CASTING_SETTING_DOUBLE_SIDED: 2,
+    /**
+     * Will only show the shadows casted from this object.
+     * In other words, the actual mesh will not be visible, only the shadows casted from the mesh will be.
+     */
+    SHADOW_CASTING_SETTING_SHADOWS_ONLY: 3,
+} as const;
+
+export type ShadowCastingSetting = (typeof ShadowCastingSetting)[keyof typeof ShadowCastingSetting];
+
+export const GIMode = {
+    /**
+     * Disabled global illumination mode. Use for dynamic objects that do not contribute to global illumination (such as characters). When using {@link VoxelGI} and SDFGI, the geometry will *receive* indirect lighting and reflections but the geometry will not be considered in GI baking.
+     */
+    GI_MODE_DISABLED: 0,
+    /**
+     * Baked global illumination mode. Use for static objects that contribute to global illumination (such as level geometry). This GI mode is effective when using {@link VoxelGI}, SDFGI and {@link LightmapGI}.
+     */
+    GI_MODE_STATIC: 1,
+    /**
+     * Dynamic global illumination mode. Use for dynamic objects that contribute to global illumination. This GI mode is only effective when using {@link VoxelGI}, but it has a higher performance impact than {@link GI_MODE_STATIC}. When using other GI methods, this will act the same as {@link GI_MODE_DISABLED}. When using {@link LightmapGI}, the object will receive indirect lighting using lightmap probes instead of using the baked lightmap texture.
+     */
+    GI_MODE_DYNAMIC: 2,
+} as const;
+
+export type GIMode = (typeof GIMode)[keyof typeof GIMode];
+
+export const LightmapScale = {
+    /**
+     * The standard texel density for lightmapping with {@link LightmapGI}.
+     */
+    LIGHTMAP_SCALE_1X: 0,
+    /**
+     * Multiplies texel density by 2× for lightmapping with {@link LightmapGI}. To ensure consistency in texel density, use this when scaling a mesh by a factor between 1.5 and 3.0.
+     */
+    LIGHTMAP_SCALE_2X: 1,
+    /**
+     * Multiplies texel density by 4× for lightmapping with {@link LightmapGI}. To ensure consistency in texel density, use this when scaling a mesh by a factor between 3.0 and 6.0.
+     */
+    LIGHTMAP_SCALE_4X: 2,
+    /**
+     * Multiplies texel density by 8× for lightmapping with {@link LightmapGI}. To ensure consistency in texel density, use this when scaling a mesh by a factor greater than 6.0.
+     */
+    LIGHTMAP_SCALE_8X: 3,
+    /**
+     * Represents the size of the {@link LightmapScale} enum.
+     */
+    LIGHTMAP_SCALE_MAX: 4,
+} as const;
+
+export type LightmapScale = (typeof LightmapScale)[keyof typeof LightmapScale];
+
+export const VisibilityRangeFadeMode = {
+    /**
+     * Will not fade itself nor its visibility dependencies, hysteresis will be used instead. This is the fastest approach to manual LOD, but it can result in noticeable LOD transitions depending on how the LOD meshes are authored. See {@link visibilityRangeBegin} and {@link Node3D.visibilityParent} for more information.
+     */
+    VISIBILITY_RANGE_FADE_DISABLED: 0,
+    /**
+     * Will fade-out itself when reaching the limits of its own visibility range. This is slower than {@link VISIBILITY_RANGE_FADE_DISABLED}, but it can provide smoother transitions. The fading range is determined by {@link visibilityRangeBeginMargin} and {@link visibilityRangeEndMargin}.
+     * **Note:** Only supported when using the Forward+ rendering method. When using the Mobile or Compatibility rendering method, this mode acts like {@link VISIBILITY_RANGE_FADE_DISABLED} but with hysteresis disabled.
+     */
+    VISIBILITY_RANGE_FADE_SELF: 1,
+    /**
+     * Will fade-in its visibility dependencies (see {@link Node3D.visibilityParent}) when reaching the limits of its own visibility range. This is slower than {@link VISIBILITY_RANGE_FADE_DISABLED}, but it can provide smoother transitions. The fading range is determined by {@link visibilityRangeBeginMargin} and {@link visibilityRangeEndMargin}.
+     * **Note:** Only supported when using the Forward+ rendering method. When using the Mobile or Compatibility rendering method, this mode acts like {@link VISIBILITY_RANGE_FADE_DISABLED} but with hysteresis disabled.
+     */
+    VISIBILITY_RANGE_FADE_DEPENDENCIES: 2,
+} as const;
+
+export type VisibilityRangeFadeMode = (typeof VisibilityRangeFadeMode)[keyof typeof VisibilityRangeFadeMode];
+

package/gen/classes/GodotInstance.ts

@@ -0,0 +1,48 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+
+/**
+ * GodotInstance represents a running Godot instance that is controlled from an outside codebase, without a perpetual main loop. It is created by the C API `libgodot_create_godot_instance`. Only one may be created per process.
+ */
+export class GodotInstance extends Object {
+
+    /**
+     * Finishes this instance's startup sequence. Returns `true` on success.
+     */
+    start(): boolean { return _C(this, 13829) as boolean; }
+
+    /**
+     * Returns `true` if this instance has been fully started.
+     */
+    isStarted(): boolean { return _C(this, 8337) as boolean; }
+
+    /**
+     * Runs a single iteration of the main loop. Returns `true` if the engine is attempting to quit.
+     */
+    iteration(): boolean { return _C(this, 8470) as boolean; }
+
+    /**
+     * Notifies the instance that it is now in focus.
+     */
+    focusIn(): void { _C(this, 3349); }
+
+    /**
+     * Notifies the instance that it is now not in focus.
+     */
+    focusOut(): void { _C(this, 3356); }
+
+    /**
+     * Notifies the instance that it is going to be paused.
+     */
+    pause(): void { _C(this, 9383); }
+
+    /**
+     * Notifies the instance that it is being resumed.
+     */
+    resume(): void { _C(this, 10099); }
+
+    static readonly name = _R(313, GodotInstance);
+}