typescript-to-gdscript 0.1.0

package/typings/classes/RDPipelineDepthStencilState.d.ts

@@ -0,0 +1,102 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Pipeline depth/stencil state (used by {@link RenderingDevice}). */
+declare class RDPipelineDepthStencilState extends RefCounted {
+  /** The method used for comparing the previous back stencil value and {@link back_op_reference}. */
+  back_op_compare: int;
+  /** Selects which bits from the back stencil value will be compared. */
+  back_op_compare_mask: int;
+  /**
+   * The operation to perform on the stencil buffer for back pixels that pass the stencil test but fail the depth test.
+   */
+  back_op_depth_fail: int;
+  /** The operation to perform on the stencil buffer for back pixels that fail the stencil test. */
+  back_op_fail: int;
+  /** The operation to perform on the stencil buffer for back pixels that pass the stencil test. */
+  back_op_pass: int;
+  /** The value the previous back stencil value will be compared to. */
+  back_op_reference: int;
+  /** Selects which bits from the back stencil value will be changed. */
+  back_op_write_mask: int;
+  /** The method used for comparing the previous and current depth values. */
+  depth_compare_operator: int;
+  /** The maximum depth that returns `true` for {@link enable_depth_range}. */
+  depth_range_max: float;
+  /** The minimum depth that returns `true` for {@link enable_depth_range}. */
+  depth_range_min: float;
+  /**
+   * If `true`, each depth value will be tested to see if it is between {@link depth_range_min} and {@link depth_range_max}. If it is outside of these values, it is discarded.
+   */
+  enable_depth_range: boolean;
+  /**
+   * If `true`, enables depth testing which allows objects to be automatically occluded by other objects based on their depth. This also allows objects to be partially occluded by other objects. If `false`, objects will appear in the order they were drawn (like in Godot's 2D renderer).
+   */
+  enable_depth_test: boolean;
+  /**
+   * If `true`, writes to the depth buffer whenever the depth test returns `true`. Only works when enable_depth_test is also `true`.
+   */
+  enable_depth_write: boolean;
+  /**
+   * If `true`, enables stencil testing. There are separate stencil buffers for front-facing triangles and back-facing triangles. See properties that begin with "front_op" and properties with "back_op" for each.
+   */
+  enable_stencil: boolean;
+  /** The method used for comparing the previous front stencil value and {@link front_op_reference}. */
+  front_op_compare: int;
+  /** Selects which bits from the front stencil value will be compared. */
+  front_op_compare_mask: int;
+  /**
+   * The operation to perform on the stencil buffer for front pixels that pass the stencil test but fail the depth test.
+   */
+  front_op_depth_fail: int;
+  /** The operation to perform on the stencil buffer for front pixels that fail the stencil test. */
+  front_op_fail: int;
+  /** The operation to perform on the stencil buffer for front pixels that pass the stencil test. */
+  front_op_pass: int;
+  /** The value the previous front stencil value will be compared to. */
+  front_op_reference: int;
+  /** Selects which bits from the front stencil value will be changed. */
+  front_op_write_mask: int;
+  set_back_op_compare(value: int): void;
+  get_back_op_compare(): int;
+  set_back_op_compare_mask(value: int): void;
+  get_back_op_compare_mask(): int;
+  set_back_op_depth_fail(value: int): void;
+  get_back_op_depth_fail(): int;
+  set_back_op_fail(value: int): void;
+  get_back_op_fail(): int;
+  set_back_op_pass(value: int): void;
+  get_back_op_pass(): int;
+  set_back_op_reference(value: int): void;
+  get_back_op_reference(): int;
+  set_back_op_write_mask(value: int): void;
+  get_back_op_write_mask(): int;
+  set_depth_compare_operator(value: int): void;
+  get_depth_compare_operator(): int;
+  set_depth_range_max(value: float): void;
+  get_depth_range_max(): float;
+  set_depth_range_min(value: float): void;
+  get_depth_range_min(): float;
+  set_enable_depth_range(value: boolean): void;
+  get_enable_depth_range(): boolean;
+  set_enable_depth_test(value: boolean): void;
+  get_enable_depth_test(): boolean;
+  set_enable_depth_write(value: boolean): void;
+  get_enable_depth_write(): boolean;
+  set_enable_stencil(value: boolean): void;
+  get_enable_stencil(): boolean;
+  set_front_op_compare(value: int): void;
+  get_front_op_compare(): int;
+  set_front_op_compare_mask(value: int): void;
+  get_front_op_compare_mask(): int;
+  set_front_op_depth_fail(value: int): void;
+  get_front_op_depth_fail(): int;
+  set_front_op_fail(value: int): void;
+  get_front_op_fail(): int;
+  set_front_op_pass(value: int): void;
+  get_front_op_pass(): int;
+  set_front_op_reference(value: int): void;
+  get_front_op_reference(): int;
+  set_front_op_write_mask(value: int): void;
+  get_front_op_write_mask(): int;
+}

package/typings/classes/RDPipelineMultisampleState.d.ts

@@ -0,0 +1,42 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Pipeline multisample state (used by {@link RenderingDevice}). */
+declare class RDPipelineMultisampleState extends RefCounted {
+  /**
+   * If `true`, alpha to coverage is enabled. This generates a temporary coverage value based on the alpha component of the fragment's first color output. This allows alpha transparency to make use of multisample antialiasing.
+   */
+  enable_alpha_to_coverage: boolean;
+  /**
+   * If `true`, alpha is forced to either `0.0` or `1.0`. This allows hardening the edges of antialiased alpha transparencies. Only relevant if {@link enable_alpha_to_coverage} is `true`.
+   */
+  enable_alpha_to_one: boolean;
+  /**
+   * If `true`, enables per-sample shading which replaces MSAA by SSAA. This provides higher quality antialiasing that works with transparent (alpha scissor) edges. This has a very high performance cost. See also {@link min_sample_shading}. See the per-sample shading Vulkan documentation (https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#primsrast-sampleshading) for more details.
+   */
+  enable_sample_shading: boolean;
+  /**
+   * The multiplier of {@link sample_count} that determines how many samples are performed for each fragment. Must be between `0.0` and `1.0` (inclusive). Only effective if {@link enable_sample_shading} is `true`. If {@link min_sample_shading} is `1.0`, fragment invocation must only read from the coverage index sample. Tile image access must not be used if {@link enable_sample_shading} is *not* `1.0`.
+   */
+  min_sample_shading: float;
+  /**
+   * The number of MSAA samples (or SSAA samples if {@link enable_sample_shading} is `true`) to perform. Higher values result in better antialiasing, at the cost of performance.
+   */
+  sample_count: int;
+  /**
+   * The sample mask array. See the sample mask Vulkan documentation (https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#fragops-samplemask) for more details.
+   */
+  sample_masks: Array<int>;
+  set_enable_alpha_to_coverage(value: boolean): void;
+  get_enable_alpha_to_coverage(): boolean;
+  set_enable_alpha_to_one(value: boolean): void;
+  get_enable_alpha_to_one(): boolean;
+  set_enable_sample_shading(value: boolean): void;
+  get_enable_sample_shading(): boolean;
+  set_min_sample_shading(value: float): void;
+  get_min_sample_shading(): float;
+  set_sample_count(value: int): void;
+  get_sample_count(): int;
+  set_sample_masks(value: Array<int>): void;
+  get_sample_masks(): Array<int>;
+}

package/typings/classes/RDPipelineRasterizationState.d.ts

@@ -0,0 +1,64 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Pipeline rasterization state (used by {@link RenderingDevice}). */
+declare class RDPipelineRasterizationState extends RefCounted {
+  /**
+   * The cull mode to use when drawing polygons, which determines whether front faces or backfaces are hidden.
+   */
+  cull_mode: int;
+  /**
+   * A limit for how much each depth value can be offset. If negative, it serves as a minimum value, but if positive, it serves as a maximum value.
+   */
+  depth_bias_clamp: float;
+  /** A constant offset added to each depth value. Applied after {@link depth_bias_slope_factor}. */
+  depth_bias_constant_factor: float;
+  /**
+   * If `true`, each generated depth value will by offset by some amount. The specific amount is generated per polygon based on the values of {@link depth_bias_slope_factor} and {@link depth_bias_constant_factor}.
+   */
+  depth_bias_enabled: boolean;
+  /**
+   * A constant scale applied to the slope of each polygons' depth. Applied before {@link depth_bias_constant_factor}.
+   */
+  depth_bias_slope_factor: float;
+  /** If `true`, primitives are discarded immediately before the rasterization stage. */
+  discard_primitives: boolean;
+  /**
+   * If `true`, clamps depth values according to the minimum and maximum depth of the associated viewport.
+   */
+  enable_depth_clamp: boolean;
+  /** The winding order to use to determine which face of a triangle is considered its front face. */
+  front_face: int;
+  /**
+   * The line width to use when drawing lines (in pixels). Thick lines may not be supported on all hardware.
+   */
+  line_width: float;
+  /**
+   * The number of control points to use when drawing a patch with tessellation enabled. Higher values result in higher quality at the cost of performance.
+   */
+  patch_control_points: int;
+  /** If `true`, performs wireframe rendering for triangles instead of flat or textured rendering. */
+  wireframe: boolean;
+  set_cull_mode(value: int): void;
+  get_cull_mode(): int;
+  set_depth_bias_clamp(value: float): void;
+  get_depth_bias_clamp(): float;
+  set_depth_bias_constant_factor(value: float): void;
+  get_depth_bias_constant_factor(): float;
+  set_depth_bias_enabled(value: boolean): void;
+  get_depth_bias_enabled(): boolean;
+  set_depth_bias_slope_factor(value: float): void;
+  get_depth_bias_slope_factor(): float;
+  set_discard_primitives(value: boolean): void;
+  get_discard_primitives(): boolean;
+  set_enable_depth_clamp(value: boolean): void;
+  get_enable_depth_clamp(): boolean;
+  set_front_face(value: int): void;
+  get_front_face(): int;
+  set_line_width(value: float): void;
+  get_line_width(): float;
+  set_patch_control_points(value: int): void;
+  get_patch_control_points(): int;
+  set_wireframe(value: boolean): void;
+  get_wireframe(): boolean;
+}

package/typings/classes/RDPipelineSpecializationConstant.d.ts

@@ -0,0 +1,18 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Pipeline specialization constant (used by {@link RenderingDevice}). */
+declare class RDPipelineSpecializationConstant extends RefCounted {
+  /**
+   * The identifier of the specialization constant. This is a value starting from `0` and that increments for every different specialization constant for a given shader.
+   */
+  constant_id: int;
+  /**
+   * The specialization constant's value. Only [bool], [int] and [float] types are valid for specialization constants.
+   */
+  value: unknown;
+  set_constant_id(value: int): void;
+  get_constant_id(): int;
+  set_value(value: unknown): void;
+  get_value(): unknown;
+}

package/typings/classes/RDSamplerState.d.ts

@@ -0,0 +1,91 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Sampler state (used by {@link RenderingDevice}). */
+declare class RDSamplerState extends RefCounted {
+  /**
+   * Maximum anisotropy that can be used when sampling. Only effective if {@link use_anisotropy} is `true`. Higher values result in a sharper sampler at oblique angles, at the cost of performance (due to memory bandwidth). This value may be limited by the graphics hardware in use. Most graphics hardware only supports values up to `16.0`.
+   * If {@link anisotropy_max} is `1.0`, forcibly disables anisotropy even if {@link use_anisotropy} is `true`.
+   */
+  anisotropy_max: float;
+  /**
+   * The border color that will be returned when sampling outside the sampler's bounds and the {@link repeat_u}, {@link repeat_v} or {@link repeat_w} modes have repeating disabled.
+   */
+  border_color: int;
+  /** The compare operation to use. Only effective if {@link enable_compare} is `true`. */
+  compare_op: int;
+  /**
+   * If `true`, returned values will be based on the comparison operation defined in {@link compare_op}. This is a hardware-based approach and is therefore faster than performing this manually in a shader. For example, compare operations are used for shadow map rendering by comparing depth values from a shadow sampler.
+   */
+  enable_compare: boolean;
+  /**
+   * The mipmap LOD bias to use. Positive values will make the sampler blurrier at a given distance, while negative values will make the sampler sharper at a given distance (at the risk of looking grainy). Recommended values are between `-0.5` and `0.0`. Only effective if the sampler has mipmaps available.
+   */
+  lod_bias: float;
+  /**
+   * The sampler's magnification filter. It is the filtering method used when sampling texels that appear bigger than on-screen pixels.
+   */
+  mag_filter: int;
+  /**
+   * The maximum mipmap LOD bias to display (lowest resolution). Only effective if the sampler has mipmaps available.
+   */
+  max_lod: float;
+  /**
+   * The sampler's minification filter. It is the filtering method used when sampling texels that appear smaller than on-screen pixels.
+   */
+  min_filter: int;
+  /**
+   * The minimum mipmap LOD bias to display (highest resolution). Only effective if the sampler has mipmaps available.
+   */
+  min_lod: float;
+  /** The filtering method to use for mipmaps. */
+  mip_filter: int;
+  /**
+   * The repeat mode to use along the U axis of UV coordinates. This affects the returned values if sampling outside the UV bounds.
+   */
+  repeat_u: int;
+  /**
+   * The repeat mode to use along the V axis of UV coordinates. This affects the returned values if sampling outside the UV bounds.
+   */
+  repeat_v: int;
+  /**
+   * The repeat mode to use along the W axis of UV coordinates. This affects the returned values if sampling outside the UV bounds. Only effective for 3D samplers.
+   */
+  repeat_w: int;
+  /**
+   * If `true`, the texture will be sampled with coordinates ranging from 0 to the texture's resolution. Otherwise, the coordinates will be normalized and range from 0 to 1.
+   */
+  unnormalized_uvw: boolean;
+  /** If `true`, perform anisotropic sampling. See {@link anisotropy_max}. */
+  use_anisotropy: boolean;
+  set_anisotropy_max(value: float): void;
+  get_anisotropy_max(): float;
+  set_border_color(value: int): void;
+  get_border_color(): int;
+  set_compare_op(value: int): void;
+  get_compare_op(): int;
+  set_enable_compare(value: boolean): void;
+  get_enable_compare(): boolean;
+  set_lod_bias(value: float): void;
+  get_lod_bias(): float;
+  set_mag_filter(value: int): void;
+  get_mag_filter(): int;
+  set_max_lod(value: float): void;
+  get_max_lod(): float;
+  set_min_filter(value: int): void;
+  get_min_filter(): int;
+  set_min_lod(value: float): void;
+  get_min_lod(): float;
+  set_mip_filter(value: int): void;
+  get_mip_filter(): int;
+  set_repeat_u(value: int): void;
+  get_repeat_u(): int;
+  set_repeat_v(value: int): void;
+  get_repeat_v(): int;
+  set_repeat_w(value: int): void;
+  get_repeat_w(): int;
+  set_unnormalized_uvw(value: boolean): void;
+  get_unnormalized_uvw(): boolean;
+  set_use_anisotropy(value: boolean): void;
+  get_use_anisotropy(): boolean;
+}

package/typings/classes/RDShaderFile.d.ts

@@ -0,0 +1,21 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Compiled shader file in SPIR-V form (used by {@link RenderingDevice}). Not to be confused with Godot's own {@link Shader}.
+ */
+declare class RDShaderFile extends Resource {
+  /**
+   * The base compilation error message, which indicates errors not related to a specific shader stage if non-empty. If empty, shader compilation is not necessarily successful (check {@link RDShaderSPIRV}'s error message members).
+   */
+  base_error: string;
+  set_base_error(value: string | NodePath): void;
+  get_base_error(): string;
+
+  /** Returns the SPIR-V intermediate representation for the specified shader `version`. */
+  get_spirv(version?: string): RDShaderSPIRV | null;
+  /** Returns the list of compiled versions for this shader. */
+  get_version_list(): Array<string>;
+  /** Sets the SPIR-V `bytecode` that will be compiled for the specified `version`. */
+  set_bytecode(bytecode: RDShaderSPIRV, version?: string): void;
+}

package/typings/classes/RDShaderSPIRV.d.ts

@@ -0,0 +1,85 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * SPIR-V intermediate representation as part of an {@link RDShaderFile} (used by {@link RenderingDevice}).
+ */
+declare class RDShaderSPIRV extends Resource {
+  /** The SPIR-V bytecode for the any hit shader stage. */
+  bytecode_any_hit: PackedByteArray;
+  /** The SPIR-V bytecode for the closest hit shader stage. */
+  bytecode_closest_hit: PackedByteArray;
+  /** The SPIR-V bytecode for the compute shader stage. */
+  bytecode_compute: PackedByteArray;
+  /** The SPIR-V bytecode for the fragment shader stage. */
+  bytecode_fragment: PackedByteArray;
+  /** The SPIR-V bytecode for the intersection shader stage. */
+  bytecode_intersection: PackedByteArray;
+  /** The SPIR-V bytecode for the miss shader stage. */
+  bytecode_miss: PackedByteArray;
+  /** The SPIR-V bytecode for the ray generation shader stage. */
+  bytecode_raygen: PackedByteArray;
+  /** The SPIR-V bytecode for the tessellation control shader stage. */
+  bytecode_tesselation_control: PackedByteArray;
+  /** The SPIR-V bytecode for the tessellation evaluation shader stage. */
+  bytecode_tesselation_evaluation: PackedByteArray;
+  /** The SPIR-V bytecode for the vertex shader stage. */
+  bytecode_vertex: PackedByteArray;
+  /**
+   * The compilation error message for the any hit shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+   */
+  compile_error_any_hit: string;
+  /**
+   * The compilation error message for the closest hit shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+   */
+  compile_error_closest_hit: string;
+  /**
+   * The compilation error message for the compute shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+   */
+  compile_error_compute: string;
+  /**
+   * The compilation error message for the fragment shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+   */
+  compile_error_fragment: string;
+  /**
+   * The compilation error message for the intersection shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+   */
+  compile_error_intersection: string;
+  /**
+   * The compilation error message for the miss shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+   */
+  compile_error_miss: string;
+  /**
+   * The compilation error message for the ray generation shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+   */
+  compile_error_raygen: string;
+  /**
+   * The compilation error message for the tessellation control shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+   */
+  compile_error_tesselation_control: string;
+  /**
+   * The compilation error message for the tessellation evaluation shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+   */
+  compile_error_tesselation_evaluation: string;
+  /**
+   * The compilation error message for the vertex shader stage (set by the SPIR-V compiler and Godot). If empty, shader compilation was successful.
+   */
+  compile_error_vertex: string;
+
+  /**
+   * Equivalent to getting one of {@link bytecode_compute}, {@link bytecode_fragment}, {@link bytecode_tesselation_control}, {@link bytecode_tesselation_evaluation}, {@link bytecode_vertex}.
+   */
+  get_stage_bytecode(stage: int): PackedByteArray;
+  /**
+   * Returns the compilation error message for the given shader `stage`. Equivalent to getting one of {@link compile_error_compute}, {@link compile_error_fragment}, {@link compile_error_tesselation_control}, {@link compile_error_tesselation_evaluation}, {@link compile_error_vertex}.
+   */
+  get_stage_compile_error(stage: int): string;
+  /**
+   * Sets the SPIR-V `bytecode` for the given shader `stage`. Equivalent to setting one of {@link bytecode_compute}, {@link bytecode_fragment}, {@link bytecode_tesselation_control}, {@link bytecode_tesselation_evaluation}, {@link bytecode_vertex}.
+   */
+  set_stage_bytecode(stage: int, bytecode: PackedByteArray | Array<unknown>): void;
+  /**
+   * Sets the compilation error message for the given shader `stage` to `compile_error`. Equivalent to setting one of {@link compile_error_compute}, {@link compile_error_fragment}, {@link compile_error_tesselation_control}, {@link compile_error_tesselation_evaluation}, {@link compile_error_vertex}.
+   */
+  set_stage_compile_error(stage: int, compile_error: string | NodePath): void;
+}

package/typings/classes/RDShaderSource.d.ts

@@ -0,0 +1,40 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Shader source code (used by {@link RenderingDevice}). */
+declare class RDShaderSource extends RefCounted {
+  /** The language the shader is written in. */
+  language: int;
+  /** Source code for the shader's any hit stage. */
+  source_any_hit: string;
+  /** Source code for the shader's closest hit stage. */
+  source_closest_hit: string;
+  /** Source code for the shader's compute stage. */
+  source_compute: string;
+  /** Source code for the shader's fragment stage. */
+  source_fragment: string;
+  /** Source code for the shader's intersection stage. */
+  source_intersection: string;
+  /** Source code for the shader's miss stage. */
+  source_miss: string;
+  /** Source code for the shader's ray generation stage. */
+  source_raygen: string;
+  /** Source code for the shader's tessellation control stage. */
+  source_tesselation_control: string;
+  /** Source code for the shader's tessellation evaluation stage. */
+  source_tesselation_evaluation: string;
+  /** Source code for the shader's vertex stage. */
+  source_vertex: string;
+  set_language(value: int): void;
+  get_language(): int;
+
+  /**
+   * Returns source code for the specified shader `stage`. Equivalent to getting one of {@link source_compute}, {@link source_fragment}, {@link source_tesselation_control}, {@link source_tesselation_evaluation} or {@link source_vertex}.
+   */
+  get_stage_source(stage: int): string;
+  /**
+   * Sets `source` code for the specified shader `stage`. Equivalent to setting one of {@link source_compute}, {@link source_fragment}, {@link source_tesselation_control}, {@link source_tesselation_evaluation} or {@link source_vertex}.
+   * **Note:** If you set the compute shader source code using this method directly, remember to remove the Godot-specific hint `#[compute]`.
+   */
+  set_stage_source(stage: int, source: string | NodePath): void;
+}

package/typings/classes/RDTextureFormat.d.ts

@@ -0,0 +1,62 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Texture format (used by {@link RenderingDevice}). */
+declare class RDTextureFormat extends RefCounted {
+  /** The number of layers in the texture. Only relevant for 2D texture arrays. */
+  array_layers: int;
+  /** The texture's depth (in pixels). This is always `1` for 2D textures. */
+  depth: int;
+  /** The texture's pixel data format. */
+  format: int;
+  /** The texture's height (in pixels). */
+  height: int;
+  /**
+   * If a texture is discardable, its contents do not need to be preserved between frames. This flag is only relevant when the texture is used as target in a draw list.
+   * This information is used by {@link RenderingDevice} to figure out if a texture's contents can be discarded, eliminating unnecessary writes to memory and boosting performance.
+   */
+  is_discardable: boolean;
+  /** The texture will be used as the destination of a resolve operation. */
+  is_resolve_buffer: boolean;
+  /** The number of mipmaps available in the texture. */
+  mipmaps: int;
+  /** The number of samples used when sampling the texture. */
+  samples: int;
+  /** The texture type. */
+  texture_type: int;
+  /** The texture's usage bits, which determine what can be done using the texture. */
+  usage_bits: int;
+  /** The texture's width (in pixels). */
+  width: int;
+  set_array_layers(value: int): void;
+  get_array_layers(): int;
+  set_depth(value: int): void;
+  get_depth(): int;
+  set_format(value: int): void;
+  get_format(): int;
+  set_height(value: int): void;
+  get_height(): int;
+  set_is_discardable(value: boolean): void;
+  get_is_discardable(): boolean;
+  set_is_resolve_buffer(value: boolean): void;
+  get_is_resolve_buffer(): boolean;
+  set_mipmaps(value: int): void;
+  get_mipmaps(): int;
+  set_samples(value: int): void;
+  get_samples(): int;
+  set_texture_type(value: int): void;
+  get_texture_type(): int;
+  set_usage_bits(value: int): void;
+  get_usage_bits(): int;
+  set_width(value: int): void;
+  get_width(): int;
+
+  /**
+   * Adds `format` as a valid format for the corresponding {@link RDTextureView}'s {@link RDTextureView.format_override} property. If any format is added as shareable, then the main {@link format} must also be added.
+   */
+  add_shareable_format(format: int): void;
+  /**
+   * Removes `format` from the list of valid formats that the corresponding {@link RDTextureView}'s {@link RDTextureView.format_override} property can be set to.
+   */
+  remove_shareable_format(format: int): void;
+}

package/typings/classes/RDTextureView.d.ts

@@ -0,0 +1,28 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Texture view (used by {@link RenderingDevice}). */
+declare class RDTextureView extends RefCounted {
+  /**
+   * Optional override for the data format to return sampled values in. The corresponding {@link RDTextureFormat} must have had this added as a shareable format. The default value of {@link RenderingDevice.DATA_FORMAT_MAX} does not override the format.
+   */
+  format_override: int;
+  /** The channel to sample when sampling the alpha channel. */
+  swizzle_a: int;
+  /** The channel to sample when sampling the blue color channel. */
+  swizzle_b: int;
+  /** The channel to sample when sampling the green color channel. */
+  swizzle_g: int;
+  /** The channel to sample when sampling the red color channel. */
+  swizzle_r: int;
+  set_format_override(value: int): void;
+  get_format_override(): int;
+  set_swizzle_a(value: int): void;
+  get_swizzle_a(): int;
+  set_swizzle_b(value: int): void;
+  get_swizzle_b(): int;
+  set_swizzle_g(value: int): void;
+  get_swizzle_g(): int;
+  set_swizzle_r(value: int): void;
+  get_swizzle_r(): int;
+}

package/typings/classes/RDUniform.d.ts

@@ -0,0 +1,23 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Shader uniform (used by {@link RenderingDevice}). */
+declare class RDUniform extends RefCounted {
+  /** The uniform's binding. */
+  binding: int;
+  /** The uniform's data type. */
+  uniform_type: int;
+  set_binding(value: int): void;
+  get_binding(): int;
+  set_uniform_type(value: int): void;
+  get_uniform_type(): int;
+
+  /**
+   * Binds the given id to the uniform. The data associated with the id is then used when the uniform is passed to a shader.
+   */
+  add_id(id: RID): void;
+  /** Unbinds all ids currently bound to the uniform. */
+  clear_ids(): void;
+  /** Returns an array of all ids currently bound to the uniform. */
+  get_ids(): Array<RID>;
+}

package/typings/classes/RDVertexAttribute.d.ts

@@ -0,0 +1,35 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Vertex attribute (used by {@link RenderingDevice}). */
+declare class RDVertexAttribute extends RefCounted {
+  /**
+   * The index of the buffer in the vertex buffer array to bind this vertex attribute. When set to `-1`, it defaults to the index of the attribute.
+   * **Note:** You cannot mix binding explicitly assigned attributes with implicitly assigned ones (i.e. `-1`). Either all attributes must have their binding set to `-1`, or all must have explicit bindings.
+   */
+  binding: int;
+  /** The way that this attribute's data is interpreted when sent to a shader. */
+  format: int;
+  /** The rate at which this attribute is pulled from its vertex buffer. */
+  frequency: int;
+  /** The location in the shader that this attribute is bound to. */
+  location: int;
+  /**
+   * The number of bytes between the start of the vertex buffer and the first instance of this attribute.
+   */
+  offset: int;
+  /** The number of bytes between the starts of consecutive instances of this attribute. */
+  stride: int;
+  set_binding(value: int): void;
+  get_binding(): int;
+  set_format(value: int): void;
+  get_format(): int;
+  set_frequency(value: int): void;
+  get_frequency(): int;
+  set_location(value: int): void;
+  get_location(): int;
+  set_offset(value: int): void;
+  get_offset(): int;
+  set_stride(value: int): void;
+  get_stride(): int;
+}