RenderingServer

public static bool RenderLoopEnabled { get; set; }

If false, disables rendering completely, but the engine logic is still being processed. You can call RenderingServer.ForceDraw to draw a frame even with rendering disabled.

public static Rid AreaLightCreate();

Creates a new area light and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID can be used in most light_* RenderingServer functions. Once finished with your RID, you will want to free the RID using the RenderingServer's RenderingServer.FreeRid method. To place in a scene, attach this area light to an instance using RenderingServer.InstanceSetBase using the returned RID. Note: The equivalent node is AreaLight3D.

public static Reckfell.Collections.Array<Image> BakeRenderUV2(Rid @base, Reckfell.Collections.Array<Rid> materialOverrides, Vector2I imageSize);

Bakes the material data of the Mesh passed in the base parameter with optional material_overrides to a set of Images of size image_size. Returns an array of Images containing material properties as specified in RenderingServer.BakeChannels.

public static void CallOnRenderThread(Callable callable);

As the RenderingServer actual logic may run on a separate thread, accessing its internals from the main (or any other) thread will result in errors. To make it easier to run code that can safely access the rendering internals (such as RenderingDevice and similar RD classes), push a callable via this function so it will be executed on the render thread.

public static Rid CameraAttributesCreate();

Creates a camera attributes object and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all camera_attributes_ RenderingServer functions. Once finished with your RID, you will want to free the RID using the RenderingServer's RenderingServer.FreeRid method. Note: The equivalent resource is CameraAttributes.

public static void CameraAttributesSetAutoExposure(Rid cameraAttributes, bool enable, float minSensitivity, float maxSensitivity, float speed, float scale);

Sets the parameters to use with the auto-exposure effect. These parameters take on the same meaning as their counterparts in CameraAttributes and CameraAttributesPractical.

public static void CameraAttributesSetDofBlur(Rid cameraAttributes, bool farEnable, float farDistance, float farTransition, bool nearEnable, float nearDistance, float nearTransition, float amount);

Sets the parameters to use with the DOF blur effect. These parameters take on the same meaning as their counterparts in CameraAttributesPractical.

public static void CameraAttributesSetDofBlurBokehShape(RenderingServer.DofBokehShape shape);

Sets the shape of the DOF bokeh pattern to shape. Different shapes may be used to achieve artistic effect, or to meet performance targets.

public static void CameraAttributesSetDofBlurQuality(RenderingServer.DofBlurQuality quality, bool useJitter);

Sets the quality level of the DOF blur effect to quality. use_jitter can be used to jitter samples taken during the blur pass to hide artifacts at the cost of looking more fuzzy.

public static void CameraAttributesSetExposure(Rid cameraAttributes, float multiplier, float normalization);

Sets the exposure values that will be used by the renderers. The normalization amount is used to bake a given Exposure Value (EV) into rendering calculations to reduce the dynamic range of the scene. The normalization factor can be calculated from exposure value (EV100) as follows:

The exposure value can be calculated from aperture (in f-stops), shutter speed (in seconds), and sensitivity (in ISO) as follows:

public static Rid CameraCreate();

Creates a 3D camera and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all camera_* RenderingServer functions. Once finished with your RID, you will want to free the RID using the RenderingServer's RenderingServer.FreeRid method. Note: The equivalent node is Camera3D.

public static void CameraSetCameraAttributes(Rid camera, Rid effects);

Sets the camera_attributes created with RenderingServer.CameraAttributesCreate to the given camera.

public static void CameraSetCompositor(Rid camera, Rid compositor);

Sets the compositor used by this camera. Equivalent to Camera3D.Compositor.

public static void CameraSetCullMask(Rid camera, uint layers);

Sets the cull mask associated with this camera. The cull mask describes which 3D layers are rendered by this camera. Equivalent to Camera3D.CullMask.

public static void CameraSetEnvironment(Rid camera, Rid env);

Sets the environment used by this camera. Equivalent to Camera3D.Environment.

public static void CameraSetFrustum(Rid camera, float size, Vector2 offset, float zNear, float zFar);

Sets camera to use frustum projection. This mode allows adjusting the offset argument to create "tilted frustum" effects.

public static void CameraSetOrthogonal(Rid camera, float size, float zNear, float zFar);

Sets camera to use orthogonal projection, also known as orthographic projection. Objects remain the same size on the screen no matter how far away they are.

public static void CameraSetPerspective(Rid camera, float fovyDegrees, float zNear, float zFar);

Sets camera to use perspective projection. Objects on the screen becomes smaller when they are far away.

public static void CameraSetTransform(Rid camera, Transform3D transform);

Sets Transform3D of camera.

public static void CameraSetUseVerticalAspect(Rid camera, bool enable);

If true, preserves the horizontal aspect ratio which is equivalent to Camera3D.KeepAspectEnum.Width. If false, preserves the vertical aspect ratio which is equivalent to Camera3D.KeepAspectEnum.Height.

public static void CameraSetXRProjections(Rid camera, Reckfell.Collections.Array<Projection> projections, Reckfell.Collections.Array<Transform3D> offsets = null);

Sets camera to use any set of projections. You can specify one projection for each view set on the viewport. If the views are offset (e.g. ocular distance) and/or skewed, this data can be provided through offsets.

public static Rid CanvasCreate();

Creates a canvas and returns the assigned Rid. It can be accessed with the RID that is returned. This RID will be used in all canvas_* RenderingServer functions. Once finished with your RID, you will want to free the RID using the RenderingServer's RenderingServer.FreeRid method. Canvas has no Resource or Entity equivalent.

public static void CanvasItemAddAnimationSlice(Rid item, double animationLength, double sliceBegin, double sliceEnd, double offset = 0d);

Subsequent drawing commands will be ignored unless they fall within the specified animation slice. This is a faster way to implement animations that loop on background rather than redrawing constantly.

public static void CanvasItemAddCircle(Rid item, Vector2 pos, float radius, Color color);

Draws a circle on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawCircle.

public static void CanvasItemAddCircle(Rid item, Vector2 pos, float radius, Color color, bool antialiased = false);

Draws a circle on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawCircle.

public static void CanvasItemAddClipIgnore(Rid item, bool ignore);

If ignore is true, ignore clipping on items drawn with this canvas item until this is called again with ignore set to false.

public static void CanvasItemAddEllipse(Rid item, Vector2 pos, float major, float minor, Color color, bool antialiased = false);

Draws an ellipse with semi-major axis major and semi-minor axis minor on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawEllipse.

public static void CanvasItemAddLcdTextureRectRegion(Rid item, Rect2 rect, Rid texture, Rect2 srcRect, Color modulate);

See also CanvasItem.DrawLcdTextureRectRegion.

public static void CanvasItemAddLine(Rid item, Vector2 from, Vector2 to, Color color, float width = -1f, bool antialiased = false);

Draws a line on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawLine.

public static void CanvasItemAddMesh(Rid item, Rid mesh, Transform2D? transform = default, Color? modulate = default, Rid texture = default);

Draws a mesh created with RenderingServer.MeshCreate with given transform, modulate color, and texture. This is used internally by MeshInstance2D.

public static void CanvasItemAddMsdfTextureRectRegion(Rid item, Rect2 rect, Rid texture, Rect2 srcRect, Color? modulate = default, int outlineSize = 0, float pxRange = 1f, float scale = 1f);

See also CanvasItem.DrawMsdfTextureRectRegion.

public static void CanvasItemAddMultiline(Rid item, Vector2[] points, Color[] colors, float width);

Draws a 2D multiline on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawMultiline and CanvasItem.DrawMultilineColors.

public static void CanvasItemAddMultiline(Rid item, Vector2[] points, Color[] colors, float width = -1f, bool antialiased = false);

Draws a 2D multiline on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawMultiline and CanvasItem.DrawMultilineColors.

public static void CanvasItemAddMultiline(Rid item, ReadOnlySpan<Vector2> points, ReadOnlySpan<Color> colors, float width);

Draws a 2D multiline on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawMultiline and CanvasItem.DrawMultilineColors.

public static void CanvasItemAddMultiline(Rid item, ReadOnlySpan<Vector2> points, ReadOnlySpan<Color> colors, float width, bool antialiased);

Draws a 2D multiline on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawMultiline and CanvasItem.DrawMultilineColors.

public static void CanvasItemAddMultimesh(Rid item, Rid mesh, Rid texture = default);

Draws a 2D MultiMesh on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawMultimesh.

public static void CanvasItemAddNinePatch(Rid item, Rect2 rect, Rect2 source, Rid texture, Vector2 topleft, Vector2 bottomright, RenderingServer.NinePatchAxisMode xAxisMode = RenderingServer.NinePatchAxisMode.Stretch, RenderingServer.NinePatchAxisMode yAxisMode = RenderingServer.NinePatchAxisMode.Stretch, bool drawCenter = true, Color? modulate = default);

Draws a nine-patch rectangle on the CanvasItem pointed to by the item Rid.

public static void CanvasItemAddParticles(Rid item, Rid particles, Rid texture);

Draws particles on the CanvasItem pointed to by the item Rid.

public static void CanvasItemAddPolygon(Rid item, Vector2[] points, Color[] colors, Vector2[] uvs = null, Rid texture = default);

Draws a 2D polygon on the CanvasItem pointed to by the item Rid. If you need more flexibility (such as being able to use bones), use RenderingServer.CanvasItemAddTriangleArray instead. See also CanvasItem.DrawPolygon. Note: If you frequently redraw the same polygon with a large number of vertices, consider pre-calculating the triangulation with Geometry2D.TriangulatePolygon and using CanvasItem.DrawMesh, CanvasItem.DrawMultimesh, or RenderingServer.CanvasItemAddTriangleArray.

public static void CanvasItemAddPolygon(Rid item, ReadOnlySpan<Vector2> points, ReadOnlySpan<Color> colors, ReadOnlySpan<Vector2> uvs, Rid texture);

Draws a 2D polygon on the CanvasItem pointed to by the item Rid. If you need more flexibility (such as being able to use bones), use RenderingServer.CanvasItemAddTriangleArray instead. See also CanvasItem.DrawPolygon. Note: If you frequently redraw the same polygon with a large number of vertices, consider pre-calculating the triangulation with Geometry2D.TriangulatePolygon and using CanvasItem.DrawMesh, CanvasItem.DrawMultimesh, or RenderingServer.CanvasItemAddTriangleArray.

public static void CanvasItemAddPolyline(Rid item, Vector2[] points, Color[] colors, float width = -1f, bool antialiased = false);

Draws a 2D polyline on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawPolyline and CanvasItem.DrawPolylineColors.

public static void CanvasItemAddPolyline(Rid item, ReadOnlySpan<Vector2> points, ReadOnlySpan<Color> colors, float width, bool antialiased);

Draws a 2D polyline on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawPolyline and CanvasItem.DrawPolylineColors.

public static void CanvasItemAddPrimitive(Rid item, Vector2[] points, Color[] colors, Vector2[] uvs, Rid texture);

Draws a 2D primitive on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawPrimitive.

public static void CanvasItemAddPrimitive(Rid item, ReadOnlySpan<Vector2> points, ReadOnlySpan<Color> colors, ReadOnlySpan<Vector2> uvs, Rid texture);

Draws a 2D primitive on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawPrimitive.

public static void CanvasItemAddRect(Rid item, Rect2 rect, Color color);

Draws a rectangle on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawRect.

public static void CanvasItemAddRect(Rid item, Rect2 rect, Color color, bool antialiased = false);

Draws a rectangle on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawRect.

public static void CanvasItemAddSetTransform(Rid item, Transform2D transform);

Sets a Transform2D that will be used to transform subsequent canvas item commands.

public static void CanvasItemAddTextureRect(Rid item, Rect2 rect, Rid texture, bool tile = false, Color? modulate = default, bool transpose = false);

Draws a 2D textured rectangle on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawTextureRect and Texture2D.DrawRect.

public static void CanvasItemAddTextureRectRegion(Rid item, Rect2 rect, Rid texture, Rect2 srcRect, Color? modulate = default, bool transpose = false, bool clipUV = true);

Draws the specified region of a 2D textured rectangle on the CanvasItem pointed to by the item Rid. See also CanvasItem.DrawTextureRectRegion and Texture2D.DrawRectRegion.

public static void CanvasItemAddTriangleArray(Rid item, int[] indices, Vector2[] points, Color[] colors, Vector2[] uvs = null, int[] bones = null, float[] weights = null, Rid texture = default, int count = -1);

Draws a triangle array on the CanvasItem pointed to by the item Rid. This is internally used by Line2D and StyleBoxFlat for rendering. RenderingServer.CanvasItemAddTriangleArray is highly flexible, but more complex to use than RenderingServer.CanvasItemAddPolygon. Note: If count is set to a non-negative value, only the first count * 3 indices (corresponding to [code skip-lint]count` triangles) will be drawn. Otherwise, all indices are drawn.

public static void CanvasItemAddTriangleArray(Rid item, ReadOnlySpan<int> indices, ReadOnlySpan<Vector2> points, ReadOnlySpan<Color> colors, ReadOnlySpan<Vector2> uvs, ReadOnlySpan<int> bones, ReadOnlySpan<float> weights, Rid texture, int count);

Draws a triangle array on the CanvasItem pointed to by the item Rid. This is internally used by Line2D and StyleBoxFlat for rendering. RenderingServer.CanvasItemAddTriangleArray is highly flexible, but more complex to use than RenderingServer.CanvasItemAddPolygon. Note: If count is set to a non-negative value, only the first count * 3 indices (corresponding to [code skip-lint]count` triangles) will be drawn. Otherwise, all indices are drawn.

public static void CanvasItemAttachSkeleton(Rid item, Rid skeleton);

Attaches a skeleton to the CanvasItem. Removes the previous skeleton.

public static void CanvasItemClear(Rid item);

Clears the CanvasItem and removes all commands in it.

public static Rid CanvasItemCreate();

Creates a new CanvasItem instance and returns its Rid. It can be accessed with the RID that is returned. This RID will be used in all canvas_item_* RenderingServer functions. Once finished with your RID, you will want to free the RID using the RenderingServer's RenderingServer.FreeRid method. Note: The equivalent node is CanvasItem.

public static Variant CanvasItemGetInstanceShaderParameter(Rid instance, StringName parameter);

Reads a parameter value from the canvas-item instance registry. An absent entry yields Nil; a returned value alone does not prove the name is declared by the current shader.

public static Variant CanvasItemGetInstanceShaderParameterDefaultValue(Rid instance, StringName parameter);

Returns the declared default known to the instance registry. Can return Nil before material preparation or for an absent name; this is not the current override.

public static Reckfell.Collections.Array<Reckfell.Collections.Dictionary> CanvasItemGetInstanceShaderParameterList(Rid instance);

Updates dirty canvas items and returns available instance-parameter descriptions. This is metadata, not a global-parameter list or ShaderMaterial values.

public static void CanvasItemResetPhysicsInterpolation(Rid item);

Prevents physics interpolation for the current physics tick. This is useful when moving a canvas item to a new location, to give an instantaneous change rather than interpolation from the previous location.

public static void CanvasItemSetCanvasGroupMode(Rid item, RenderingServer.CanvasGroupMode mode, float clearMargin = 5f, bool fitEmpty = false, float fitMargin = 0f, bool blurMipmaps = false);

Sets the canvas group mode used during 2D rendering for the canvas item specified by the item RID. For faster but more limited clipping, use RenderingServer.CanvasItemSetClip instead. Note: The equivalent node functionality is found in CanvasGroup and CanvasItem.ClipChildren.

public static void CanvasItemSetClip(Rid item, bool clip);

If clip is true, makes the canvas item specified by the item RID not draw anything outside of its rect's coordinates. This clipping is fast, but works only with axis-aligned rectangles. This means that rotation is ignored by the clipping rectangle. For more advanced clipping shapes, use RenderingServer.CanvasItemSetCanvasGroupMode instead. Note: The equivalent node functionality is found in Label.ClipText, RichTextLabel (always enabled) and more.

public static void CanvasItemSetCopyToBackbuffer(Rid item, bool enabled, Rect2 rect);

Sets the CanvasItem to copy a rect to the backbuffer.

public static void CanvasItemSetCustomRect(Rid item, bool useCustomRect, Rect2? rect = default);

If use_custom_rect is true, sets the custom visibility rectangle (used for culling) to rect for the canvas item specified by item. Setting a custom visibility rect can reduce CPU load when drawing lots of 2D instances. If use_custom_rect is false, automatically computes a visibility rectangle based on the canvas item's draw commands.

public static void CanvasItemSetDefaultTextureFilter(Rid item, RenderingServer.CanvasItemTextureFilter filter);

Sets the default texture filter mode for the canvas item specified by the item RID. Equivalent to CanvasItem.TextureFilter.

public static void CanvasItemSetDefaultTextureRepeat(Rid item, RenderingServer.CanvasItemTextureRepeat repeat);

Sets the default texture repeat mode for the canvas item specified by the item RID. Equivalent to CanvasItem.TextureRepeat.

public static void CanvasItemSetDistanceFieldMode(Rid item, bool enabled);

If enabled is true, enables multichannel signed distance field rendering mode for the canvas item specified by the item RID. This is meant to be used for font rendering, or with specially generated images using msdfgen.

public static void CanvasItemSetDrawBehindParent(Rid item, bool enabled);

If enabled is true, draws the canvas item specified by the item RID behind its parent. Equivalent to CanvasItem.ShowBehindParent.

public static void CanvasItemSetDrawIndex(Rid item, int index);

Sets the index for the CanvasItem.

public static void CanvasItemSetInstanceShaderParameter(Rid instance, StringName parameter, Variant value);

Writes a low-level canvas-item instance parameter value. For normal reset to the declared default use scene-level CanvasItem.SetInstanceShaderParameter with Nil: that method resolves the default first. The registry does not support Object values.

public static void CanvasItemSetInterpolated(Rid item, bool interpolated);

If interpolated is true, turns on physics interpolation for the canvas item.

public static void CanvasItemSetLightMask(Rid item, int mask);

Sets the light mask for the canvas item specified by the item RID. Equivalent to CanvasItem.LightMask.

public static void CanvasItemSetMaterial(Rid item, Rid material);

Sets a new material to the canvas item specified by the item RID. Equivalent to CanvasItem.Material.

public static void CanvasItemSetModulate(Rid item, Color color);

Multiplies the color of the canvas item specified by the item RID, while affecting its children. See also RenderingServer.CanvasItemSetSelfModulate. Equivalent to CanvasItem.Modulate.

public static void CanvasItemSetParent(Rid item, Rid parent);

Sets a parent CanvasItem to the CanvasItem. The item will inherit transform, modulation and visibility from its parent, like CanvasItem nodes in the scene tree.

public static void CanvasItemSetSelfModulate(Rid item, Color color);

Multiplies the color of the canvas item specified by the item RID, without affecting its children. See also RenderingServer.CanvasItemSetModulate. Equivalent to CanvasItem.SelfModulate.

public static void CanvasItemSetSortChildrenByY(Rid item, bool enabled);

If enabled is true, child nodes with the lowest Y position are drawn before those with a higher Y position. Y-sorting only affects children that inherit from the canvas item specified by the item RID, not the canvas item itself. Equivalent to CanvasItem.YSortEnabled.

public static void CanvasItemSetTransform(Rid item, Transform2D transform);

Sets the transform of the canvas item specified by the item RID. This affects where and how the item will be drawn. Child canvas items' transforms are multiplied by their parent's transform. Equivalent to Entity2D.Transform.

public static void CanvasItemSetUseParentMaterial(Rid item, bool enabled);

Sets if the CanvasItem uses its parent's material.

public static void CanvasItemSetVisibilityLayer(Rid item, uint visibilityLayer);

Sets the rendering visibility layer associated with this CanvasItem. Only Viewport nodes with a matching rendering mask will render this CanvasItem.

public static void CanvasItemSetVisibilityNotifier(Rid item, bool enable, Rect2 area, Callable enterCallable, Callable exitCallable);

Sets the given CanvasItem as visibility notifier. area defines the area of detecting visibility. enter_callable is called when the CanvasItem enters the screen, exit_callable is called when the CanvasItem exits the screen. If enable is false, the item will no longer function as notifier. This method can be used to manually mimic VisibleOnScreenNotifier2D.

public static void CanvasItemSetVisible(Rid item, bool visible);

Sets the visibility of the CanvasItem.

public static void CanvasItemSetZAsRelativeToParent(Rid item, bool enabled);

If this is enabled, the Z index of the parent will be added to the children's Z index.

public static void CanvasItemSetZIndex(Rid item, int zIndex);

Sets the CanvasItem's Z index, i.e. its draw order (lower indexes are drawn first).

public static void CanvasItemTransformPhysicsInterpolation(Rid item, Transform2D transform);

Transforms both the current and previous stored transform for a canvas item. This allows transforming a canvas item without creating a "glitch" in the interpolation, which is particularly useful for large worlds utilizing a shifting origin.

public static void CanvasLightAttachToCanvas(Rid light, Rid canvas);

Attaches the canvas light to the canvas. Removes it from its previous canvas.

public static Rid CanvasLightCreate();

Creates a canvas light and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all canvas_light_* RenderingServer functions. Once finished with your RID, you will want to free the RID using the RenderingServer's RenderingServer.FreeRid method. Note: The equivalent node is Light2D.

public static void CanvasLightOccluderAttachToCanvas(Rid occluder, Rid canvas);

Attaches a light occluder to the canvas. Removes it from its previous canvas.

public static Rid CanvasLightOccluderCreate();

Creates a light occluder and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all canvas_light_occluder_* RenderingServer functions. Once finished with your RID, you will want to free the RID using the RenderingServer's RenderingServer.FreeRid method. Note: The equivalent node is LightOccluder2D.

public static void CanvasLightOccluderResetPhysicsInterpolation(Rid occluder);

Prevents physics interpolation for the current physics tick. This is useful when moving an occluder to a new location, to give an instantaneous change rather than interpolation from the previous location.

public static void CanvasLightOccluderSetAsSdfCollision(Rid occluder, bool enable);

Enables or disables using the light occluder as a signed distance field for 2D particle collision.

public static void CanvasLightOccluderSetEnabled(Rid occluder, bool enabled);

Enables or disables light occluder.

public static void CanvasLightOccluderSetInterpolated(Rid occluder, bool interpolated);

If interpolated is true, turns on physics interpolation for the light occluder.

public static void CanvasLightOccluderSetLightMask(Rid occluder, int mask);

The light mask. See LightOccluder2D for more information on light masks.

public static void CanvasLightOccluderSetPolygon(Rid occluder, Rid polygon);

Sets a light occluder's polygon.

public static void CanvasLightOccluderSetTransform(Rid occluder, Transform2D transform);

Sets a light occluder's Transform2D.

public static void CanvasLightOccluderTransformPhysicsInterpolation(Rid occluder, Transform2D transform);

Transforms both the current and previous stored transform for a light occluder. This allows transforming an occluder without creating a "glitch" in the interpolation, which is particularly useful for large worlds utilizing a shifting origin.

public static void CanvasLightResetPhysicsInterpolation(Rid light);

Prevents physics interpolation for the current physics tick. This is useful when moving a canvas item to a new location, to give an instantaneous change rather than interpolation from the previous location.

public static void CanvasLightSetBlendMode(Rid light, RenderingServer.CanvasLightBlendMode mode);

Sets the blend mode for the given canvas light to mode. Equivalent to Light2D.BlendMode.

public static void CanvasLightSetColor(Rid light, Color color);

Sets the color for a light.

public static void CanvasLightSetEnabled(Rid light, bool enabled);

Enables or disables a canvas light.

public static void CanvasLightSetEnergy(Rid light, float energy);

Sets a canvas light's energy.

public static void CanvasLightSetHeight(Rid light, float height);

Sets a canvas light's height.

public static void CanvasLightSetInterpolated(Rid light, bool interpolated);

If interpolated is true, turns on physics interpolation for the canvas light.

public static void CanvasLightSetItemCullMask(Rid light, int mask);

The light mask. See LightOccluder2D for more information on light masks.

public static void CanvasLightSetItemShadowCullMask(Rid light, int mask);

The binary mask used to determine which layers this canvas light's shadows affects. See LightOccluder2D for more information on light masks.

public static void CanvasLightSetLayerRange(Rid light, int minLayer, int maxLayer);

The layer range that gets rendered with this light.

public static void CanvasLightSetMode(Rid light, RenderingServer.CanvasLightMode mode);

Sets the mode of the canvas light.

public static void CanvasLightSetShadowColor(Rid light, Color color);

Sets the color of the canvas light's shadow.

public static void CanvasLightSetShadowEnabled(Rid light, bool enabled);

Enables or disables the canvas light's shadow.

public static void CanvasLightSetShadowFilter(Rid light, RenderingServer.CanvasLightShadowFilter filter);

Sets the canvas light's shadow's filter.

public static void CanvasLightSetShadowSmooth(Rid light, float smooth);

Smoothens the shadow. The lower, the smoother.

public static void CanvasLightSetTexture(Rid light, Rid texture);

Sets the texture to be used by a PointLight2D. Equivalent to PointLight2D.Texture.

public static void CanvasLightSetTextureOffset(Rid light, Vector2 offset);

Sets the offset of a PointLight2D's texture. Equivalent to PointLight2D.Offset.

public static void CanvasLightSetTextureScale(Rid light, float scale);

Sets the scale factor of a PointLight2D's texture. Equivalent to PointLight2D.TextureScale.

public static void CanvasLightSetTransform(Rid light, Transform2D transform);

Sets the canvas light's Transform2D.

public static void CanvasLightSetZRange(Rid light, int minZ, int maxZ);

Sets the Z range of objects that will be affected by this light. Equivalent to Light2D.RangeZMin and Light2D.RangeZMax.

public static void CanvasLightTransformPhysicsInterpolation(Rid light, Transform2D transform);

Transforms both the current and previous stored transform for a canvas light. This allows transforming a light without creating a "glitch" in the interpolation, which is particularly useful for large worlds utilizing a shifting origin.

public static Rid CanvasOccluderPolygonCreate();

Creates a new light occluder polygon and adds it to the RenderingServer. It can be accessed with the RID that is returned. This RID will be used in all canvas_occluder_polygon_* RenderingServer functions. Once finished with your RID, you will want to free the RID using the RenderingServer's RenderingServer.FreeRid method. Note: The equivalent resource is OccluderPolygon2D.

public static void CanvasOccluderPolygonSetCullMode(Rid occluderPolygon, RenderingServer.CanvasOccluderPolygonCullMode mode);

Sets an occluder polygon's cull mode.

public static void CanvasOccluderPolygonSetShape(Rid occluderPolygon, Vector2[] shape, bool closed);

Sets the shape of the occluder polygon.

public static void CanvasOccluderPolygonSetShape(Rid occluderPolygon, ReadOnlySpan<Vector2> shape, bool closed);

Sets the shape of the occluder polygon.

public static void CanvasSetDisableScale(bool disable);

If disable is true, makes 2D rendering ignore the canvas scale defined for each canvas layer. This affects CanvasLayers with the CanvasLayer.FollowViewportEnabled property set to true. In the editor, this is set to true by default, and set to false when View > Preview Canvas Scale is enabled at the top of the 2D editor viewport. Note: Setting this to true does not impact the behavior of CanvasLayer.Scale, Entity2D.Scale, or Control.Scale.

public static void CanvasSetItemMirroring(Rid canvas, Rid item, Vector2 mirroring);

A copy of the canvas item will be drawn with a local offset of the mirroring. Note: This is equivalent to calling RenderingServer.CanvasSetItemRepeat like canvas_set_item_repeat(item, mirroring, 1), with an additional check ensuring canvas is a parent of item.

public static void CanvasSetItemRepeat(Rid item, Vector2 repeatSize, int repeatTimes);

A copy of the canvas item will be drawn with a local offset of the repeat_size by the number of times of the repeat_times. As the repeat_times increases, the copies will spread away from the origin texture.

public static void CanvasSetModulate(Rid canvas, Color color);

Modulates all colors in the given canvas.