@ringozz/godot 0.1.0

package/gen/classes/CameraAttributesPhysical.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 { CameraAttributes } from './CameraAttributes.ts';
+
+/**
+ * {@link CameraAttributesPhysical} is used to set rendering settings based on a physically-based camera's settings. It is responsible for exposure, auto-exposure, and depth of field.
+ * When used in a {@link WorldEnvironment} it provides default settings for exposure, auto-exposure, and depth of field that will be used by all cameras without their own {@link CameraAttributes}, including the editor camera. When used in a {@link Camera3D} it will override any {@link CameraAttributes} set in the {@link WorldEnvironment} and will override the {@link Camera3D}s {@link Camera3D.far}, {@link Camera3D.near}, {@link Camera3D.fov}, and {@link Camera3D.keepAspect} properties. When used in {@link VoxelGI} or {@link LightmapGI}, only the exposure settings will be used.
+ * The default settings are intended for use in an outdoor environment, tips for settings for use in an indoor environment can be found in each setting's documentation.
+ * **Note:** Depth of field blur is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+ * **Note:** Auto-exposure is only supported in the Forward+ rendering method, not Mobile or Compatibility.
+ */
+export class CameraAttributesPhysical extends CameraAttributes {
+    constructor(name = 177) { super(name); }
+
+    /**
+     * Returns the vertical field of view that corresponds to the {@link frustumFocalLength}. This value is calculated internally whenever {@link frustumFocalLength} is changed.
+     */
+    getFov(): number { return _C(this, 4865) as number; }
+
+    /**
+     * Distance from camera of object that will be in focus, measured in meters. Internally this will be clamped to be at least 1 millimeter larger than {@link frustumFocalLength}.
+     */
+    get frustumFocusDistance(): number { return _C(this, 4821) as number; }
+    set frustumFocusDistance(v: number) { _C(this, 11426, v); }
+
+    /**
+     * Distance between camera lens and camera aperture, measured in millimeters. Controls field of view and depth of field. A larger focal length will result in a smaller field of view and a narrower depth of field meaning fewer objects will be in focus. A smaller focal length will result in a wider field of view and a larger depth of field meaning more objects will be in focus. When attached to a {@link Camera3D} as its {@link Camera3D.attributes}, it will override the {@link Camera3D.fov} property and the {@link Camera3D.keepAspect} property.
+     */
+    get frustumFocalLength(): number { return _C(this, 4819) as number; }
+    set frustumFocalLength(v: number) { _C(this, 11424, v); }
+
+    /**
+     * Override value for {@link Camera3D.near}. Used internally when calculating depth of field. When attached to a {@link Camera3D} as its {@link Camera3D.attributes}, it will override the {@link Camera3D.near} property.
+     */
+    get frustumNear(): number { return _C(this, 5616) as number; }
+    set frustumNear(v: number) { _C(this, 12124, v); }
+
+    /**
+     * Override value for {@link Camera3D.far}. Used internally when calculating depth of field. When attached to a {@link Camera3D} as its {@link Camera3D.attributes}, it will override the {@link Camera3D.far} property.
+     */
+    get frustumFar(): number { return _C(this, 4758) as number; }
+    set frustumFar(v: number) { _C(this, 11369, v); }
+
+    /**
+     * Size of the aperture of the camera, measured in f-stops. An f-stop is a unitless ratio between the focal length of the camera and the diameter of the aperture. A high aperture setting will result in a smaller aperture which leads to a dimmer image and sharper focus. A low aperture results in a wide aperture which lets in more light resulting in a brighter, less-focused image. Default is appropriate for outdoors at daytime (i.e. for use with a default {@link DirectionalLight3D}), for indoor lighting, a value between 2 and 4 is more appropriate.
+     * Only available when {@link ProjectSettings.rendering/lightsAndShadows/usePhysicalLightUnits} is enabled.
+     */
+    get exposureAperture(): number { return _C(this, 3780) as number; }
+    set exposureAperture(v: number) { _C(this, 10518, v); }
+
+    /**
+     * Time for shutter to open and close, evaluated as `1 / shutter_speed` seconds. A higher value will allow less light (leading to a darker image), while a lower value will allow more light (leading to a brighter image).
+     * Only available when {@link ProjectSettings.rendering/lightsAndShadows/usePhysicalLightUnits} is enabled.
+     */
+    get exposureShutterSpeed(): number { return _C(this, 6387) as number; }
+    set exposureShutterSpeed(v: number) { _C(this, 12745, v); }
+
+    /**
+     * The minimum luminance (in EV100) used when calculating auto exposure. When calculating scene average luminance, color values will be clamped to at least this value. This limits the auto-exposure from exposing above a certain brightness, resulting in a cut off point where the scene will remain dark.
+     */
+    get autoExposureMinExposureValue(): number { return _C(this, 3834) as number; }
+    set autoExposureMinExposureValue(v: number) { _C(this, 10573, v); }
+
+    /**
+     * The maximum luminance (in EV100) used when calculating auto exposure. When calculating scene average luminance, color values will be clamped to at least this value. This limits the auto-exposure from exposing below a certain brightness, resulting in a cut off point where the scene will remain bright.
+     */
+    get autoExposureMaxExposureValue(): number { return _C(this, 3832) as number; }
+    set autoExposureMaxExposureValue(v: number) { _C(this, 10571, v); }
+
+    static readonly name = _R(177, CameraAttributesPhysical);
+}

package/gen/classes/CameraAttributesPractical.ts

@@ -0,0 +1,75 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { CameraAttributes } from './CameraAttributes.ts';
+
+/**
+ * Controls camera-specific attributes such as auto-exposure, depth of field, and exposure override.
+ * When used in a {@link WorldEnvironment} it provides default settings for exposure, auto-exposure, and depth of field that will be used by all cameras without their own {@link CameraAttributes}, including the editor camera. When used in a {@link Camera3D} it will override any {@link CameraAttributes} set in the {@link WorldEnvironment}. When used in {@link VoxelGI} or {@link LightmapGI}, only the exposure settings will be used.
+ * **Note:** Depth of field blur is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+ * **Note:** Auto-exposure is only supported in the Forward+ rendering method, not Mobile or Compatibility.
+ */
+export class CameraAttributesPractical extends CameraAttributes {
+    constructor(name = 178) { super(name); }
+
+    /**
+     * Enables depth of field blur for objects further than {@link dofBlurFarDistance}. Strength of blur is controlled by {@link dofBlurAmount} and modulated by {@link dofBlurFarTransition}.
+     * **Note:** Depth of field blur is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+     * **Note:** Depth of field blur is not supported on viewports that have a transparent background (where {@link Viewport.transparentBg} is `true`).
+     */
+    get dofBlurFarEnabled(): boolean { return _C(this, 7888) as boolean; }
+    set dofBlurFarEnabled(v: boolean) { _C(this, 11142, v); }
+
+    /**
+     * Objects further from the {@link Camera3D} by this amount will be blurred by the depth of field effect. Measured in meters.
+     */
+    get dofBlurFarDistance(): number { return _C(this, 4532) as number; }
+    set dofBlurFarDistance(v: number) { _C(this, 11141, v); }
+
+    /**
+     * When positive, distance over which (starting from {@link dofBlurFarDistance}) blur effect will scale from 0 to {@link dofBlurAmount}. When negative, uses physically-based scaling so depth of field effect will scale from 0 at {@link dofBlurFarDistance} and will increase in a physically accurate way as objects get further from the {@link Camera3D}.
+     */
+    get dofBlurFarTransition(): number { return _C(this, 4533) as number; }
+    set dofBlurFarTransition(v: number) { _C(this, 11143, v); }
+
+    /**
+     * Enables depth of field blur for objects closer than {@link dofBlurNearDistance}. Strength of blur is controlled by {@link dofBlurAmount} and modulated by {@link dofBlurNearTransition}.
+     * **Note:** Depth of field blur is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+     * **Note:** Depth of field blur is not supported on viewports that have a transparent background (where {@link Viewport.transparentBg} is `true`).
+     */
+    get dofBlurNearEnabled(): boolean { return _C(this, 7889) as boolean; }
+    set dofBlurNearEnabled(v: boolean) { _C(this, 11145, v); }
+
+    /**
+     * Objects closer from the {@link Camera3D} by this amount will be blurred by the depth of field effect. Measured in meters.
+     */
+    get dofBlurNearDistance(): number { return _C(this, 4534) as number; }
+    set dofBlurNearDistance(v: number) { _C(this, 11144, v); }
+
+    /**
+     * When positive, distance over which blur effect will scale from 0 to {@link dofBlurAmount}, ending at {@link dofBlurNearDistance}. When negative, uses physically-based scaling so depth of field effect will scale from 0 at {@link dofBlurNearDistance} and will increase in a physically accurate way as objects get closer to the {@link Camera3D}.
+     */
+    get dofBlurNearTransition(): number { return _C(this, 4535) as number; }
+    set dofBlurNearTransition(v: number) { _C(this, 11146, v); }
+
+    /**
+     * Sets the maximum amount of blur. When using physically-based blur amounts, will instead act as a multiplier. High values lead to an increased amount of blurriness, but can be much more expensive to calculate. It is best to keep this as low as possible for a given art style.
+     */
+    get dofBlurAmount(): number { return _C(this, 4531) as number; }
+    set dofBlurAmount(v: number) { _C(this, 11140, v); }
+
+    /**
+     * The minimum sensitivity (in ISO) used when calculating auto exposure. When calculating scene average luminance, color values will be clamped to at least this value. This limits the auto-exposure from exposing above a certain brightness, resulting in a cut off point where the scene will remain dark.
+     */
+    get autoExposureMinSensitivity(): number { return _C(this, 3835) as number; }
+    set autoExposureMinSensitivity(v: number) { _C(this, 10574, v); }
+
+    /**
+     * The maximum sensitivity (in ISO) used when calculating auto exposure. When calculating scene average luminance, color values will be clamped to at least this value. This limits the auto-exposure from exposing below a certain brightness, resulting in a cut off point where the scene will remain bright.
+     */
+    get autoExposureMaxSensitivity(): number { return _C(this, 3833) as number; }
+    set autoExposureMaxSensitivity(v: number) { _C(this, 10572, v); }
+
+    static readonly name = _R(178, CameraAttributesPractical);
+}

package/gen/classes/CameraFeed.ts

@@ -0,0 +1,155 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { GodotArray, GodotDictionary, Signal } from '../heap-types/index.ts';
+import type { Transform2D } from '../value-types/index.ts';
+import type { FeedImage } from './CameraServer.ts';
+import type { Image } from './Image.ts';
+
+/**
+ * A camera feed gives you access to a single physical camera attached to your device. When enabled, Godot will start capturing frames from the camera which can then be used. See also {@link CameraServer}.
+ * **Note:** Many cameras will return YCbCr images which are split into two textures and need to be combined in a shader. Godot does this automatically for you if you set the environment to show the camera image in the background.
+ * **Note:** This class is currently only implemented on Linux, Android, macOS, and iOS. On other platforms no {@link CameraFeed}s will be available. To get a {@link CameraFeed} on iOS, enable {@link EditorExportPlatformIOS.modules/camera}.
+ */
+export class CameraFeed extends RefCounted {
+    constructor(name = 179) { super(name); }
+
+    /**
+     * Returns the unique ID for this feed.
+     */
+    getId(): number { return _C(this, 5062) as number; }
+
+    /**
+     * Returns the camera's name.
+     */
+    getName(): string { return _C(this, 5602) as string; }
+
+    /**
+     * Sets the camera's name.
+     */
+    setName(name: string): void { _C(this, 12113, name); }
+
+    /**
+     * Returns the position of camera on the device.
+     */
+    getPosition(): FeedPosition { return _C(this, 5973) as FeedPosition; }
+
+    /**
+     * Sets the position of this camera.
+     */
+    setPosition(position: FeedPosition): void { _C(this, 12381, position); }
+
+    /**
+     * Sets RGB image for this feed.
+     */
+    setRgbImage(rgbImage: Image): void { _C(this, 12554, rgbImage); }
+
+    /**
+     * Sets YCbCr image for this feed.
+     */
+    setYcbcrImage(ycbcrImage: Image): void { _C(this, 13401, ycbcrImage); }
+
+    /**
+     * Sets Y and CbCr images for this feed.
+     */
+    setYcbcrImages(yImage: Image, cbcrImage: Image): void { _C(this, 13402, yImage, cbcrImage); }
+
+    /**
+     * Sets the feed as external feed provided by another library.
+     */
+    setExternal(width: number, height: number): void { _C(this, 11335, width, height); }
+
+    /**
+     * Returns the texture backend ID (usable by some external libraries that need a handle to a texture to write data).
+     */
+    getTextureTexId(feedImageType: FeedImage): number { return _C(this, 6756, feedImageType) as number; }
+
+    /**
+     * Returns feed image data type.
+     */
+    getDatatype(): FeedDataType { return _C(this, 4415) as FeedDataType; }
+
+    /**
+     * Sets the feed format parameters for the given `index` in the {@link formats} array. Returns `true` on success. By default, the YUYV encoded stream is transformed to {@link FEED_RGB}. The YUYV encoded stream output format can be changed by setting `parameters`'s `output` entry to one of the following:
+     * - `"separate"` will result in {@link FEED_YCBCR_SEP};
+     * - `"grayscale"` will result in desaturated {@link FEED_RGB};
+     * - `"copy"` will result in {@link FEED_YCBCR}.
+     */
+    setFormat(index: number, parameters: GodotDictionary): boolean { return _C(this, 11465, index, parameters) as boolean; }
+
+    /**
+     * If `true`, the feed is active.
+     */
+    get feedIsActive(): boolean { return _C(this, 7746) as boolean; }
+    set feedIsActive(v: boolean) { _C(this, 10426, v); }
+
+    /**
+     * The transform applied to the camera's image.
+     */
+    get feedTransform(): Transform2D { return _C(this, 6874) as Transform2D; }
+    set feedTransform(v: Transform2D) { _C(this, 13134, v); }
+
+    /**
+     * Formats supported by the feed. Each entry is a {@link Dictionary} describing format parameters.
+     */
+    get formats(): GodotArray { return _C(this, 4863) as GodotArray; }
+
+    /**
+     * Emitted when a new frame is available.
+     */
+    get frameChanged(): Signal<() => void> { return _G(this, 3564) as Signal<() => void>; }
+    set frameChanged(v: (() => void) | null) { _G(this, 3564, v); }
+
+    /**
+     * Emitted when the format has changed.
+     */
+    get formatChanged(): Signal<() => void> { return _G(this, 3545) as Signal<() => void>; }
+    set formatChanged(v: (() => void) | null) { _G(this, 3545, v); }
+
+    static readonly name = _R(179, CameraFeed);
+}
+
+export const FeedDataType = {
+    /**
+     * No image set for the feed.
+     */
+    FEED_NOIMAGE: 0,
+    /**
+     * Feed supplies RGB images.
+     */
+    FEED_RGB: 1,
+    /**
+     * Feed supplies YCbCr images that need to be converted to RGB.
+     */
+    FEED_YCBCR: 2,
+    /**
+     * Feed supplies separate Y and CbCr images that need to be combined and converted to RGB.
+     */
+    FEED_YCBCR_SEP: 3,
+    /**
+     * Feed supplies external image.
+     */
+    FEED_EXTERNAL: 4,
+} as const;
+
+export type FeedDataType = (typeof FeedDataType)[keyof typeof FeedDataType];
+
+export const FeedPosition = {
+    /**
+     * Unspecified position.
+     */
+    FEED_UNSPECIFIED: 0,
+    /**
+     * Camera is mounted at the front of the device.
+     */
+    FEED_FRONT: 1,
+    /**
+     * Camera is mounted at the back of the device.
+     */
+    FEED_BACK: 2,
+} as const;
+
+export type FeedPosition = (typeof FeedPosition)[keyof typeof FeedPosition];
+

package/gen/classes/CameraServer.ts

@@ -0,0 +1,105 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar, _G } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { GodotArray, Signal } from '../heap-types/index.ts';
+import type { CameraFeed } from './CameraFeed.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 180));
+
+/**
+ * The {@link CameraServer} keeps track of different cameras accessible in Godot. These are external cameras such as webcams or the cameras on your phone.
+ * It is notably used to provide AR modules with a video feed from the camera.
+ * **Note:** This class is currently only implemented on Linux, Android, macOS, and iOS. On other platforms no {@link CameraFeed}s will be available. To get a {@link CameraFeed} on iOS, enable {@link EditorExportPlatformIOS.modules/camera}.
+ */
+export class CameraServer extends GodotVar {
+
+    /**
+     * Returns the {@link CameraFeed} corresponding to the camera with the given `index`.
+     */
+    static getFeed(index: number): CameraFeed { return _C($(), 4763, index) as CameraFeed; }
+
+    /**
+     * Returns the number of {@link CameraFeed}s registered.
+     */
+    static getFeedCount(): number { return _C($(), 4764) as number; }
+
+    /**
+     * Returns an array of {@link CameraFeed}s.
+     */
+    static feeds(): GodotArray<CameraFeed> { return _C($(), 3242) as GodotArray<CameraFeed>; }
+
+    /**
+     * Adds the camera `feed` to the camera server.
+     */
+    static addFeed(feed: CameraFeed): void { _C($(), 1216, feed); }
+
+    /**
+     * Removes the specified camera `feed`.
+     */
+    static removeFeed(feed: CameraFeed): void { _C($(), 9912, feed); }
+
+    /**
+     * If `true`, the server is actively monitoring available camera feeds.
+     * This has a performance cost, so only set it to `true` when you're actively accessing the camera.
+     * **Note:** After setting it to `true`, you can receive updated camera feeds through the {@link camera_feeds_updated} signal.
+     *
+     *
+     * ```gdscript
+     *
+     * func _ready():
+     * 	CameraServer.camera_feeds_updated.connect(_on_camera_feeds_updated)
+     * 	CameraServer.monitoring_feeds = true
+     *
+     * func _on_camera_feeds_updated():
+     * 	var feeds = CameraServer.feeds()
+     *
+     * ```
+     */
+    static get monitoringFeeds(): boolean { return _C($(), 8113) as boolean; }
+    static set monitoringFeeds(v: boolean) { _C($(), 12085, v); }
+
+    /**
+     * Emitted when a {@link CameraFeed} is added (e.g. a webcam is plugged in).
+     */
+    static get cameraFeedAdded(): Signal<(id: number) => void> { return _G($(), 1990) as Signal<(id: number) => void>; }
+    static set cameraFeedAdded(v: ((id: number) => void) | null) { _G($(), 1990, v); }
+
+    /**
+     * Emitted when a {@link CameraFeed} is removed (e.g. a webcam is unplugged).
+     */
+    static get cameraFeedRemoved(): Signal<(id: number) => void> { return _G($(), 1992) as Signal<(id: number) => void>; }
+    static set cameraFeedRemoved(v: ((id: number) => void) | null) { _G($(), 1992, v); }
+
+    /**
+     * Emitted when camera feeds are updated.
+     */
+    static get cameraFeedsUpdated(): Signal<() => void> { return _G($(), 1993) as Signal<() => void>; }
+    static set cameraFeedsUpdated(v: (() => void) | null) { _G($(), 1993, v); }
+
+    static readonly name = _R(180, CameraServer);
+}
+
+export const FeedImage = {
+    /**
+     * The RGBA camera image.
+     */
+    FEED_RGBA_IMAGE: 0,
+    /**
+     * The [YCbCr](https://en.wikipedia.org/wiki/YCbCr) camera image.
+     */
+    FEED_YCBCR_IMAGE: 0,
+    /**
+     * The Y component camera image.
+     */
+    FEED_Y_IMAGE: 0,
+    /**
+     * The CbCr component camera image.
+     */
+    FEED_CBCR_IMAGE: 1,
+} as const;
+
+export type FeedImage = (typeof FeedImage)[keyof typeof FeedImage];
+

package/gen/classes/CameraTexture.ts

@@ -0,0 +1,34 @@
+// 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 { FeedImage } from './CameraServer.ts';
+
+/**
+ * This texture gives access to the camera texture provided by a {@link CameraFeed}.
+ * **Note:** Many cameras supply YCbCr images which need to be converted in a shader.
+ */
+export class CameraTexture extends Texture2D {
+    constructor(name = 181) { super(name); }
+
+    /**
+     * The ID of the {@link CameraFeed} for which we want to display the image.
+     */
+    get cameraFeedId(): number { return _C(this, 4064) as number; }
+    set cameraFeedId(v: number) { _C(this, 10786, v); }
+
+    /**
+     * Which image within the {@link CameraFeed} we want access to, important if the camera image is split in a Y and CbCr component.
+     */
+    get whichFeed(): FeedImage { return _C(this, 7146) as FeedImage; }
+    set whichFeed(v: FeedImage) { _C(this, 13371, v); }
+
+    /**
+     * Convenience property that gives access to the active property of the {@link CameraFeed}.
+     */
+    get cameraIsActive(): boolean { return _C(this, 4062) as boolean; }
+    set cameraIsActive(v: boolean) { _C(this, 10784, v); }
+
+    static readonly name = _R(181, CameraTexture);
+}

package/gen/classes/CanvasGroup.ts

@@ -0,0 +1,54 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+
+/**
+ * Child {@link CanvasItem} nodes of a {@link CanvasGroup} are drawn as a single object. It allows to e.g. draw overlapping translucent 2D nodes without causing the overlapping sections to be more opaque than intended (set the {@link CanvasItem.selfModulate} property on the {@link CanvasGroup} to achieve this effect).
+ * **Note:** The {@link CanvasGroup} uses a custom shader to read from the backbuffer to draw its children. Assigning a {@link Material} to the {@link CanvasGroup} overrides the built-in shader. To duplicate the behavior of the built-in shader in a custom {@link Shader}, use the following:
+ *
+ * ```text
+ *
+ * shader_type canvas_item;
+ * render_mode unshaded;
+ *
+ * uniform sampler2D screen_texture : hint_screen_texture, repeat_disable, filter_nearest;
+ *
+ * void fragment() {
+ * 	vec4 c = textureLod(screen_texture, SCREEN_UV, 0.0);
+ *
+ * 	if (c.a > 0.0001) {
+ * 		c.rgb /= c.a;
+ * 	}
+ *
+ * 	COLOR *= c;
+ * }
+ *
+ * ```
+ *
+ * **Note:** Since {@link CanvasGroup} and {@link CanvasItem.clipChildren} both utilize the backbuffer, children of a {@link CanvasGroup} who have their {@link CanvasItem.clipChildren} set to anything other than {@link CanvasItem.CLIP_CHILDREN_DISABLED} will not function correctly.
+ */
+export class CanvasGroup extends Node2D {
+    constructor(name = 182) { super(name); }
+
+    /**
+     * Sets the size of a margin used to expand the drawable rect of this {@link CanvasGroup}. The size of the {@link CanvasGroup} is determined by fitting a rect around its children then expanding that rect by {@link fitMargin}. This increases both the backbuffer area used and the area covered by the {@link CanvasGroup} both of which can reduce performance. This should be kept as small as possible and should only be expanded when an increased size is needed (e.g. for custom shader effects).
+     */
+    get fitMargin(): number { return _C(this, 4796) as number; }
+    set fitMargin(v: number) { _C(this, 11400, v); }
+
+    /**
+     * Sets the size of the margin used to expand the clearing rect of this {@link CanvasGroup}. This expands the area of the backbuffer that will be used by the {@link CanvasGroup}. A smaller margin will reduce the area of the backbuffer used which can increase performance, however if {@link useMipmaps} is enabled, a small margin may result in mipmap errors at the edge of the {@link CanvasGroup}. Accordingly, this should be left as small as possible, but should be increased if artifacts appear along the edges of the canvas group.
+     */
+    get clearMargin(): number { return _C(this, 4152) as number; }
+    set clearMargin(v: number) { _C(this, 10856, v); }
+
+    /**
+     * If `true`, calculates mipmaps for the backbuffer before drawing the {@link CanvasGroup} so that mipmaps can be used in a custom {@link ShaderMaterial} attached to the {@link CanvasGroup}. Generating mipmaps has a performance cost so this should not be enabled unless required.
+     */
+    get useMipmaps(): boolean { return _C(this, 8410) as boolean; }
+    set useMipmaps(v: boolean) { _C(this, 13226, v); }
+
+    static readonly name = _R(182, CanvasGroup);
+}