@ringozz/godot 0.1.0

package/gen/classes/DirAccess.ts

@@ -0,0 +1,300 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { Error } from '../global-enums.ts';
+import type { PackedStringArray } from '../heap-types/index.ts';
+
+/**
+ * This class is used to manage directories and their content, even outside of the project folder.
+ * {@link DirAccess} can't be instantiated directly. Instead it is created with a static method that takes a path for which it will be opened.
+ * Most of the methods have a static alternative that can be used without creating a {@link DirAccess}. Static methods only support absolute paths (including `res://` and `user://`).
+ *
+ * ```text
+ *
+ * # Standard
+ * var dir = DirAccess.open("user://levels")
+ * dir.make_dir("world1")
+ * # Static
+ * DirAccess.make_dir_absolute("user://levels/world1")
+ *
+ * ```
+ *
+ * **Note:** Accessing project ("res://") directories once exported may behave unexpectedly as some files are converted to engine-specific formats and their original source files may not be present in the expected PCK package. Because of this, to access resources in an exported project, it is recommended to use {@link ResourceLoader} instead of {@link FileAccess}.
+ * Here is an example on how to iterate through the files of a directory:
+ *
+ *
+ * ```gdscript
+ *
+ * func dir_contents(path):
+ * 	var dir = DirAccess.open(path)
+ * 	if dir:
+ * 		dir.list_dir_begin()
+ * 		var file_name = dir.get_next()
+ * 		while file_name != "":
+ * 			if dir.current_is_dir():
+ * 				print("Found directory: " + file_name)
+ * 			else:
+ * 				print("Found file: " + file_name)
+ * 			file_name = dir.get_next()
+ * 	else:
+ * 		print("An error occurred when trying to access the path.")
+ *
+ * ```
+ *
+ *
+ *
+ * Keep in mind that file names may change or be remapped after export. If you want to see the actual resource file list as it appears in the editor, use {@link ResourceLoader.listDirectory} instead.
+ */
+export class DirAccess extends RefCounted {
+
+    /**
+     * Creates a new {@link DirAccess} object and opens an existing directory of the filesystem. The `path` argument can be within the project tree (`res://folder`), the user directory (`user://folder`) or an absolute path of the user filesystem (e.g. `/tmp/folder` or `C:\tmp\folder`).
+     * Returns `null` if opening the directory failed. You can use {@link getOpenError} to check the error that occurred.
+     */
+    static open(path: string): DirAccess | null { return _C(246, 9189, path) as DirAccess | null; }
+
+    /**
+     * Returns the result of the last {@link open} call in the current thread.
+     */
+    static getOpenError(): Error { return _C(246, 5722) as Error; }
+
+    /**
+     * Creates a temporary directory. This directory will be freed when the returned {@link DirAccess} is freed.
+     * If `prefix` is not empty, it will be prefixed to the directory name, separated by a `-`.
+     * If `keep` is `true`, the directory is not deleted when the returned {@link DirAccess} is freed.
+     * Returns `null` if opening the directory failed. You can use {@link getOpenError} to check the error that occurred.
+     */
+    static createTemp(prefix?: string /* = "" */, keep?: boolean /* = false */): DirAccess | null { return _C(246, 2576, prefix, keep) as DirAccess | null; }
+
+    /**
+     * Initializes the stream used to list all files and directories using the {@link getNext} function, closing the currently opened stream if needed. Once the stream has been processed, it should typically be closed with {@link listDirEnd}.
+     * Affected by {@link includeHidden} and {@link includeNavigational}.
+     * **Note:** The order of files and directories returned by this method is not deterministic, and can vary between operating systems. If you want a list of all files or folders sorted alphabetically, use {@link getFiles} or {@link getDirectories}.
+     */
+    listDirBegin(): Error { return _C(this, 8661) as Error; }
+
+    /**
+     * Returns the next element (file or directory) in the current directory.
+     * The name of the file or directory is returned (and not its full path). Once the stream has been fully processed, the method returns an empty {@link String} and closes the stream automatically (i.e. {@link listDirEnd} would not be mandatory in such a case).
+     */
+    getNext(): string { return _C(this, 5622) as string; }
+
+    /**
+     * Returns whether the current item processed with the last {@link getNext} call is a directory (`.` and `..` are considered directories).
+     */
+    currentIsDir(): boolean { return _C(this, 2604) as boolean; }
+
+    /**
+     * Closes the current stream opened with {@link listDirBegin} (whether it has been fully processed with {@link getNext} does not matter).
+     */
+    listDirEnd(): void { _C(this, 8662); }
+
+    /**
+     * Returns a {@link PackedStringArray} containing filenames of the directory contents, excluding directories. The array is sorted alphabetically.
+     * Affected by {@link includeHidden}.
+     * **Note:** When used on a `res://` path in an exported project, only the files actually included in the PCK at the given folder level are returned. In practice, this means that since imported resources are stored in a top-level `.godot/` folder, only paths to `*.gd` and `*.import` files are returned (plus a few files such as `project.godot` or `project.binary` and the project icon). In an exported project, the list of returned files will also vary depending on whether {@link ProjectSettings.editor/export/convertTextResourcesToBinary} is `true`.
+     */
+    getFiles(): PackedStringArray { return _C(this, 4776) as PackedStringArray; }
+
+    /**
+     * Returns a {@link PackedStringArray} containing filenames of the directory contents, excluding directories, at the given `path`. The array is sorted alphabetically.
+     * Use {@link getFiles} if you want more control of what gets included.
+     * **Note:** When used on a `res://` path in an exported project, only the files included in the PCK at the given folder level are returned. In practice, this means that since imported resources are stored in a top-level `.godot/` folder, only paths to `.gd` and `.import` files are returned (plus a few other files, such as `project.godot` or `project.binary` and the project icon). In an exported project, the list of returned files will also vary depending on {@link ProjectSettings.editor/export/convertTextResourcesToBinary}.
+     */
+    static getFilesAt(path: string): PackedStringArray { return _C(246, 4777, path) as PackedStringArray; }
+
+    /**
+     * Returns a {@link PackedStringArray} containing filenames of the directory contents, excluding files. The array is sorted alphabetically.
+     * Affected by {@link includeHidden} and {@link includeNavigational}.
+     * **Note:** The returned directories in the editor and after exporting in the `res://` directory may differ as some files are converted to engine-specific formats when exported.
+     */
+    getDirectories(): PackedStringArray { return _C(this, 4508) as PackedStringArray; }
+
+    /**
+     * Returns a {@link PackedStringArray} containing filenames of the directory contents, excluding files, at the given `path`. The array is sorted alphabetically.
+     * Use {@link getDirectories} if you want more control of what gets included.
+     * **Note:** The returned directories in the editor and after exporting in the `res://` directory may differ as some files are converted to engine-specific formats when exported.
+     */
+    static getDirectoriesAt(path: string): PackedStringArray { return _C(246, 4509, path) as PackedStringArray; }
+
+    /**
+     * On Windows, returns the number of drives (partitions) mounted on the current filesystem.
+     * On macOS and Android, returns the number of mounted volumes.
+     * On Linux, returns the number of mounted volumes and GTK 3 bookmarks.
+     * On other platforms, the method returns 0.
+     */
+    static getDriveCount(): number { return _C(246, 4572) as number; }
+
+    /**
+     * On Windows, returns the name of the drive (partition) passed as an argument (e.g. `C:`).
+     * On macOS, returns the path to the mounted volume passed as an argument.
+     * On Linux, returns the path to the mounted volume or GTK 3 bookmark passed as an argument.
+     * On Android (API level 30+), returns the path to the mounted volume as an argument.
+     * On other platforms, or if the requested drive does not exist, returns an empty String.
+     */
+    static getDriveName(idx: number): string { return _C(246, 4574, idx) as string; }
+
+    /**
+     * On Windows, returns the label of the drive (partition) passed as an argument.
+     * On other platforms, or if the requested drive does not exist, returns an empty String.
+     */
+    static getDriveLabel(idx: number): string { return _C(246, 4573, idx) as string; }
+
+    /**
+     * Returns the currently opened directory's drive index. See {@link getDriveName} to convert returned index to the name of the drive.
+     */
+    getCurrentDrive(): number { return _C(this, 4350) as number; }
+
+    /**
+     * Changes the currently opened directory to the one passed as an argument. The argument can be relative to the current directory (e.g. `newdir` or `../newdir`), or an absolute path (e.g. `/tmp/newdir` or `res://somedir/newdir`).
+     * Returns one of the {@link Error} code constants ({@link OK} on success).
+     * **Note:** The new directory must be within the same scope, e.g. when you had opened a directory inside `res://`, you can't change it to `user://` directory. If you need to open a directory in another access scope, use {@link open} to create a new instance instead.
+     */
+    changeDir(toDir: string): Error { return _C(this, 2186, toDir) as Error; }
+
+    /**
+     * Returns the absolute path to the currently opened directory (e.g. `res://folder` or `C:\tmp\folder`).
+     */
+    getCurrentDir(includeDrive?: boolean /* = true */): string { return _C(this, 4349, includeDrive) as string; }
+
+    /**
+     * Creates a directory. The argument can be relative to the current directory, or an absolute path. The target directory should be placed in an already existing directory (to create the full path recursively, see {@link makeDirRecursive}).
+     * Returns one of the {@link Error} code constants ({@link OK} on success).
+     */
+    makeDir(path: string): Error { return _C(this, 8730, path) as Error; }
+
+    /**
+     * Static version of {@link makeDir}. Supports only absolute paths.
+     */
+    static makeDirAbsolute(path: string): Error { return _C(246, 8731, path) as Error; }
+
+    /**
+     * Creates a target directory and all necessary intermediate directories in its path, by calling {@link makeDir} recursively. The argument can be relative to the current directory, or an absolute path.
+     * Returns one of the {@link Error} code constants ({@link OK} on success).
+     */
+    makeDirRecursive(path: string): Error { return _C(this, 8732, path) as Error; }
+
+    /**
+     * Static version of {@link makeDirRecursive}. Supports only absolute paths.
+     */
+    static makeDirRecursiveAbsolute(path: string): Error { return _C(246, 8733, path) as Error; }
+
+    /**
+     * Returns whether the target file exists. The argument can be relative to the current directory, or an absolute path.
+     * For a static equivalent, use {@link FileAccess.fileExists}.
+     * **Note:** Many resources types are imported (e.g. textures or sound files), and their source asset will not be included in the exported game, as only the imported version is used. See {@link ResourceLoader.exists} for an alternative approach that takes resource remapping into account.
+     */
+    fileExists(path: string): boolean { return _C(this, 3248, path) as boolean; }
+
+    /**
+     * Returns whether the target directory exists. The argument can be relative to the current directory, or an absolute path.
+     * **Note:** The returned {@link bool} in the editor and after exporting when used on a path in the `res://` directory may be different. Some files are converted to engine-specific formats when exported, potentially changing the directory structure.
+     */
+    dirExists(path: string): boolean { return _C(this, 2787, path) as boolean; }
+
+    /**
+     * Static version of {@link dirExists}. Supports only absolute paths.
+     * **Note:** The returned {@link bool} in the editor and after exporting when used on a path in the `res://` directory may be different. Some files are converted to engine-specific formats when exported, potentially changing the directory structure.
+     */
+    static dirExistsAbsolute(path: string): boolean { return _C(246, 2788, path) as boolean; }
+
+    /**
+     * Returns the available space on the current directory's disk, in bytes. Returns `0` if the platform-specific method to query the available space fails.
+     */
+    getSpaceLeft(): number { return _C(this, 6464) as number; }
+
+    /**
+     * Copies the `from` file to the `to` destination. Both arguments should be paths to files, either relative or absolute. If the destination file exists and is not access-protected, it will be overwritten.
+     * If `chmodFlags` is different than `-1`, the Unix permissions for the destination path will be set to the provided value, if available on the current operating system.
+     * Returns one of the {@link Error} code constants ({@link OK} on success).
+     */
+    copy(from: string, to: string, chmodFlags?: number /* = -1 */): Error { return _C(this, 2486, from, to, chmodFlags) as Error; }
+
+    /**
+     * Static version of {@link copy}. Supports only absolute paths.
+     */
+    static copyAbsolute(from: string, to: string, chmodFlags?: number /* = -1 */): Error { return _C(246, 2487, from, to, chmodFlags) as Error; }
+
+    /**
+     * Renames (move) the `from` file or directory to the `to` destination. Both arguments should be paths to files or directories, either relative or absolute. If the destination file or directory exists and is not access-protected, it will be overwritten.
+     * Returns one of the {@link Error} code constants ({@link OK} on success).
+     */
+    rename(from: string, to: string): Error { return _C(this, 9991, from, to) as Error; }
+
+    /**
+     * Static version of {@link rename}. Supports only absolute paths.
+     */
+    static renameAbsolute(from: string, to: string): Error { return _C(246, 9992, from, to) as Error; }
+
+    /**
+     * Permanently deletes the target file or an empty directory. The argument can be relative to the current directory, or an absolute path. If the target directory is not empty, the operation will fail.
+     * If you don't want to delete the file/directory permanently, use {@link OS.moveToTrash} instead.
+     * Returns one of the {@link Error} code constants ({@link OK} on success).
+     */
+    remove(path: string): Error { return _C(this, 9877, path) as Error; }
+
+    /**
+     * Static version of {@link remove}. Supports only absolute paths.
+     */
+    static removeAbsolute(path: string): Error { return _C(246, 9878, path) as Error; }
+
+    /**
+     * Returns `true` if the file or directory is a symbolic link, directory junction, or other reparse point.
+     * **Note:** This method is implemented on macOS, Linux, and Windows.
+     */
+    isLink(path: string): boolean { return _C(this, 8085, path) as boolean; }
+
+    /**
+     * Returns target of the symbolic link.
+     * **Note:** This method is implemented on macOS, Linux, and Windows.
+     */
+    readLink(path: string): string { return _C(this, 9759, path) as string; }
+
+    /**
+     * Creates symbolic link between files or folders.
+     * **Note:** On Windows, this method works only if the application is running with elevated privileges or Developer Mode is enabled.
+     * **Note:** This method is implemented on macOS, Linux, and Windows.
+     */
+    createLink(source: string, target: string): Error { return _C(this, 2548, source, target) as Error; }
+
+    /**
+     * Returns `true` if the directory is a macOS bundle.
+     * **Note:** This method is implemented on macOS.
+     */
+    isBundle(path: string): boolean { return _C(this, 7805, path) as boolean; }
+
+    /**
+     * Returns file system type name of the current directory's disk. Returned values are uppercase strings like `NTFS`, `FAT32`, `EXFAT`, `APFS`, `EXT4`, `BTRFS`, and so on.
+     * **Note:** This method is implemented on macOS, Linux, Windows and for PCK virtual file system.
+     */
+    getFilesystemType(): string { return _C(this, 4778) as string; }
+
+    /**
+     * Returns `true` if the file system or directory use case sensitive file names.
+     * **Note:** This method is implemented on macOS, Linux (for EXT4 and F2FS filesystems only) and Windows. On other platforms, it always returns `true`.
+     */
+    isCaseSensitive(path: string): boolean { return _C(this, 7823, path) as boolean; }
+
+    /**
+     * Returns `true` if paths `pathA` and `pathB` resolve to the same file system object. Returns `false` otherwise, even if the files are bit-for-bit identical (e.g., identical copies of the file that are not symbolic links).
+     */
+    isEquivalent(pathA: string, pathB: string): boolean { return _C(this, 7939, pathA, pathB) as boolean; }
+
+    /**
+     * If `true`, `.` and `..` are included when navigating the directory.
+     * Affects {@link listDirBegin} and {@link getDirectories}.
+     */
+    get includeNavigational(): boolean { return _C(this, 5080) as boolean; }
+    set includeNavigational(v: boolean) { _C(this, 11681, v); }
+
+    /**
+     * If `true`, hidden files are included when navigating the directory.
+     * Affects {@link listDirBegin}, {@link getDirectories} and {@link getFiles}.
+     */
+    get includeHidden(): boolean { return _C(this, 5079) as boolean; }
+    set includeHidden(v: boolean) { _C(this, 11680, v); }
+
+    static readonly name = _R(246, DirAccess);
+}

package/gen/classes/DirectionalLight2D.ts

@@ -0,0 +1,28 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Light2D } from './Light2D.ts';
+
+/**
+ * A directional light is a type of {@link Light2D} node that models an infinite number of parallel rays covering the entire scene. It is used for lights with strong intensity that are located far away from the scene (for example: to model sunlight or moonlight).
+ * Light is emitted in the +Y direction of the node's global basis. For an unrotated light, this means that the light is emitted downwards. The position of the node is ignored; only the basis is used to determine light direction.
+ * **Note:** {@link DirectionalLight2D} does not support light cull masks (but it supports shadow cull masks). It will always light up 2D nodes, regardless of the 2D node's {@link CanvasItem.lightMask}.
+ */
+export class DirectionalLight2D extends Light2D {
+    constructor(name = 247) { super(name); }
+
+    /**
+     * The height of the light. Used with 2D normal mapping. Ranges from 0 (parallel to the plane) to 1 (perpendicular to the plane).
+     */
+    get height(): number { return _C(this, 5024) as number; }
+    set height(v: number) { _C(this, 11609, v); }
+
+    /**
+     * The maximum distance from the camera center objects can be before their shadows are culled (in pixels). Decreasing this value can prevent objects located outside the camera from casting shadows (while also improving performance). {@link Camera2D.zoom} is not taken into account by {@link maxDistance}, which means that at higher zoom values, shadows will appear to fade out sooner when zooming onto a given point.
+     */
+    get maxDistance(): number { return _C(this, 5467) as number; }
+    set maxDistance(v: number) { _C(this, 11992, v); }
+
+    static readonly name = _R(247, DirectionalLight2D);
+}

package/gen/classes/DirectionalLight3D.ts

@@ -0,0 +1,104 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Light3D } from './Light3D.ts';
+
+/**
+ * A directional light is a type of {@link Light3D} node that models an infinite number of parallel rays covering the entire scene. It is used for lights with strong intensity that are located far away from the scene to model sunlight or moonlight.
+ * Light is emitted in the -Z direction of the node's global basis. For an unrotated light, this means that the light is emitted forwards, illuminating the front side of a 3D model (see {@link Vector3.FORWARD} and {@link Vector3.MODEL_FRONT}). The position of the node is ignored; only the basis is used to determine light direction.
+ */
+export class DirectionalLight3D extends Light3D {
+    constructor(name = 248) { super(name); }
+
+    /**
+     * The light's shadow rendering algorithm.
+     */
+    get directionalShadowMode(): ShadowMode { return _C(this, 6363) as ShadowMode; }
+    set directionalShadowMode(v: ShadowMode) { _C(this, 12710, v); }
+
+    /**
+     * The distance from camera to shadow split 1. Relative to {@link directionalShadowMaxDistance}. Only used when {@link directionalShadowMode} is {@link SHADOW_PARALLEL_2_SPLITS} or {@link SHADOW_PARALLEL_4_SPLITS}.
+     */
+    get directionalShadowSplit1(): number { return _C(this, 5809, 10) as number; }
+    set directionalShadowSplit1(v: number) { _C(this, 12248, 10, v); }
+
+    /**
+     * The distance from shadow split 1 to split 2. Relative to {@link directionalShadowMaxDistance}. Only used when {@link directionalShadowMode} is {@link SHADOW_PARALLEL_4_SPLITS}.
+     */
+    get directionalShadowSplit2(): number { return _C(this, 5809, 11) as number; }
+    set directionalShadowSplit2(v: number) { _C(this, 12248, 11, v); }
+
+    /**
+     * The distance from shadow split 2 to split 3. Relative to {@link directionalShadowMaxDistance}. Only used when {@link directionalShadowMode} is {@link SHADOW_PARALLEL_4_SPLITS}.
+     */
+    get directionalShadowSplit3(): number { return _C(this, 5809, 12) as number; }
+    set directionalShadowSplit3(v: number) { _C(this, 12248, 12, v); }
+
+    /**
+     * If `true`, shadow detail is sacrificed in exchange for smoother transitions between splits. Enabling shadow blend splitting also has a moderate performance cost. This is ignored when {@link directionalShadowMode} is {@link SHADOW_ORTHOGONAL}.
+     */
+    get directionalShadowBlendSplits(): boolean { return _C(this, 7796) as boolean; }
+    set directionalShadowBlendSplits(v: boolean) { _C(this, 10686, v); }
+
+    /**
+     * Proportion of {@link directionalShadowMaxDistance} at which point the shadow starts to fade. At {@link directionalShadowMaxDistance}, the shadow will disappear. The default value is a balance between smooth fading and distant shadow visibility. If the camera moves fast and the {@link directionalShadowMaxDistance} is low, consider lowering {@link directionalShadowFadeStart} below `0.8` to make shadow transitions less noticeable. On the other hand, if you tuned {@link directionalShadowMaxDistance} to cover the entire scene, you can set {@link directionalShadowFadeStart} to `1.0` to prevent the shadow from fading in the distance (it will suddenly cut off instead).
+     */
+    get directionalShadowFadeStart(): number { return _C(this, 5809, 13) as number; }
+    set directionalShadowFadeStart(v: number) { _C(this, 12248, 13, v); }
+
+    /**
+     * The maximum distance for shadow splits. Increasing this value will make directional shadows visible from further away, at the cost of lower overall shadow detail and performance (since more objects need to be included in the directional shadow rendering).
+     */
+    get directionalShadowMaxDistance(): number { return _C(this, 5809, 9) as number; }
+    set directionalShadowMaxDistance(v: number) { _C(this, 12248, 9, v); }
+
+    /**
+     * Sets the size of the directional shadow pancake. The pancake offsets the start of the shadow's camera frustum to provide a higher effective depth resolution for the shadow. However, a high pancake size can cause artifacts in the shadows of large objects that are close to the edge of the frustum. Reducing the pancake size can help. Setting the size to `0` turns off the pancaking effect.
+     */
+    get directionalShadowPancakeSize(): number { return _C(this, 5809, 16) as number; }
+    set directionalShadowPancakeSize(v: number) { _C(this, 12248, 16, v); }
+
+    /**
+     * Whether this {@link DirectionalLight3D} is visible in the sky, in the scene, or both in the sky and in the scene.
+     */
+    get skyMode(): SkyMode { return _C(this, 6426) as SkyMode; }
+    set skyMode(v: SkyMode) { _C(this, 12774, v); }
+
+    static readonly name = _R(248, DirectionalLight3D);
+}
+
+export const ShadowMode = {
+    /**
+     * Renders the entire scene's shadow map from an orthogonal point of view. This is the fastest directional shadow mode. May result in blurrier shadows on close objects.
+     */
+    SHADOW_ORTHOGONAL: 0,
+    /**
+     * Splits the view frustum in 2 areas, each with its own shadow map. This shadow mode is a compromise between {@link SHADOW_ORTHOGONAL} and {@link SHADOW_PARALLEL_4_SPLITS} in terms of performance.
+     */
+    SHADOW_PARALLEL_2_SPLITS: 1,
+    /**
+     * Splits the view frustum in 4 areas, each with its own shadow map. This is the slowest directional shadow mode.
+     */
+    SHADOW_PARALLEL_4_SPLITS: 2,
+} as const;
+
+export type ShadowMode = (typeof ShadowMode)[keyof typeof ShadowMode];
+
+export const SkyMode = {
+    /**
+     * Makes the light visible in both scene lighting and sky rendering.
+     */
+    SKY_MODE_LIGHT_AND_SKY: 0,
+    /**
+     * Makes the light visible in scene lighting only (including direct lighting and global illumination). When using this mode, the light will not be visible from sky shaders.
+     */
+    SKY_MODE_LIGHT_ONLY: 1,
+    /**
+     * Makes the light visible to sky shaders only. When using this mode the light will not cast light into the scene (either through direct lighting or through global illumination), but can be accessed through sky shaders. This can be useful, for example, when you want to control sky effects without illuminating the scene (during a night cycle, for example).
+     */
+    SKY_MODE_SKY_ONLY: 2,
+} as const;
+
+export type SkyMode = (typeof SkyMode)[keyof typeof SkyMode];
+