@ringozz/godot 0.1.0

package/gen/classes/CylinderShape3D.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 { Shape3D } from './Shape3D.ts';
+
+/**
+ * A 3D cylinder shape, intended for use in physics. Usually used to provide a shape for a {@link CollisionShape3D}.
+ * **Note:** There are several known bugs with cylinder collision shapes. Using {@link CapsuleShape3D} or {@link BoxShape3D} instead is recommended.
+ * **Performance:** {@link CylinderShape3D} is fast to check collisions against, but it is slower than {@link CapsuleShape3D}, {@link BoxShape3D}, and {@link SphereShape3D}.
+ */
+export class CylinderShape3D extends Shape3D {
+    constructor(name = 241) { super(name); }
+
+    /**
+     * The cylinder's height.
+     */
+    get height(): number { return _C(this, 5024) as number; }
+    set height(v: number) { _C(this, 11609, v); }
+
+    /**
+     * The cylinder's radius.
+     */
+    get radius(): number { return _C(this, 6068) as number; }
+    set radius(v: number) { _C(this, 12467, v); }
+
+    static readonly name = _R(241, CylinderShape3D);
+}

package/gen/classes/DPITexture.ts

@@ -0,0 +1,73 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture2D } from './Texture2D.ts';
+import type { GodotDictionary, RID } from '../heap-types/index.ts';
+import type { Vector2i } from '../value-types/index.ts';
+
+/**
+ * An automatically scalable {@link Texture2D} based on an SVG image. {@link DPITexture}s are used to automatically re-rasterize icons and other texture based UI theme elements to match viewport scale and font oversampling. See also {@link ProjectSettings.display/window/stretch/mode} ("canvas_items" mode) and {@link Viewport.oversamplingOverride}.
+ */
+export class DPITexture extends Texture2D {
+    constructor(name = 242) { super(name); }
+
+    /**
+     * Creates a new {@link DPITexture} and initializes it by allocating and setting the SVG data to `source`.
+     */
+    static createFromString(source: string, scale?: number /* = 1.0 */, saturation?: number /* = 1.0 */, colorMap?: GodotDictionary /* = {} */): DPITexture { return _C(242, 2537, source, scale, saturation, colorMap) as DPITexture; }
+
+    /**
+     * Sets this SVG texture's source code.
+     */
+    setSource(source: string): void { _C(this, 12812, source); }
+
+    /**
+     * Returns this SVG texture's source code.
+     */
+    getSource(): string { return _C(this, 6455) as string; }
+
+    /**
+     * Resizes the texture to the specified dimensions.
+     */
+    setSizeOverride(size: Vector2i): void { _C(this, 12756, size); }
+
+    /**
+     * Returns the {@link RID} of the texture rasterized to match the oversampling of the currently drawn canvas item.
+     */
+    getScaledRid(): RID { return _C(this, 6243) as RID; }
+
+    /**
+     * If `true`, puts pixels of the same surrounding color in transition from transparent to opaque areas. For textures displayed with bilinear filtering, this helps to reduce the outline effect when exporting images from an image editor.
+     */
+    get fixAlphaBorder(): boolean { return _C(this, 4797) as boolean; }
+    set fixAlphaBorder(v: boolean) { _C(this, 11402, v); }
+
+    /**
+     * An alternative to fixing darkened borders with {@link fixAlphaBorder} is to use premultiplied alpha. By enabling this option, the texture will be converted to this format. A premultiplied alpha texture requires specific materials to be displayed correctly:
+     * - In 2D, a {@link CanvasItemMaterial} will need to be created and configured to use the {@link CanvasItemMaterial.BLEND_MODE_PREMULT_ALPHA} blend mode on {@link CanvasItem}s that use this texture. In custom `canvas_item` shaders, `render_mode blend_premul_alpha;` should be used.
+     * - In 3D, a {@link BaseMaterial3D} will need to be created and configured to use the {@link BaseMaterial3D.BLEND_MODE_PREMULT_ALPHA} blend mode on materials that use this texture. In custom `spatial` shaders, `render_mode blend_premul_alpha;` should be used.
+     */
+    get premultAlpha(): boolean { return _C(this, 5990) as boolean; }
+    set premultAlpha(v: boolean) { _C(this, 12399, v); }
+
+    /**
+     * Texture scale. `1.0` is the original SVG size. Higher values result in a larger image.
+     */
+    get baseScale(): number { return _C(this, 3898) as number; }
+    set baseScale(v: number) { _C(this, 10644, v); }
+
+    /**
+     * Overrides texture saturation.
+     */
+    get saturation(): number { return _C(this, 6234) as number; }
+    set saturation(v: number) { _C(this, 12607, v); }
+
+    /**
+     * If set, remaps texture colors according to {@link Color}-{@link Color} map.
+     */
+    get colorMap(): GodotDictionary { return _C(this, 4226) as GodotDictionary; }
+    set colorMap(v: GodotDictionary) { _C(this, 10910, v); }
+
+    static readonly name = _R(242, DPITexture);
+}

package/gen/classes/DTLSServer.ts

@@ -0,0 +1,93 @@
+// 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 { PacketPeerDTLS } from './PacketPeerDTLS.ts';
+import type { PacketPeerUDP } from './PacketPeerUDP.ts';
+import type { TLSOptions } from './TLSOptions.ts';
+
+/**
+ * This class is used to store the state of a DTLS server. Upon {@link setup} it converts connected {@link PacketPeerUDP} to {@link PacketPeerDTLS} accepting them via {@link takeConnection} as DTLS clients. Under the hood, this class is used to store the DTLS state and cookies of the server. The reason of why the state and cookies are needed is outside of the scope of this documentation.
+ * Below a small example of how to use it:
+ *
+ *
+ * ```gdscript
+ *
+ * # server_node.gd
+ * extends Node
+ *
+ * var dtls = DTLSServer.new()
+ * var server = UDPServer.new()
+ * var peers = []
+ *
+ * func _ready():
+ * 	server.listen(4242)
+ * 	var key = load("key.key") # Your private key.
+ * 	var cert = load("cert.crt") # Your X509 certificate.
+ * 	dtls.setup(TlsOptions.server(key, cert))
+ *
+ * func _process(delta):
+ * 	while server.is_connection_available():
+ * 		var peer = server.take_connection()
+ * 		var dtls_peer = dtls.take_connection(peer)
+ * 		if dtls_peer.get_status() != PacketPeerDTLS.STATUS_HANDSHAKING:
+ * 			continue # It is normal that 50% of the connections fails due to cookie exchange.
+ * 		print("Peer connected!")
+ * 		peers.append(dtls_peer)
+ *
+ * 	for p in peers:
+ * 		p.poll() # Must poll to update the state.
+ * 		if p.get_status() == PacketPeerDTLS.STATUS_CONNECTED:
+ * 			while p.get_available_packet_count() > 0:
+ * 				print("Received message from client: %s" % p.get_packet().get_string_from_utf8())
+ * 				p.put_packet("Hello DTLS client".to_utf8_buffer())
+ *
+ * ```
+ *
+ *
+ *
+ *
+ *
+ * ```gdscript
+ *
+ * # client_node.gd
+ * extends Node
+ *
+ * var dtls = PacketPeerDTLS.new()
+ * var udp = PacketPeerUDP.new()
+ * var connected = false
+ *
+ * func _ready():
+ * 	udp.connect_to_host("127.0.0.1", 4242)
+ * 	dtls.connect_to_peer(udp, false) # Use true in production for certificate validation!
+ *
+ * func _process(delta):
+ * 	dtls.poll()
+ * 	if dtls.get_status() == PacketPeerDTLS.STATUS_CONNECTED:
+ * 		if !connected:
+ * 			# Try to contact server
+ * 			dtls.put_packet("The answer is... 42!".to_utf8_buffer())
+ * 		while dtls.get_available_packet_count() > 0:
+ * 			print("Connected: %s" % dtls.get_packet().get_string_from_utf8())
+ * 			connected = true
+ *
+ * ```
+ */
+export class DTLSServer extends RefCounted {
+    constructor(name = 243) { super(name); }
+
+    /**
+     * Setup the DTLS server to use the given `serverOptions`. See {@link TLSOptions.server}.
+     */
+    setup(serverOptions: TLSOptions): Error { return _C(this, 13415, serverOptions) as Error; }
+
+    /**
+     * Try to initiate the DTLS handshake with the given `udpPeer` which must be already connected (see {@link PacketPeerUDP.connectToHost}).
+     * **Note:** You must check that the state of the return PacketPeerUDP is {@link PacketPeerDTLS.STATUS_HANDSHAKING}, as it is normal that 50% of the new connections will be invalid due to cookie exchange.
+     */
+    takeConnection(udpPeer: PacketPeerUDP): PacketPeerDTLS { return _C(this, 14114, udpPeer) as PacketPeerDTLS; }
+
+    static readonly name = _R(243, DTLSServer);
+}

package/gen/classes/DampedSpringJoint2D.ts

@@ -0,0 +1,38 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Joint2D } from './Joint2D.ts';
+
+/**
+ * A physics joint that connects two 2D physics bodies with a spring-like force. This behaves like a spring that always wants to stretch to a given length.
+ */
+export class DampedSpringJoint2D extends Joint2D {
+    constructor(name = 244) { super(name); }
+
+    /**
+     * The spring joint's maximum length. The two attached bodies cannot stretch it past this value.
+     */
+    get length(): number { return _C(this, 5331) as number; }
+    set length(v: number) { _C(this, 11891, v); }
+
+    /**
+     * When the bodies attached to the spring joint move they stretch or squash it. The joint always tries to resize towards this length.
+     */
+    get restLength(): number { return _C(this, 6170) as number; }
+    set restLength(v: number) { _C(this, 12545, v); }
+
+    /**
+     * The higher the value, the less the bodies attached to the joint will deform it. The joint applies an opposing force to the bodies, the product of the stiffness multiplied by the size difference from its resting length.
+     */
+    get stiffness(): number { return _C(this, 6554) as number; }
+    set stiffness(v: number) { _C(this, 12893, v); }
+
+    /**
+     * The spring joint's damping ratio. A value between `0` and `1`. When the two bodies move into different directions the system tries to align them to the spring axis again. A high {@link damping} value forces the attached bodies to align faster.
+     */
+    get damping(): number { return _C(this, 4405) as number; }
+    set damping(v: number) { _C(this, 11029, v); }
+
+    static readonly name = _R(244, DampedSpringJoint2D);
+}

package/gen/classes/Decal.ts

@@ -0,0 +1,146 @@
+// 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 { Color, Vector3 } from '../value-types/index.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * {@link Decal}s are used to project a texture onto a {@link Mesh} in the scene. Use Decals to add detail to a scene without affecting the underlying {@link Mesh}. They are often used to add weathering to building, add dirt or mud to the ground, or add variety to props. Decals can be moved at any time, making them suitable for things like blob shadows or laser sight dots.
+ * They are made of an {@link AABB} and a group of {@link Texture2D}s specifying {@link Color}, normal, ORM (ambient occlusion, roughness, metallic), and emission. Decals are projected within their {@link AABB} so altering the orientation of the Decal affects the direction in which they are projected. By default, Decals are projected down (i.e. from positive Y to negative Y).
+ * The {@link Texture2D}s associated with the Decal are automatically stored in a texture atlas which is used for drawing the decals so all decals can be drawn at once. Godot uses clustered decals, meaning they are stored in cluster data and drawn when the mesh is drawn, they are not drawn as a post-processing effect after.
+ * **Note:** Decals cannot affect an underlying material's transparency, regardless of its transparency mode (alpha blend, alpha scissor, alpha hash, opaque pre-pass). This means translucent or transparent areas of a material will remain translucent or transparent even if an opaque decal is applied on them.
+ * **Note:** Decals are only supported in the Forward+ and Mobile rendering methods, not Compatibility. When using the Mobile rendering method, only 8 decals can be displayed on each mesh resource. Attempting to display more than 8 decals on a single mesh resource will result in decals flickering in and out as the camera moves.
+ * **Note:** When using the Mobile rendering method, decals will only correctly affect meshes whose visibility AABB intersects with the decal's AABB. If using a shader to deform the mesh in a way that makes it go outside its AABB, {@link GeometryInstance3D.extraCullMargin} must be increased on the mesh. Otherwise, the decal may not be visible on the mesh.
+ */
+export class Decal extends VisualInstance3D {
+    constructor(name = 245) { super(name); }
+
+    /**
+     * Sets the size of the {@link AABB} used by the decal. All dimensions must be set to a value greater than zero (they will be clamped to `0.001` if this is not the case). The AABB goes from `-size/2` to `size/2`.
+     * **Note:** To improve culling efficiency of "hard surface" decals, set their {@link upperFade} and {@link lowerFade} to `0.0` and set the Y component of the {@link size} as low as possible. This will reduce the decals' AABB size without affecting their appearance.
+     */
+    get size(): Vector3 { return _C(this, 6399) as Vector3; }
+    set size(v: Vector3) { _C(this, 12752, v); }
+
+    /**
+     * {@link Texture2D} with the base {@link Color} of the Decal. Either this or the {@link textureEmission} must be set for the Decal to be visible. Use the alpha channel like a mask to smoothly blend the edges of the decal with the underlying object.
+     * **Note:** Unlike {@link BaseMaterial3D} whose filter mode can be adjusted on a per-material basis, the filter mode for {@link Decal} textures is set globally with {@link ProjectSettings.rendering/textures/decals/filter}.
+     */
+    get textureAlbedo(): Texture2D { return _C(this, 6726, 0) as Texture2D; }
+    set textureAlbedo(v: Texture2D) { _C(this, 13024, 0, v); }
+
+    /**
+     * {@link Texture2D} with the per-pixel normal map for the decal. Use this to add extra detail to decals.
+     * **Note:** Unlike {@link BaseMaterial3D} whose filter mode can be adjusted on a per-material basis, the filter mode for {@link Decal} textures is set globally with {@link ProjectSettings.rendering/textures/decals/filter}.
+     * **Note:** Setting this texture alone will not result in a visible decal, as {@link textureAlbedo} must also be set. To create a normal-only decal, load an albedo texture into {@link textureAlbedo} and set {@link albedoMix} to `0.0`. The albedo texture's alpha channel will be used to determine where the underlying surface's normal map should be overridden (and its intensity).
+     */
+    get textureNormal(): Texture2D { return _C(this, 6726, 1) as Texture2D; }
+    set textureNormal(v: Texture2D) { _C(this, 13024, 1, v); }
+
+    /**
+     * {@link Texture2D} storing ambient occlusion, roughness, and metallic for the decal. Use this to add extra detail to decals.
+     * **Note:** Unlike {@link BaseMaterial3D} whose filter mode can be adjusted on a per-material basis, the filter mode for {@link Decal} textures is set globally with {@link ProjectSettings.rendering/textures/decals/filter}.
+     * **Note:** Setting this texture alone will not result in a visible decal, as {@link textureAlbedo} must also be set. To create an ORM-only decal, load an albedo texture into {@link textureAlbedo} and set {@link albedoMix} to `0.0`. The albedo texture's alpha channel will be used to determine where the underlying surface's ORM map should be overridden (and its intensity).
+     * **Note:** Due to technical limitations, modifying the underlying surface's roughness using {@link textureOrm} does *not* affect screen-space reflections ({@link Environment.ssrEnabled}), reflections from {@link VoxelGI}, and reflections from SDFGI ({@link Environment.sdfgiEnabled}). Only reflections from {@link ReflectionProbe}s are affected.
+     */
+    get textureOrm(): Texture2D { return _C(this, 6726, 2) as Texture2D; }
+    set textureOrm(v: Texture2D) { _C(this, 13024, 2, v); }
+
+    /**
+     * {@link Texture2D} with the emission {@link Color} of the Decal. Either this or the {@link textureAlbedo} must be set for the Decal to be visible. Use the alpha channel like a mask to smoothly blend the edges of the decal with the underlying object.
+     * **Note:** Unlike {@link BaseMaterial3D} whose filter mode can be adjusted on a per-material basis, the filter mode for {@link Decal} textures is set globally with {@link ProjectSettings.rendering/textures/decals/filter}.
+     */
+    get textureEmission(): Texture2D { return _C(this, 6726, 3) as Texture2D; }
+    set textureEmission(v: Texture2D) { _C(this, 13024, 3, v); }
+
+    /**
+     * Energy multiplier for the emission texture. This will make the decal emit light at a higher or lower intensity, independently of the albedo color. See also {@link modulate}.
+     */
+    get emissionEnergy(): number { return _C(this, 4620) as number; }
+    set emissionEnergy(v: number) { _C(this, 11237, v); }
+
+    /**
+     * Changes the {@link Color} of the Decal by multiplying the albedo and emission colors with this value. The alpha component is only taken into account when multiplying the albedo color, not the emission color. See also {@link emissionEnergy} and {@link albedoMix} to change the emission and albedo intensity independently of each other.
+     */
+    get modulate(): Color { return _C(this, 5576) as Color; }
+    set modulate(v: Color) { _C(this, 12081, v); }
+
+    /**
+     * Blends the albedo {@link Color} of the decal with albedo {@link Color} of the underlying mesh. This can be set to `0.0` to create a decal that only affects normal or ORM. In this case, an albedo texture is still required as its alpha channel will determine where the normal and ORM will be overridden. See also {@link modulate}.
+     */
+    get albedoMix(): number { return _C(this, 3711) as number; }
+    set albedoMix(v: number) { _C(this, 10447, v); }
+
+    /**
+     * Fades the Decal if the angle between the Decal's {@link AABB} and the target surface becomes too large. A value of `0` projects the Decal regardless of angle, a value of `1` limits the Decal to surfaces that are nearly perpendicular.
+     * **Note:** Setting {@link normalFade} to a value greater than `0.0` has a small performance cost due to the added normal angle computations.
+     */
+    get normalFade(): number { return _C(this, 5677) as number; }
+    set normalFade(v: number) { _C(this, 12147, v); }
+
+    /**
+     * Sets the curve over which the decal will fade as the surface gets further from the center of the {@link AABB}. Only positive values are valid (negative values will be clamped to `0.0`). See also {@link lowerFade}.
+     */
+    get upperFade(): number { return _C(this, 6965) as number; }
+    set upperFade(v: number) { _C(this, 13185, v); }
+
+    /**
+     * Sets the curve over which the decal will fade as the surface gets further from the center of the {@link AABB}. Only positive values are valid (negative values will be clamped to `0.0`). See also {@link upperFade}.
+     */
+    get lowerFade(): number { return _C(this, 5425) as number; }
+    set lowerFade(v: number) { _C(this, 11958, v); }
+
+    /**
+     * If `true`, decals will smoothly fade away when far from the active {@link Camera3D} starting at {@link distanceFadeBegin}. The Decal will fade out over {@link distanceFadeBegin} + {@link distanceFadeLength}, after which it will be culled and not sent to the shader at all. Use this to reduce the number of active Decals in a scene and thus improve performance.
+     */
+    get distanceFadeEnabled(): boolean { return _C(this, 7887) as boolean; }
+    set distanceFadeEnabled(v: boolean) { _C(this, 11274, v); }
+
+    /**
+     * The distance from the camera at which the Decal begins to fade away (in 3D units).
+     */
+    get distanceFadeBegin(): number { return _C(this, 4525) as number; }
+    set distanceFadeBegin(v: number) { _C(this, 11135, v); }
+
+    /**
+     * The distance over which the Decal fades (in 3D units). The Decal becomes slowly more transparent over this distance and is completely invisible at the end. Higher values result in a smoother fade-out transition, which is more suited when the camera moves fast.
+     */
+    get distanceFadeLength(): number { return _C(this, 4526) as number; }
+    set distanceFadeLength(v: number) { _C(this, 11136, v); }
+
+    /**
+     * Specifies which {@link VisualInstance3D.layers} this decal will project on. By default, Decals affect all layers. This is used so you can specify which types of objects receive the Decal and which do not. This is especially useful so you can ensure that dynamic objects don't accidentally receive a Decal intended for the terrain under them.
+     */
+    get cullMask(): number { return _C(this, 4339) as number; }
+    set cullMask(v: number) { _C(this, 10981, v); }
+
+    static readonly name = _R(245, Decal);
+}
+
+export const DecalTexture = {
+    /**
+     * {@link Texture2D} corresponding to {@link textureAlbedo}.
+     */
+    TEXTURE_ALBEDO: 0,
+    /**
+     * {@link Texture2D} corresponding to {@link textureNormal}.
+     */
+    TEXTURE_NORMAL: 1,
+    /**
+     * {@link Texture2D} corresponding to {@link textureOrm}.
+     */
+    TEXTURE_ORM: 2,
+    /**
+     * {@link Texture2D} corresponding to {@link textureEmission}.
+     */
+    TEXTURE_EMISSION: 3,
+    /**
+     * Max size of {@link DecalTexture} enum.
+     */
+    TEXTURE_MAX: 4,
+} as const;
+
+export type DecalTexture = (typeof DecalTexture)[keyof typeof DecalTexture];
+