| github_url: | hide |
|---|
Inherits: :ref:`Object<class_Object>`
Server for anything visible.
Server for anything visible. The visual server is the API backend for everything visible. The whole scene system mounts on it to display.
The visual server is completely opaque, the internals are entirely implementation specific and cannot be accessed.
The visual server can be used to bypass the scene system entirely.
Resources are created using the *_create functions.
All objects are drawn to a viewport. You can use the :ref:`Viewport<class_Viewport>` attached to the :ref:`SceneTree<class_SceneTree>` or you can create one yourself with :ref:`viewport_create<class_VisualServer_method_viewport_create>`. When using a custom scenario or canvas, the scenario or canvas needs to be attached to the viewport using :ref:`viewport_set_scenario<class_VisualServer_method_viewport_set_scenario>` or :ref:`viewport_attach_canvas<class_VisualServer_method_viewport_attach_canvas>`.
In 3D, all visual objects must be associated with a scenario. The scenario is a visual representation of the world. If accessing the visual server from a running game, the scenario can be accessed from the scene tree from any :ref:`Spatial<class_Spatial>` node with :ref:`Spatial.get_world<class_Spatial_method_get_world>`. Otherwise, a scenario can be created with :ref:`scenario_create<class_VisualServer_method_scenario_create>`.
Similarly in 2D, a canvas is needed to draw all canvas items.
In 3D, all visible objects are comprised of a resource and an instance. A resource can be a mesh, a particle system, a light, or any other 3D object. In order to be visible resources must be attached to an instance using :ref:`instance_set_base<class_VisualServer_method_instance_set_base>`. The instance must also be attached to the scenario using :ref:`instance_set_scenario<class_VisualServer_method_instance_set_scenario>` in order to be visible.
In 2D, all visible objects are some form of canvas item. In order to be visible, a canvas item needs to be the child of a canvas attached to a viewport, or it needs to be the child of another canvas item that is eventually attached to the canvas.
- frame_post_draw ( )
Emitted at the end of the frame, after the VisualServer has finished updating all the Viewports.
- frame_pre_draw ( )
Emitted at the beginning of the frame, before the VisualServer updates all the Viewports.
enum TextureLayeredType:
- TEXTURE_LAYERED_2D_ARRAY = 0
- TEXTURE_LAYERED_CUBEMAP = 1
- TEXTURE_LAYERED_CUBEMAP_ARRAY = 2
enum CubeMapLayer:
- CUBEMAP_LAYER_LEFT = 0
- CUBEMAP_LAYER_RIGHT = 1
- CUBEMAP_LAYER_BOTTOM = 2
- CUBEMAP_LAYER_TOP = 3
- CUBEMAP_LAYER_FRONT = 4
- CUBEMAP_LAYER_BACK = 5
enum ShaderMode:
- SHADER_SPATIAL = 0 --- Shader is a 3D shader.
- SHADER_CANVAS_ITEM = 1 --- Shader is a 2D shader.
- SHADER_PARTICLES = 2 --- Shader is a particle shader.
- SHADER_SKY = 3 --- Shader is a sky shader.
- SHADER_MAX = 4 --- Represents the size of the :ref:`ShaderMode<enum_VisualServer_ShaderMode>` enum.
enum ArrayType:
- ARRAY_VERTEX = 0 --- Array is a vertex array.
- ARRAY_NORMAL = 1 --- Array is a normal array.
- ARRAY_TANGENT = 2 --- Array is a tangent array.
- ARRAY_COLOR = 3 --- Array is a color array.
- ARRAY_TEX_UV = 4 --- Array is an UV coordinates array.
- ARRAY_TEX_UV2 = 5 --- Array is an UV coordinates array for the second UV coordinates.
- ARRAY_BONES = 6 --- Array contains bone information.
- ARRAY_WEIGHTS = 7 --- Array is weight information.
- ARRAY_INDEX = 8 --- Array is index array.
- ARRAY_MAX = 9 --- Represents the size of the :ref:`ArrayType<enum_VisualServer_ArrayType>` enum.
enum ArrayFormat:
- ARRAY_FORMAT_VERTEX = 1 --- Flag used to mark a vertex array.
- ARRAY_FORMAT_NORMAL = 2 --- Flag used to mark a normal array.
- ARRAY_FORMAT_TANGENT = 4 --- Flag used to mark a tangent array.
- ARRAY_FORMAT_COLOR = 8 --- Flag used to mark a color array.
- ARRAY_FORMAT_TEX_UV = 16 --- Flag used to mark an UV coordinates array.
- ARRAY_FORMAT_TEX_UV2 = 32 --- Flag used to mark an UV coordinates array for the second UV coordinates.
- ARRAY_FORMAT_BONES = 64 --- Flag used to mark a bone information array.
- ARRAY_FORMAT_WEIGHTS = 128 --- Flag used to mark a weights array.
- ARRAY_FORMAT_INDEX = 256 --- Flag used to mark an index array.
- ARRAY_COMPRESS_NORMAL = 1024 --- Flag used to mark a compressed (half float) normal array.
- ARRAY_COMPRESS_TANGENT = 2048 --- Flag used to mark a compressed (half float) tangent array.
- ARRAY_COMPRESS_COLOR = 4096 --- Flag used to mark a compressed (half float) color array.
- ARRAY_COMPRESS_TEX_UV = 8192 --- Flag used to mark a compressed (half float) UV coordinates array.
- ARRAY_COMPRESS_TEX_UV2 = 16384 --- Flag used to mark a compressed (half float) UV coordinates array for the second UV coordinates.
- ARRAY_COMPRESS_INDEX = 131072 --- Flag used to mark a compressed index array.
- ARRAY_FLAG_USE_2D_VERTICES = 262144 --- Flag used to mark that the array contains 2D vertices.
- ARRAY_FLAG_USE_DYNAMIC_UPDATE = 1048576
- ARRAY_COMPRESS_DEFAULT = 31744 --- Used to set flags :ref:`ARRAY_COMPRESS_NORMAL<class_VisualServer_constant_ARRAY_COMPRESS_NORMAL>`, :ref:`ARRAY_COMPRESS_TANGENT<class_VisualServer_constant_ARRAY_COMPRESS_TANGENT>`, :ref:`ARRAY_COMPRESS_COLOR<class_VisualServer_constant_ARRAY_COMPRESS_COLOR>`, :ref:`ARRAY_COMPRESS_TEX_UV<class_VisualServer_constant_ARRAY_COMPRESS_TEX_UV>` and :ref:`ARRAY_COMPRESS_TEX_UV2<class_VisualServer_constant_ARRAY_COMPRESS_TEX_UV2>` quickly.
enum PrimitiveType:
- PRIMITIVE_POINTS = 0 --- Primitive to draw consists of points.
- PRIMITIVE_LINES = 1 --- Primitive to draw consists of lines.
- PRIMITIVE_LINE_STRIP = 2 --- Primitive to draw consists of a line strip from start to end.
- PRIMITIVE_TRIANGLES = 3 --- Primitive to draw consists of triangles.
- PRIMITIVE_TRIANGLE_STRIP = 4 --- Primitive to draw consists of a triangle strip (the last 3 vertices are always combined to make a triangle).
- PRIMITIVE_MAX = 5 --- Represents the size of the :ref:`PrimitiveType<enum_VisualServer_PrimitiveType>` enum.
enum BlendShapeMode:
- BLEND_SHAPE_MODE_NORMALIZED = 0 --- Blend shapes are normalized.
- BLEND_SHAPE_MODE_RELATIVE = 1 --- Blend shapes are relative to base weight.
enum MultimeshTransformFormat:
- MULTIMESH_TRANSFORM_2D = 0 --- Use :ref:`Transform2D<class_Transform2D>` to store MultiMesh transform.
- MULTIMESH_TRANSFORM_3D = 1 --- Use :ref:`Transform<class_Transform>` to store MultiMesh transform.
enum LightType:
- LIGHT_DIRECTIONAL = 0 --- Is a directional (sun) light.
- LIGHT_OMNI = 1 --- Is an omni light.
- LIGHT_SPOT = 2 --- Is a spot light.
enum LightParam:
- LIGHT_PARAM_ENERGY = 0 --- The light's energy.
- LIGHT_PARAM_INDIRECT_ENERGY = 1
- LIGHT_PARAM_SPECULAR = 2 --- The light's influence on specularity.
- LIGHT_PARAM_RANGE = 3 --- The light's range.
- LIGHT_PARAM_ATTENUATION = 4 --- The light's attenuation.
- LIGHT_PARAM_SPOT_ANGLE = 5 --- The spotlight's angle.
- LIGHT_PARAM_SPOT_ATTENUATION = 6 --- The spotlight's attenuation.
- LIGHT_PARAM_CONTACT_SHADOW_SIZE = 7 --- Scales the shadow color.
- LIGHT_PARAM_SHADOW_MAX_DISTANCE = 8 --- Max distance that shadows will be rendered.
- LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET = 9 --- Proportion of shadow atlas occupied by the first split.
- LIGHT_PARAM_SHADOW_SPLIT_2_OFFSET = 10 --- Proportion of shadow atlas occupied by the second split.
- LIGHT_PARAM_SHADOW_SPLIT_3_OFFSET = 11 --- Proportion of shadow atlas occupied by the third split. The fourth split occupies the rest.
- LIGHT_PARAM_SHADOW_FADE_START = 12
- LIGHT_PARAM_SHADOW_NORMAL_BIAS = 13 --- Normal bias used to offset shadow lookup by object normal. Can be used to fix self-shadowing artifacts.
- LIGHT_PARAM_SHADOW_BIAS = 14 --- Bias the shadow lookup to fix self-shadowing artifacts.
- LIGHT_PARAM_SHADOW_BIAS_SPLIT_SCALE = 15 --- Increases bias on further splits to fix self-shadowing that only occurs far away from the camera.
- LIGHT_PARAM_MAX = 16 --- Represents the size of the :ref:`LightParam<enum_VisualServer_LightParam>` enum.
enum LightOmniShadowMode:
- LIGHT_OMNI_SHADOW_DUAL_PARABOLOID = 0 --- Use a dual paraboloid shadow map for omni lights.
- LIGHT_OMNI_SHADOW_CUBE = 1 --- Use a cubemap shadow map for omni lights. Slower but better quality than dual paraboloid.
enum LightDirectionalShadowMode:
- LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL = 0 --- Use orthogonal shadow projection for directional light.
- LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS = 1 --- Use 2 splits for shadow projection when using directional light.
- LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS = 2 --- Use 4 splits for shadow projection when using directional light.
enum LightDirectionalShadowDepthRangeMode:
- LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_STABLE = 0 --- Keeps shadows stable as camera moves but has lower effective resolution.
- LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_OPTIMIZED = 1 --- Optimize use of shadow maps, increasing the effective resolution. But may result in shadows moving or flickering slightly.
enum ReflectionProbeUpdateMode:
- REFLECTION_PROBE_UPDATE_ONCE = 0 --- Reflection probe will update reflections once and then stop.
- REFLECTION_PROBE_UPDATE_ALWAYS = 1 --- Reflection probe will update each frame. This mode is necessary to capture moving objects.
enum ParticlesDrawOrder:
- PARTICLES_DRAW_ORDER_INDEX = 0 --- Draw particles in the order that they appear in the particles array.
- PARTICLES_DRAW_ORDER_LIFETIME = 1 --- Sort particles based on their lifetime.
- PARTICLES_DRAW_ORDER_VIEW_DEPTH = 2 --- Sort particles based on their distance to the camera.
enum ViewportUpdateMode:
- VIEWPORT_UPDATE_DISABLED = 0 --- Do not update the viewport.
- VIEWPORT_UPDATE_ONCE = 1 --- Update the viewport once then set to disabled.
- VIEWPORT_UPDATE_WHEN_VISIBLE = 2 --- Update the viewport whenever it is visible.
- VIEWPORT_UPDATE_ALWAYS = 3 --- Always update the viewport.
enum ViewportClearMode:
- VIEWPORT_CLEAR_ALWAYS = 0 --- The viewport is always cleared before drawing.
- VIEWPORT_CLEAR_NEVER = 1 --- The viewport is never cleared before drawing.
- VIEWPORT_CLEAR_ONLY_NEXT_FRAME = 2 --- The viewport is cleared once, then the clear mode is set to :ref:`VIEWPORT_CLEAR_NEVER<class_VisualServer_constant_VIEWPORT_CLEAR_NEVER>`.
enum ViewportMSAA:
- VIEWPORT_MSAA_DISABLED = 0 --- Multisample antialiasing is disabled.
- VIEWPORT_MSAA_2X = 1 --- Multisample antialiasing is set to 2×.
- VIEWPORT_MSAA_4X = 2 --- Multisample antialiasing is set to 4×.
- VIEWPORT_MSAA_8X = 3 --- Multisample antialiasing is set to 8×.
- VIEWPORT_MSAA_16X = 4 --- Multisample antialiasing is set to 16×.
- VIEWPORT_MSAA_EXT_2X = 5 --- Multisample antialiasing is set to 2× on external texture. Special mode for GLES2 Android VR (Oculus Quest and Go).
- VIEWPORT_MSAA_EXT_4X = 6 --- Multisample antialiasing is set to 4× on external texture. Special mode for GLES2 Android VR (Oculus Quest and Go).
enum ViewportRenderInfo:
- VIEWPORT_RENDER_INFO_OBJECTS_IN_FRAME = 0 --- Number of objects drawn in a single frame.
- VIEWPORT_RENDER_INFO_VERTICES_IN_FRAME = 1 --- Number of vertices drawn in a single frame.
- VIEWPORT_RENDER_INFO_MATERIAL_CHANGES_IN_FRAME = 2 --- Number of material changes during this frame.
- VIEWPORT_RENDER_INFO_SHADER_CHANGES_IN_FRAME = 3 --- Number of shader changes during this frame.
- VIEWPORT_RENDER_INFO_SURFACE_CHANGES_IN_FRAME = 4 --- Number of surface changes during this frame.
- VIEWPORT_RENDER_INFO_DRAW_CALLS_IN_FRAME = 5 --- Number of draw calls during this frame.
- VIEWPORT_RENDER_INFO_MAX = 6 --- Represents the size of the :ref:`ViewportRenderInfo<enum_VisualServer_ViewportRenderInfo>` enum.
enum ViewportDebugDraw:
- VIEWPORT_DEBUG_DRAW_DISABLED = 0 --- Debug draw is disabled. Default setting.
- VIEWPORT_DEBUG_DRAW_UNSHADED = 1 --- Debug draw sets objects to unshaded.
- VIEWPORT_DEBUG_DRAW_LIGHTING = 2
- VIEWPORT_DEBUG_DRAW_OVERDRAW = 3 --- Overwrites clear color to
(0,0,0,0). - VIEWPORT_DEBUG_DRAW_WIREFRAME = 4 --- Debug draw draws objects in wireframe.
- VIEWPORT_DEBUG_DRAW_NORMAL_BUFFER = 5
- VIEWPORT_DEBUG_DRAW_GI_PROBE_ALBEDO = 6
- VIEWPORT_DEBUG_DRAW_GI_PROBE_LIGHTING = 7
- VIEWPORT_DEBUG_DRAW_GI_PROBE_EMISSION = 8
- VIEWPORT_DEBUG_DRAW_SHADOW_ATLAS = 9
- VIEWPORT_DEBUG_DRAW_DIRECTIONAL_SHADOW_ATLAS = 10
- VIEWPORT_DEBUG_DRAW_SCENE_LUMINANCE = 11
- VIEWPORT_DEBUG_DRAW_SSAO = 12
- VIEWPORT_DEBUG_DRAW_ROUGHNESS_LIMITER = 13
enum SkyMode:
- SKY_MODE_QUALITY = 0
- SKY_MODE_REALTIME = 1
enum EnvironmentBG:
- ENV_BG_CLEAR_COLOR = 0 --- Use the clear color as background.
- ENV_BG_COLOR = 1 --- Use a specified color as the background.
- ENV_BG_SKY = 2 --- Use a sky resource for the background.
- ENV_BG_CANVAS = 3 --- Use a specified canvas layer as the background. This can be useful for instantiating a 2D scene in a 3D world.
- ENV_BG_KEEP = 4 --- Do not clear the background, use whatever was rendered last frame as the background.
- ENV_BG_CAMERA_FEED = 5 --- Displays a camera feed in the background.
- ENV_BG_MAX = 6 --- Represents the size of the :ref:`EnvironmentBG<enum_VisualServer_EnvironmentBG>` enum.
enum EnvironmentAmbientSource:
- ENV_AMBIENT_SOURCE_BG = 0
- ENV_AMBIENT_SOURCE_DISABLED = 1
- ENV_AMBIENT_SOURCE_COLOR = 2
- ENV_AMBIENT_SOURCE_SKY = 3
enum EnvironmentReflectionSource:
- ENV_REFLECTION_SOURCE_BG = 0
- ENV_REFLECTION_SOURCE_DISABLED = 1
- ENV_REFLECTION_SOURCE_SKY = 2
enum EnvironmentGlowBlendMode:
- ENV_GLOW_BLEND_MODE_ADDITIVE = 0
- ENV_GLOW_BLEND_MODE_SCREEN = 1
- ENV_GLOW_BLEND_MODE_SOFTLIGHT = 2
- ENV_GLOW_BLEND_MODE_REPLACE = 3
- ENV_GLOW_BLEND_MODE_MIX = 4
enum EnvironmentToneMapper:
- ENV_TONE_MAPPER_LINEAR = 0 --- Output color as they came in.
- ENV_TONE_MAPPER_REINHARD = 1 --- Use the Reinhard tonemapper.
- ENV_TONE_MAPPER_FILMIC = 2 --- Use the filmic tonemapper.
- ENV_TONE_MAPPER_ACES = 3 --- Use the ACES tonemapper.
enum EnvironmentSSAOBlur:
- ENV_SSAO_BLUR_DISABLED = 0 --- Disables the blur set for SSAO. Will make SSAO look noisier.
- ENV_SSAO_BLUR_1x1 = 1 --- Perform a 1x1 blur on the SSAO output.
- ENV_SSAO_BLUR_2x2 = 2 --- Performs a 2x2 blur on the SSAO output.
- ENV_SSAO_BLUR_3x3 = 3 --- Performs a 3x3 blur on the SSAO output. Use this for smoothest SSAO.
enum EnvironmentSSAOQuality:
- ENV_SSAO_QUALITY_LOW = 0 --- Lowest quality of screen space ambient occlusion.
- ENV_SSAO_QUALITY_MEDIUM = 1 --- Medium quality screen space ambient occlusion.
- ENV_SSAO_QUALITY_HIGH = 2 --- Highest quality screen space ambient occlusion.
- ENV_SSAO_QUALITY_ULTRA = 3
enum DOFBlurQuality:
- DOF_BLUR_QUALITY_VERY_LOW = 0
- DOF_BLUR_QUALITY_LOW = 1
- DOF_BLUR_QUALITY_MEDIUM = 2
- DOF_BLUR_QUALITY_HIGH = 3
enum DOFBokehShape:
- DOF_BOKEH_BOX = 0
- DOF_BOKEH_HEXAGON = 1
- DOF_BOKEH_CIRCLE = 2
enum ScenarioDebugMode:
- SCENARIO_DEBUG_DISABLED = 0 --- Do not use a debug mode.
- SCENARIO_DEBUG_WIREFRAME = 1 --- Draw all objects as wireframe models.
- SCENARIO_DEBUG_OVERDRAW = 2 --- Draw all objects in a way that displays how much overdraw is occurring. Overdraw occurs when a section of pixels is drawn and shaded and then another object covers it up. To optimize a scene, you should reduce overdraw.
- SCENARIO_DEBUG_SHADELESS = 3 --- Draw all objects without shading. Equivalent to setting all objects shaders to
unshaded.
enum InstanceType:
- INSTANCE_NONE = 0 --- The instance does not have a type.
- INSTANCE_MESH = 1 --- The instance is a mesh.
- INSTANCE_MULTIMESH = 2 --- The instance is a multimesh.
- INSTANCE_IMMEDIATE = 3 --- The instance is an immediate geometry.
- INSTANCE_PARTICLES = 4 --- The instance is a particle emitter.
- INSTANCE_LIGHT = 5 --- The instance is a light.
- INSTANCE_REFLECTION_PROBE = 6 --- The instance is a reflection probe.
- INSTANCE_GI_PROBE = 7 --- The instance is a GI probe.
- INSTANCE_LIGHTMAP_CAPTURE = 8 --- The instance is a lightmap capture.
- INSTANCE_MAX = 9 --- Represents the size of the :ref:`InstanceType<enum_VisualServer_InstanceType>` enum.
- INSTANCE_GEOMETRY_MASK = 30 --- A combination of the flags of geometry instances (mesh, multimesh, immediate and particles).
enum InstanceFlags:
- INSTANCE_FLAG_USE_BAKED_LIGHT = 0 --- Allows the instance to be used in baked lighting.
- INSTANCE_FLAG_USE_DYNAMIC_GI = 1
- INSTANCE_FLAG_DRAW_NEXT_FRAME_IF_VISIBLE = 2 --- When set, manually requests to draw geometry on next frame.
- INSTANCE_FLAG_MAX = 3 --- Represents the size of the :ref:`InstanceFlags<enum_VisualServer_InstanceFlags>` enum.
enum ShadowCastingSetting:
- SHADOW_CASTING_SETTING_OFF = 0 --- Disable shadows from this instance.
- SHADOW_CASTING_SETTING_ON = 1 --- Cast shadows from this instance.
- SHADOW_CASTING_SETTING_DOUBLE_SIDED = 2 --- Disable backface culling when rendering the shadow of the object. This is slightly slower but may result in more correct shadows.
- SHADOW_CASTING_SETTING_SHADOWS_ONLY = 3 --- Only render the shadows from the object. The object itself will not be drawn.
enum NinePatchAxisMode:
- NINE_PATCH_STRETCH = 0 --- The nine patch gets stretched where needed.
- NINE_PATCH_TILE = 1 --- The nine patch gets filled with tiles where needed.
- NINE_PATCH_TILE_FIT = 2 --- The nine patch gets filled with tiles where needed and stretches them a bit if needed.
enum CanvasItemTextureFilter:
- CANVAS_ITEM_TEXTURE_FILTER_DEFAULT = 0
- CANVAS_ITEM_TEXTURE_FILTER_NEAREST = 1
- CANVAS_ITEM_TEXTURE_FILTER_LINEAR = 2
- CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS = 3
- CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS = 4
- CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC = 5
- CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC = 6
- CANVAS_ITEM_TEXTURE_FILTER_MAX = 7
enum CanvasItemTextureRepeat:
- CANVAS_ITEM_TEXTURE_REPEAT_DEFAULT = 0
- CANVAS_ITEM_TEXTURE_REPEAT_DISABLED = 1
- CANVAS_ITEM_TEXTURE_REPEAT_ENABLED = 2
- CANVAS_ITEM_TEXTURE_REPEAT_MIRROR = 3
- CANVAS_ITEM_TEXTURE_REPEAT_MAX = 4
enum CanvasLightMode:
- CANVAS_LIGHT_MODE_ADD = 0 --- Adds light color additive to the canvas.
- CANVAS_LIGHT_MODE_SUB = 1 --- Adds light color subtractive to the canvas.
- CANVAS_LIGHT_MODE_MIX = 2 --- The light adds color depending on transparency.
- CANVAS_LIGHT_MODE_MASK = 3 --- The light adds color depending on mask.
enum CanvasLightShadowFilter:
- CANVAS_LIGHT_FILTER_NONE = 0 --- Do not apply a filter to canvas light shadows.
- CANVAS_LIGHT_FILTER_PCF5 = 1 --- Use PCF5 filtering to filter canvas light shadows.
- CANVAS_LIGHT_FILTER_PCF13 = 2 --- Use PCF13 filtering to filter canvas light shadows.
- CANVAS_LIGHT_FILTER_MAX = 3
enum CanvasOccluderPolygonCullMode:
- CANVAS_OCCLUDER_POLYGON_CULL_DISABLED = 0 --- Culling of the canvas occluder is disabled.
- CANVAS_OCCLUDER_POLYGON_CULL_CLOCKWISE = 1 --- Culling of the canvas occluder is clockwise.
- CANVAS_OCCLUDER_POLYGON_CULL_COUNTER_CLOCKWISE = 2 --- Culling of the canvas occluder is counterclockwise.
enum RenderInfo:
- INFO_OBJECTS_IN_FRAME = 0 --- The amount of objects in the frame.
- INFO_VERTICES_IN_FRAME = 1 --- The amount of vertices in the frame.
- INFO_MATERIAL_CHANGES_IN_FRAME = 2 --- The amount of modified materials in the frame.
- INFO_SHADER_CHANGES_IN_FRAME = 3 --- The amount of shader rebinds in the frame.
- INFO_SURFACE_CHANGES_IN_FRAME = 4 --- The amount of surface changes in the frame.
- INFO_DRAW_CALLS_IN_FRAME = 5 --- The amount of draw calls in frame.
- INFO_USAGE_VIDEO_MEM_TOTAL = 6 --- Unimplemented in the GLES2 rendering backend, always returns 0.
- INFO_VIDEO_MEM_USED = 7 --- The amount of video memory used, i.e. texture and vertex memory combined.
- INFO_TEXTURE_MEM_USED = 8 --- The amount of texture memory used.
- INFO_VERTEX_MEM_USED = 9 --- The amount of vertex memory used.
enum Features:
- FEATURE_SHADERS = 0 --- Hardware supports shaders. This enum is currently unused in Godot 3.x.
- FEATURE_MULTITHREADED = 1 --- Hardware supports multithreading. This enum is currently unused in Godot 3.x.
- NO_INDEX_ARRAY = -1 --- Marks an error that shows that the index array is empty.
- ARRAY_WEIGHTS_SIZE = 4 --- Number of weights/bones per vertex.
- CANVAS_ITEM_Z_MIN = -4096 --- The minimum Z-layer for canvas items.
- CANVAS_ITEM_Z_MAX = 4096 --- The maximum Z-layer for canvas items.
- MAX_GLOW_LEVELS = 7 --- Max number of glow levels that can be used with glow post-process effect.
- MAX_CURSORS = 8 --- Unused enum in Godot 3.x.
- MATERIAL_RENDER_PRIORITY_MIN = -128 --- The minimum renderpriority of all materials.
- MATERIAL_RENDER_PRIORITY_MAX = 127 --- The maximum renderpriority of all materials.
- void black_bars_set_images ( :ref:`RID<class_RID>` left, :ref:`RID<class_RID>` top, :ref:`RID<class_RID>` right, :ref:`RID<class_RID>` bottom )
Sets images to be rendered in the window margin.
- void black_bars_set_margins ( :ref:`int<class_int>` left, :ref:`int<class_int>` top, :ref:`int<class_int>` right, :ref:`int<class_int>` bottom )
Sets margin size, where black bars (or images, if :ref:`black_bars_set_images<class_VisualServer_method_black_bars_set_images>` was used) are rendered.
- :ref:`RID<class_RID>` camera_create ( )
Creates a camera and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all camera_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
- void camera_set_cull_mask ( :ref:`RID<class_RID>` camera, :ref:`int<class_int>` layers )
Sets the cull mask associated with this camera. The cull mask describes which 3D layers are rendered by this camera. Equivalent to :ref:`Camera.cull_mask<class_Camera_property_cull_mask>`.
- void camera_set_environment ( :ref:`RID<class_RID>` camera, :ref:`RID<class_RID>` env )
Sets the environment used by this camera. Equivalent to :ref:`Camera.environment<class_Camera_property_environment>`.
- void camera_set_frustum ( :ref:`RID<class_RID>` camera, :ref:`float<class_float>` size, :ref:`Vector2<class_Vector2>` offset, :ref:`float<class_float>` z_near, :ref:`float<class_float>` z_far )
Sets camera to use frustum projection. This mode allows adjusting the offset argument to create "tilted frustum" effects.
- void camera_set_orthogonal ( :ref:`RID<class_RID>` camera, :ref:`float<class_float>` size, :ref:`float<class_float>` z_near, :ref:`float<class_float>` z_far )
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.
- void camera_set_perspective ( :ref:`RID<class_RID>` camera, :ref:`float<class_float>` fovy_degrees, :ref:`float<class_float>` z_near, :ref:`float<class_float>` z_far )
Sets camera to use perspective projection. Objects on the screen becomes smaller when they are far away.
- void camera_set_transform ( :ref:`RID<class_RID>` camera, :ref:`Transform<class_Transform>` transform )
Sets :ref:`Transform<class_Transform>` of camera.
- void camera_set_use_vertical_aspect ( :ref:`RID<class_RID>` camera, :ref:`bool<class_bool>` enable )
If true, preserves the horizontal aspect ratio which is equivalent to :ref:`Camera.KEEP_WIDTH<class_Camera_constant_KEEP_WIDTH>`. If false, preserves the vertical aspect ratio which is equivalent to :ref:`Camera.KEEP_HEIGHT<class_Camera_constant_KEEP_HEIGHT>`.
- :ref:`RID<class_RID>` canvas_create ( )
Creates a canvas and returns the assigned :ref:`RID<class_RID>`. It can be accessed with the RID that is returned. This RID will be used in all canvas_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
- void canvas_item_clear ( :ref:`RID<class_RID>` item )
Clears the :ref:`CanvasItem<class_CanvasItem>` and removes all commands in it.
- void canvas_item_set_copy_to_backbuffer ( :ref:`RID<class_RID>` item, :ref:`bool<class_bool>` enabled, :ref:`Rect2<class_Rect2>` rect )
Sets the :ref:`CanvasItem<class_CanvasItem>` to copy a rect to the backbuffer.
- void canvas_item_set_draw_index ( :ref:`RID<class_RID>` item, :ref:`int<class_int>` index )
Sets the index for the :ref:`CanvasItem<class_CanvasItem>`.
- void canvas_item_set_material ( :ref:`RID<class_RID>` item, :ref:`RID<class_RID>` material )
Sets a new material to the :ref:`CanvasItem<class_CanvasItem>`.
- void canvas_item_set_use_parent_material ( :ref:`RID<class_RID>` item, :ref:`bool<class_bool>` enabled )
Sets if the :ref:`CanvasItem<class_CanvasItem>` uses its parent's material.
- void canvas_item_set_z_as_relative_to_parent ( :ref:`RID<class_RID>` item, :ref:`bool<class_bool>` enabled )
If this is enabled, the Z index of the parent will be added to the children's Z index.
- void canvas_item_set_z_index ( :ref:`RID<class_RID>` item, :ref:`int<class_int>` z_index )
Sets the :ref:`CanvasItem<class_CanvasItem>`'s Z index, i.e. its draw order (lower indexes are drawn first).
- void canvas_light_attach_to_canvas ( :ref:`RID<class_RID>` light, :ref:`RID<class_RID>` canvas )
Attaches the canvas light to the canvas. Removes it from its previous canvas.
- :ref:`RID<class_RID>` canvas_light_create ( )
Creates a canvas light and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all canvas_light_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
- void canvas_light_occluder_attach_to_canvas ( :ref:`RID<class_RID>` occluder, :ref:`RID<class_RID>` canvas )
Attaches a light occluder to the canvas. Removes it from its previous canvas.
- :ref:`RID<class_RID>` canvas_light_occluder_create ( )
Creates a light occluder and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all canvas_light_ocluder_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
- void canvas_light_occluder_set_enabled ( :ref:`RID<class_RID>` occluder, :ref:`bool<class_bool>` enabled )
Enables or disables light occluder.
- void canvas_light_occluder_set_light_mask ( :ref:`RID<class_RID>` occluder, :ref:`int<class_int>` mask )
The light mask. See :ref:`LightOccluder2D<class_LightOccluder2D>` for more information on light masks.
- void canvas_light_occluder_set_polygon ( :ref:`RID<class_RID>` occluder, :ref:`RID<class_RID>` polygon )
Sets a light occluder's polygon.
- void canvas_light_occluder_set_transform ( :ref:`RID<class_RID>` occluder, :ref:`Transform2D<class_Transform2D>` transform )
Sets a light occluder's :ref:`Transform2D<class_Transform2D>`.
- void canvas_light_set_color ( :ref:`RID<class_RID>` light, :ref:`Color<class_Color>` color )
Sets the color for a light.
- void canvas_light_set_enabled ( :ref:`RID<class_RID>` light, :ref:`bool<class_bool>` enabled )
Enables or disables a canvas light.
- void canvas_light_set_energy ( :ref:`RID<class_RID>` light, :ref:`float<class_float>` energy )
Sets a canvas light's energy.
- void canvas_light_set_height ( :ref:`RID<class_RID>` light, :ref:`float<class_float>` height )
Sets a canvas light's height.
- void canvas_light_set_item_cull_mask ( :ref:`RID<class_RID>` light, :ref:`int<class_int>` mask )
The light mask. See :ref:`LightOccluder2D<class_LightOccluder2D>` for more information on light masks.
- void canvas_light_set_item_shadow_cull_mask ( :ref:`RID<class_RID>` light, :ref:`int<class_int>` mask )
The binary mask used to determine which layers this canvas light's shadows affects. See :ref:`LightOccluder2D<class_LightOccluder2D>` for more information on light masks.
- void canvas_light_set_layer_range ( :ref:`RID<class_RID>` light, :ref:`int<class_int>` min_layer, :ref:`int<class_int>` max_layer )
The layer range that gets rendered with this light.
- void canvas_light_set_mode ( :ref:`RID<class_RID>` light, :ref:`CanvasLightMode<enum_VisualServer_CanvasLightMode>` mode )
The mode of the light, see :ref:`CanvasLightMode<enum_VisualServer_CanvasLightMode>` constants.
- void canvas_light_set_scale ( :ref:`RID<class_RID>` light, :ref:`float<class_float>` scale )
Sets the texture's scale factor of the light. Equivalent to :ref:`Light2D.texture_scale<class_Light2D_property_texture_scale>`.
- void canvas_light_set_shadow_buffer_size ( :ref:`RID<class_RID>` light, :ref:`int<class_int>` size )
Sets the width of the shadow buffer, size gets scaled to the next power of two for this.
- void canvas_light_set_shadow_color ( :ref:`RID<class_RID>` light, :ref:`Color<class_Color>` color )
Sets the color of the canvas light's shadow.
- void canvas_light_set_shadow_enabled ( :ref:`RID<class_RID>` light, :ref:`bool<class_bool>` enabled )
Enables or disables the canvas light's shadow.
- void canvas_light_set_shadow_filter ( :ref:`RID<class_RID>` light, :ref:`CanvasLightShadowFilter<enum_VisualServer_CanvasLightShadowFilter>` filter )
Sets the canvas light's shadow's filter, see :ref:`CanvasLightShadowFilter<enum_VisualServer_CanvasLightShadowFilter>` constants.
- void canvas_light_set_shadow_smooth ( :ref:`RID<class_RID>` light, :ref:`float<class_float>` smooth )
Smoothens the shadow. The lower, the smoother.
- void canvas_light_set_texture ( :ref:`RID<class_RID>` light, :ref:`RID<class_RID>` texture )
Sets texture to be used by light. Equivalent to :ref:`Light2D.texture<class_Light2D_property_texture>`.
- void canvas_light_set_texture_offset ( :ref:`RID<class_RID>` light, :ref:`Vector2<class_Vector2>` offset )
Sets the offset of the light's texture. Equivalent to :ref:`Light2D.offset<class_Light2D_property_offset>`.
- void canvas_light_set_transform ( :ref:`RID<class_RID>` light, :ref:`Transform2D<class_Transform2D>` transform )
Sets the canvas light's :ref:`Transform2D<class_Transform2D>`.
- void canvas_light_set_z_range ( :ref:`RID<class_RID>` light, :ref:`int<class_int>` min_z, :ref:`int<class_int>` max_z )
Sets the Z range of objects that will be affected by this light. Equivalent to :ref:`Light2D.range_z_min<class_Light2D_property_range_z_min>` and :ref:`Light2D.range_z_max<class_Light2D_property_range_z_max>`.
- :ref:`RID<class_RID>` canvas_occluder_polygon_create ( )
Creates a new light occluder polygon and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all canvas_occluder_polygon_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
- void canvas_occluder_polygon_set_cull_mode ( :ref:`RID<class_RID>` occluder_polygon, :ref:`CanvasOccluderPolygonCullMode<enum_VisualServer_CanvasOccluderPolygonCullMode>` mode )
Sets an occluder polygons cull mode. See :ref:`CanvasOccluderPolygonCullMode<enum_VisualServer_CanvasOccluderPolygonCullMode>` constants.
- void canvas_occluder_polygon_set_shape ( :ref:`RID<class_RID>` occluder_polygon, :ref:`PackedVector2Array<class_PackedVector2Array>` shape, :ref:`bool<class_bool>` closed )
Sets the shape of the occluder polygon.
- void canvas_occluder_polygon_set_shape_as_lines ( :ref:`RID<class_RID>` occluder_polygon, :ref:`PackedVector2Array<class_PackedVector2Array>` shape )
Sets the shape of the occluder polygon as lines.
- void canvas_set_item_mirroring ( :ref:`RID<class_RID>` canvas, :ref:`RID<class_RID>` item, :ref:`Vector2<class_Vector2>` mirroring )
A copy of the canvas item will be drawn with a local offset of the mirroring :ref:`Vector2<class_Vector2>`.
- void canvas_set_modulate ( :ref:`RID<class_RID>` canvas, :ref:`Color<class_Color>` color )
Modulates all colors in the given canvas.
- :ref:`RID<class_RID>` directional_light_create ( )
Creates a directional light and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID can be used in most light_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
To place in a scene, attach this directional light to an instance using :ref:`instance_set_base<class_VisualServer_method_instance_set_base>` using the returned RID.
- :ref:`RID<class_RID>` environment_create ( )
Creates an environment and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all environment_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
- void environment_set_adjustment ( :ref:`RID<class_RID>` env, :ref:`bool<class_bool>` enable, :ref:`float<class_float>` brightness, :ref:`float<class_float>` contrast, :ref:`float<class_float>` saturation, :ref:`RID<class_RID>` ramp )
Sets the values to be used with the "Adjustment" post-process effect. See :ref:`Environment<class_Environment>` for more details.
- void environment_set_ambient_light ( :ref:`RID<class_RID>` env, :ref:`Color<class_Color>` color, :ref:`EnvironmentAmbientSource<enum_VisualServer_EnvironmentAmbientSource>` ambient=0, :ref:`float<class_float>` energy=1.0, :ref:`float<class_float>` sky_contibution=0.0, :ref:`EnvironmentReflectionSource<enum_VisualServer_EnvironmentReflectionSource>` reflection_source=0, :ref:`Color<class_Color>` ao_color=Color( 0, 0, 0, 1 ) )
- void environment_set_background ( :ref:`RID<class_RID>` env, :ref:`EnvironmentBG<enum_VisualServer_EnvironmentBG>` bg )
Sets the BGMode of the environment. Equivalent to :ref:`Environment.background_mode<class_Environment_property_background_mode>`.
- void environment_set_bg_color ( :ref:`RID<class_RID>` env, :ref:`Color<class_Color>` color )
Color displayed for clear areas of the scene (if using Custom color or Color+Sky background modes).
- void environment_set_bg_energy ( :ref:`RID<class_RID>` env, :ref:`float<class_float>` energy )
Sets the intensity of the background color.
- void environment_set_canvas_max_layer ( :ref:`RID<class_RID>` env, :ref:`int<class_int>` max_layer )
Sets the maximum layer to use if using Canvas background mode.
- void environment_set_fog ( :ref:`RID<class_RID>` env, :ref:`bool<class_bool>` enable, :ref:`Color<class_Color>` color, :ref:`Color<class_Color>` sun_color, :ref:`float<class_float>` sun_amount )
Sets the variables to be used with the scene fog. See :ref:`Environment<class_Environment>` for more details.
- void environment_set_fog_depth ( :ref:`RID<class_RID>` env, :ref:`bool<class_bool>` enable, :ref:`float<class_float>` depth_begin, :ref:`float<class_float>` depth_end, :ref:`float<class_float>` depth_curve, :ref:`bool<class_bool>` transmit, :ref:`float<class_float>` transmit_curve )
Sets the variables to be used with the fog depth effect. See :ref:`Environment<class_Environment>` for more details.
- void environment_set_fog_height ( :ref:`RID<class_RID>` env, :ref:`bool<class_bool>` enable, :ref:`float<class_float>` min_height, :ref:`float<class_float>` max_height, :ref:`float<class_float>` height_curve )
Sets the variables to be used with the fog height effect. See :ref:`Environment<class_Environment>` for more details.
- void environment_set_glow ( :ref:`RID<class_RID>` env, :ref:`bool<class_bool>` enable, :ref:`int<class_int>` level_flags, :ref:`float<class_float>` intensity, :ref:`float<class_float>` strength, :ref:`float<class_float>` mix, :ref:`float<class_float>` bloom_threshold, :ref:`EnvironmentGlowBlendMode<enum_VisualServer_EnvironmentGlowBlendMode>` blend_mode, :ref:`float<class_float>` hdr_bleed_threshold, :ref:`float<class_float>` hdr_bleed_scale, :ref:`float<class_float>` hdr_luminance_cap, :ref:`bool<class_bool>` bicubic_upscale )
- void environment_set_sky ( :ref:`RID<class_RID>` env, :ref:`RID<class_RID>` sky )
Sets the :ref:`Sky<class_Sky>` to be used as the environment's background when using BGMode sky. Equivalent to :ref:`Environment.sky<class_Environment_property_sky>`.
- void environment_set_sky_custom_fov ( :ref:`RID<class_RID>` env, :ref:`float<class_float>` scale )
Sets a custom field of view for the background :ref:`Sky<class_Sky>`. Equivalent to :ref:`Environment.sky_custom_fov<class_Environment_property_sky_custom_fov>`.
- void environment_set_sky_orientation ( :ref:`RID<class_RID>` env, :ref:`Basis<class_Basis>` orientation )
Sets the rotation of the background :ref:`Sky<class_Sky>` expressed as a :ref:`Basis<class_Basis>`. Equivalent to :ref:`Environment.sky_rotation<class_Environment_property_sky_rotation>`, where the rotation vector is used to construct the :ref:`Basis<class_Basis>`.
- void environment_set_ssao ( :ref:`RID<class_RID>` env, :ref:`bool<class_bool>` enable, :ref:`float<class_float>` radius, :ref:`float<class_float>` intensity, :ref:`float<class_float>` bias, :ref:`float<class_float>` light_affect, :ref:`float<class_float>` ao_channel_affect, :ref:`EnvironmentSSAOBlur<enum_VisualServer_EnvironmentSSAOBlur>` blur, :ref:`float<class_float>` bilateral_sharpness )
- void environment_set_ssr ( :ref:`RID<class_RID>` env, :ref:`bool<class_bool>` enable, :ref:`int<class_int>` max_steps, :ref:`float<class_float>` fade_in, :ref:`float<class_float>` fade_out, :ref:`float<class_float>` depth_tolerance, :ref:`bool<class_bool>` roughness )
Sets the variables to be used with the "screen space reflections" post-process effect. See :ref:`Environment<class_Environment>` for more details.
- void environment_set_tonemap ( :ref:`RID<class_RID>` env, :ref:`EnvironmentToneMapper<enum_VisualServer_EnvironmentToneMapper>` tone_mapper, :ref:`float<class_float>` exposure, :ref:`float<class_float>` white, :ref:`bool<class_bool>` auto_exposure, :ref:`float<class_float>` min_luminance, :ref:`float<class_float>` max_luminance, :ref:`float<class_float>` auto_exp_speed, :ref:`float<class_float>` auto_exp_grey )
Sets the variables to be used with the "tonemap" post-process effect. See :ref:`Environment<class_Environment>` for more details.
- void finish ( )
Removes buffers and clears testcubes.
- void force_draw ( :ref:`bool<class_bool>` swap_buffers=true, :ref:`float<class_float>` frame_step=0.0 )
Forces a frame to be drawn when the function is called. Drawing a frame updates all :ref:`Viewport<class_Viewport>`s that are set to update. Use with extreme caution.
- void force_sync ( )
Synchronizes threads.
- void free_rid ( :ref:`RID<class_RID>` rid )
Tries to free an object in the VisualServer.
- :ref:`int<class_int>` get_render_info ( :ref:`RenderInfo<enum_VisualServer_RenderInfo>` info )
Returns a certain information, see :ref:`RenderInfo<enum_VisualServer_RenderInfo>` for options.
- :ref:`RID<class_RID>` get_test_cube ( )
Returns the id of the test cube. Creates one if none exists.
- :ref:`RID<class_RID>` get_test_texture ( )
Returns the id of the test texture. Creates one if none exists.
- :ref:`String<class_String>` get_video_adapter_name ( ) const
Returns the name of the video adapter (e.g. "GeForce GTX 1080/PCIe/SSE2").
Note: When running a headless or server binary, this function returns an empty string.
- :ref:`String<class_String>` get_video_adapter_vendor ( ) const
Returns the vendor of the video adapter (e.g. "NVIDIA Corporation").
Note: When running a headless or server binary, this function returns an empty string.
- :ref:`RID<class_RID>` get_white_texture ( )
Returns the id of a white texture. Creates one if none exists.
- :ref:`bool<class_bool>` has_changed ( ) const
Returns true if changes have been made to the VisualServer's data. :ref:`force_draw<class_VisualServer_method_force_draw>` is usually called if this happens.
- :ref:`bool<class_bool>` has_feature ( :ref:`Features<enum_VisualServer_Features>` feature ) const
Not yet implemented. Always returns false.
- :ref:`bool<class_bool>` has_os_feature ( :ref:`String<class_String>` feature ) const
Returns true if the OS supports a certain feature. Features might be s3tc, etc, etc2 and pvrtc.
- void immediate_begin ( :ref:`RID<class_RID>` immediate, :ref:`PrimitiveType<enum_VisualServer_PrimitiveType>` primitive, :ref:`RID<class_RID>` texture )
Sets up :ref:`ImmediateGeometry<class_ImmediateGeometry>` internals to prepare for drawing. Equivalent to :ref:`ImmediateGeometry.begin<class_ImmediateGeometry_method_begin>`.
- void immediate_clear ( :ref:`RID<class_RID>` immediate )
Clears everything that was set up between :ref:`immediate_begin<class_VisualServer_method_immediate_begin>` and :ref:`immediate_end<class_VisualServer_method_immediate_end>`. Equivalent to :ref:`ImmediateGeometry.clear<class_ImmediateGeometry_method_clear>`.
- void immediate_color ( :ref:`RID<class_RID>` immediate, :ref:`Color<class_Color>` color )
Sets the color to be used with next vertex. Equivalent to :ref:`ImmediateGeometry.set_color<class_ImmediateGeometry_method_set_color>`.
- :ref:`RID<class_RID>` immediate_create ( )
Creates an immediate geometry and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all immediate_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
To place in a scene, attach this immediate geometry to an instance using :ref:`instance_set_base<class_VisualServer_method_instance_set_base>` using the returned RID.
- void immediate_end ( :ref:`RID<class_RID>` immediate )
Ends drawing the :ref:`ImmediateGeometry<class_ImmediateGeometry>` and displays it. Equivalent to :ref:`ImmediateGeometry.end<class_ImmediateGeometry_method_end>`.
- :ref:`RID<class_RID>` immediate_get_material ( :ref:`RID<class_RID>` immediate ) const
Returns the material assigned to the :ref:`ImmediateGeometry<class_ImmediateGeometry>`.
- void immediate_normal ( :ref:`RID<class_RID>` immediate, :ref:`Vector3<class_Vector3>` normal )
Sets the normal to be used with next vertex. Equivalent to :ref:`ImmediateGeometry.set_normal<class_ImmediateGeometry_method_set_normal>`.
- void immediate_set_material ( :ref:`RID<class_RID>` immediate, :ref:`RID<class_RID>` material )
Sets the material to be used to draw the :ref:`ImmediateGeometry<class_ImmediateGeometry>`.
- void immediate_tangent ( :ref:`RID<class_RID>` immediate, :ref:`Plane<class_Plane>` tangent )
Sets the tangent to be used with next vertex. Equivalent to :ref:`ImmediateGeometry.set_tangent<class_ImmediateGeometry_method_set_tangent>`.
- void immediate_uv ( :ref:`RID<class_RID>` immediate, :ref:`Vector2<class_Vector2>` tex_uv )
Sets the UV to be used with next vertex. Equivalent to :ref:`ImmediateGeometry.set_uv<class_ImmediateGeometry_method_set_uv>`.
- void immediate_uv2 ( :ref:`RID<class_RID>` immediate, :ref:`Vector2<class_Vector2>` tex_uv )
Sets the UV2 to be used with next vertex. Equivalent to :ref:`ImmediateGeometry.set_uv2<class_ImmediateGeometry_method_set_uv2>`.
- void immediate_vertex ( :ref:`RID<class_RID>` immediate, :ref:`Vector3<class_Vector3>` vertex )
Adds the next vertex using the information provided in advance. Equivalent to :ref:`ImmediateGeometry.add_vertex<class_ImmediateGeometry_method_add_vertex>`.
- void immediate_vertex_2d ( :ref:`RID<class_RID>` immediate, :ref:`Vector2<class_Vector2>` vertex )
Adds the next vertex using the information provided in advance. This is a helper class that calls :ref:`immediate_vertex<class_VisualServer_method_immediate_vertex>` under the hood. Equivalent to :ref:`ImmediateGeometry.add_vertex<class_ImmediateGeometry_method_add_vertex>`.
- void init ( )
Initializes the visual server. This function is called internally by platform-dependent code during engine initialization. If called from a running game, it will not do anything.
- void instance_attach_object_instance_id ( :ref:`RID<class_RID>` instance, :ref:`int<class_int>` id )
Attaches a unique Object ID to instance. Object ID must be attached to instance for proper culling with :ref:`instances_cull_aabb<class_VisualServer_method_instances_cull_aabb>`, :ref:`instances_cull_convex<class_VisualServer_method_instances_cull_convex>`, and :ref:`instances_cull_ray<class_VisualServer_method_instances_cull_ray>`.
- void instance_attach_skeleton ( :ref:`RID<class_RID>` instance, :ref:`RID<class_RID>` skeleton )
Attaches a skeleton to an instance. Removes the previous skeleton from the instance.
- :ref:`RID<class_RID>` instance_create ( )
Creates a visual instance and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all instance_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
An instance is a way of placing a 3D object in the scenario. Objects like particles, meshes, and reflection probes need to be associated with an instance to be visible in the scenario using :ref:`instance_set_base<class_VisualServer_method_instance_set_base>`.
- :ref:`RID<class_RID>` instance_create2 ( :ref:`RID<class_RID>` base, :ref:`RID<class_RID>` scenario )
Creates a visual instance, adds it to the VisualServer, and sets both base and scenario. It can be accessed with the RID that is returned. This RID will be used in all instance_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
- void instance_geometry_set_as_instance_lod ( :ref:`RID<class_RID>` instance, :ref:`RID<class_RID>` as_lod_of_instance )
Not implemented in Godot 3.x.
- void instance_geometry_set_cast_shadows_setting ( :ref:`RID<class_RID>` instance, :ref:`ShadowCastingSetting<enum_VisualServer_ShadowCastingSetting>` shadow_casting_setting )
Sets the shadow casting setting to one of :ref:`ShadowCastingSetting<enum_VisualServer_ShadowCastingSetting>`. Equivalent to :ref:`GeometryInstance.cast_shadow<class_GeometryInstance_property_cast_shadow>`.
- void instance_geometry_set_draw_range ( :ref:`RID<class_RID>` instance, :ref:`float<class_float>` min, :ref:`float<class_float>` max, :ref:`float<class_float>` min_margin, :ref:`float<class_float>` max_margin )
Not implemented in Godot 3.x.
- void instance_geometry_set_flag ( :ref:`RID<class_RID>` instance, :ref:`InstanceFlags<enum_VisualServer_InstanceFlags>` flag, :ref:`bool<class_bool>` enabled )
Sets the flag for a given :ref:`InstanceFlags<enum_VisualServer_InstanceFlags>`. See :ref:`InstanceFlags<enum_VisualServer_InstanceFlags>` for more details.
- void instance_geometry_set_material_override ( :ref:`RID<class_RID>` instance, :ref:`RID<class_RID>` material )
Sets a material that will override the material for all surfaces on the mesh associated with this instance. Equivalent to :ref:`GeometryInstance.material_override<class_GeometryInstance_property_material_override>`.
- void instance_set_base ( :ref:`RID<class_RID>` instance, :ref:`RID<class_RID>` base )
Sets the base of the instance. A base can be any of the 3D objects that are created in the VisualServer that can be displayed. For example, any of the light types, mesh, multimesh, immediate geometry, particle system, reflection probe, lightmap capture, and the GI probe are all types that can be set as the base of an instance in order to be displayed in the scenario.
- void instance_set_blend_shape_weight ( :ref:`RID<class_RID>` instance, :ref:`int<class_int>` shape, :ref:`float<class_float>` weight )
Sets the weight for a given blend shape associated with this instance.
- void instance_set_custom_aabb ( :ref:`RID<class_RID>` instance, :ref:`AABB<class_AABB>` aabb )
Sets a custom AABB to use when culling objects from the view frustum. Equivalent to :ref:`GeometryInstance.set_custom_aabb<class_GeometryInstance_method_set_custom_aabb>`.
- void instance_set_exterior ( :ref:`RID<class_RID>` instance, :ref:`bool<class_bool>` enabled )
Function not implemented in Godot 3.x.
- void instance_set_extra_visibility_margin ( :ref:`RID<class_RID>` instance, :ref:`float<class_float>` margin )
Sets a margin to increase the size of the AABB when culling objects from the view frustum. This allows you avoid culling objects that fall outside the view frustum. Equivalent to :ref:`GeometryInstance.extra_cull_margin<class_GeometryInstance_property_extra_cull_margin>`.
- void instance_set_layer_mask ( :ref:`RID<class_RID>` instance, :ref:`int<class_int>` mask )
Sets the render layers that this instance will be drawn to. Equivalent to :ref:`VisualInstance.layers<class_VisualInstance_property_layers>`.
- void instance_set_scenario ( :ref:`RID<class_RID>` instance, :ref:`RID<class_RID>` scenario )
Sets the scenario that the instance is in. The scenario is the 3D world that the objects will be displayed in.
- void instance_set_surface_material ( :ref:`RID<class_RID>` instance, :ref:`int<class_int>` surface, :ref:`RID<class_RID>` material )
Sets the material of a specific surface. Equivalent to :ref:`MeshInstance.set_surface_material<class_MeshInstance_method_set_surface_material>`.
- void instance_set_transform ( :ref:`RID<class_RID>` instance, :ref:`Transform<class_Transform>` transform )
Sets the world space transform of the instance. Equivalent to :ref:`Spatial.transform<class_Spatial_property_transform>`.
- void instance_set_use_lightmap ( :ref:`RID<class_RID>` instance, :ref:`RID<class_RID>` lightmap_instance, :ref:`RID<class_RID>` lightmap )
Sets the lightmap to use with this instance.
- void instance_set_visible ( :ref:`RID<class_RID>` instance, :ref:`bool<class_bool>` visible )
Sets whether an instance is drawn or not. Equivalent to :ref:`Spatial.visible<class_Spatial_property_visible>`.
- :ref:`Array<class_Array>` instances_cull_aabb ( :ref:`AABB<class_AABB>` aabb, :ref:`RID<class_RID>` scenario ) const
Returns an array of object IDs intersecting with the provided AABB. Only visual 3D nodes are considered, such as :ref:`MeshInstance<class_MeshInstance>` or :ref:`DirectionalLight<class_DirectionalLight>`. Use :ref:`@GDScript.instance_from_id<class_@GDScript_method_instance_from_id>` to obtain the actual nodes. A scenario RID must be provided, which is available in the :ref:`World<class_World>` you want to query. This forces an update for all resources queued to update.
Warning: This function is primarily intended for editor usage. For in-game use cases, prefer physics collision.
- :ref:`Array<class_Array>` instances_cull_convex ( :ref:`Array<class_Array>` convex, :ref:`RID<class_RID>` scenario ) const
Returns an array of object IDs intersecting with the provided convex shape. Only visual 3D nodes are considered, such as :ref:`MeshInstance<class_MeshInstance>` or :ref:`DirectionalLight<class_DirectionalLight>`. Use :ref:`@GDScript.instance_from_id<class_@GDScript_method_instance_from_id>` to obtain the actual nodes. A scenario RID must be provided, which is available in the :ref:`World<class_World>` you want to query. This forces an update for all resources queued to update.
Warning: This function is primarily intended for editor usage. For in-game use cases, prefer physics collision.
- :ref:`Array<class_Array>` instances_cull_ray ( :ref:`Vector3<class_Vector3>` from, :ref:`Vector3<class_Vector3>` to, :ref:`RID<class_RID>` scenario ) const
Returns an array of object IDs intersecting with the provided 3D ray. Only visual 3D nodes are considered, such as :ref:`MeshInstance<class_MeshInstance>` or :ref:`DirectionalLight<class_DirectionalLight>`. Use :ref:`@GDScript.instance_from_id<class_@GDScript_method_instance_from_id>` to obtain the actual nodes. A scenario RID must be provided, which is available in the :ref:`World<class_World>` you want to query. This forces an update for all resources queued to update.
Warning: This function is primarily intended for editor usage. For in-game use cases, prefer physics collision.
- void light_directional_set_blend_splits ( :ref:`RID<class_RID>` light, :ref:`bool<class_bool>` enable )
If true, this directional light will blend between shadow map splits resulting in a smoother transition between them. Equivalent to :ref:`DirectionalLight.directional_shadow_blend_splits<class_DirectionalLight_property_directional_shadow_blend_splits>`.
- void light_directional_set_shadow_depth_range_mode ( :ref:`RID<class_RID>` light, :ref:`LightDirectionalShadowDepthRangeMode<enum_VisualServer_LightDirectionalShadowDepthRangeMode>` range_mode )
Sets the shadow depth range mode for this directional light. Equivalent to :ref:`DirectionalLight.directional_shadow_depth_range<class_DirectionalLight_property_directional_shadow_depth_range>`. See :ref:`LightDirectionalShadowDepthRangeMode<enum_VisualServer_LightDirectionalShadowDepthRangeMode>` for options.
- void light_directional_set_shadow_mode ( :ref:`RID<class_RID>` light, :ref:`LightDirectionalShadowMode<enum_VisualServer_LightDirectionalShadowMode>` mode )
Sets the shadow mode for this directional light. Equivalent to :ref:`DirectionalLight.directional_shadow_mode<class_DirectionalLight_property_directional_shadow_mode>`. See :ref:`LightDirectionalShadowMode<enum_VisualServer_LightDirectionalShadowMode>` for options.
- void light_omni_set_shadow_mode ( :ref:`RID<class_RID>` light, :ref:`LightOmniShadowMode<enum_VisualServer_LightOmniShadowMode>` mode )
Sets whether to use a dual paraboloid or a cubemap for the shadow map. Dual paraboloid is faster but may suffer from artifacts. Equivalent to :ref:`OmniLight.omni_shadow_mode<class_OmniLight_property_omni_shadow_mode>`.
- void light_set_color ( :ref:`RID<class_RID>` light, :ref:`Color<class_Color>` color )
Sets the color of the light. Equivalent to :ref:`Light.light_color<class_Light_property_light_color>`.
- void light_set_cull_mask ( :ref:`RID<class_RID>` light, :ref:`int<class_int>` mask )
Sets the cull mask for this Light. Lights only affect objects in the selected layers. Equivalent to :ref:`Light.light_cull_mask<class_Light_property_light_cull_mask>`.
- void light_set_negative ( :ref:`RID<class_RID>` light, :ref:`bool<class_bool>` enable )
If true, light will subtract light instead of adding light. Equivalent to :ref:`Light.light_negative<class_Light_property_light_negative>`.
- void light_set_param ( :ref:`RID<class_RID>` light, :ref:`LightParam<enum_VisualServer_LightParam>` param, :ref:`float<class_float>` value )
Sets the specified light parameter. See :ref:`LightParam<enum_VisualServer_LightParam>` for options. Equivalent to :ref:`Light.set_param<class_Light_method_set_param>`.
- void light_set_projector ( :ref:`RID<class_RID>` light, :ref:`RID<class_RID>` texture )
Not implemented in Godot 3.x.
- void light_set_reverse_cull_face_mode ( :ref:`RID<class_RID>` light, :ref:`bool<class_bool>` enabled )
If true, reverses the backface culling of the mesh. This can be useful when you have a flat mesh that has a light behind it. If you need to cast a shadow on both sides of the mesh, set the mesh to use double sided shadows with :ref:`instance_geometry_set_cast_shadows_setting<class_VisualServer_method_instance_geometry_set_cast_shadows_setting>`. Equivalent to :ref:`Light.shadow_reverse_cull_face<class_Light_property_shadow_reverse_cull_face>`.
- void light_set_shadow ( :ref:`RID<class_RID>` light, :ref:`bool<class_bool>` enabled )
If true, light will cast shadows. Equivalent to :ref:`Light.shadow_enabled<class_Light_property_shadow_enabled>`.
- void light_set_shadow_color ( :ref:`RID<class_RID>` light, :ref:`Color<class_Color>` color )
Sets the color of the shadow cast by the light. Equivalent to :ref:`Light.shadow_color<class_Light_property_shadow_color>`.
- void light_set_use_gi ( :ref:`RID<class_RID>` light, :ref:`bool<class_bool>` enabled )
Sets whether GI probes capture light information from this light.
- :ref:`RID<class_RID>` lightmap_capture_create ( )
Creates a lightmap capture and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all lightmap_capture_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
To place in a scene, attach this lightmap capture to an instance using :ref:`instance_set_base<class_VisualServer_method_instance_set_base>` using the returned RID.
- :ref:`AABB<class_AABB>` lightmap_capture_get_bounds ( :ref:`RID<class_RID>` capture ) const
Returns the size of the lightmap capture area.
- :ref:`float<class_float>` lightmap_capture_get_energy ( :ref:`RID<class_RID>` capture ) const
Returns the energy multiplier used by the lightmap capture.
- :ref:`PackedByteArray<class_PackedByteArray>` lightmap_capture_get_octree ( :ref:`RID<class_RID>` capture ) const
Returns the octree used by the lightmap capture.
- :ref:`int<class_int>` lightmap_capture_get_octree_cell_subdiv ( :ref:`RID<class_RID>` capture ) const
Returns the cell subdivision amount used by this lightmap capture's octree.
- :ref:`Transform<class_Transform>` lightmap_capture_get_octree_cell_transform ( :ref:`RID<class_RID>` capture ) const
Returns the cell transform for this lightmap capture's octree.
- void lightmap_capture_set_bounds ( :ref:`RID<class_RID>` capture, :ref:`AABB<class_AABB>` bounds )
Sets the size of the area covered by the lightmap capture.
- void lightmap_capture_set_energy ( :ref:`RID<class_RID>` capture, :ref:`float<class_float>` energy )
Sets the energy multiplier for this lightmap capture.
- void lightmap_capture_set_octree ( :ref:`RID<class_RID>` capture, :ref:`PackedByteArray<class_PackedByteArray>` octree )
Sets the octree to be used by this lightmap capture.
- void lightmap_capture_set_octree_cell_subdiv ( :ref:`RID<class_RID>` capture, :ref:`int<class_int>` subdiv )
Sets the subdivision level of this lightmap capture's octree.
- void lightmap_capture_set_octree_cell_transform ( :ref:`RID<class_RID>` capture, :ref:`Transform<class_Transform>` xform )
Sets the octree cell transform for this lightmap capture's octree.
- :ref:`RID<class_RID>` make_sphere_mesh ( :ref:`int<class_int>` latitudes, :ref:`int<class_int>` longitudes, :ref:`float<class_float>` radius )
Returns a mesh of a sphere with the given amount of horizontal and vertical subdivisions.
- :ref:`RID<class_RID>` material_create ( )
Creates an empty material and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all material_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
- :ref:`Variant<class_Variant>` material_get_param ( :ref:`RID<class_RID>` material, :ref:`StringName<class_StringName>` parameter ) const
Returns the value of a certain material's parameter.
- void material_set_next_pass ( :ref:`RID<class_RID>` material, :ref:`RID<class_RID>` next_material )
Sets an object's next material.
- void material_set_param ( :ref:`RID<class_RID>` material, :ref:`StringName<class_StringName>` parameter, :ref:`Variant<class_Variant>` value )
Sets a material's parameter.
- void material_set_render_priority ( :ref:`RID<class_RID>` material, :ref:`int<class_int>` priority )
Sets a material's render priority.
- void material_set_shader ( :ref:`RID<class_RID>` shader_material, :ref:`RID<class_RID>` shader )
Sets a shader material's shader.
- void mesh_add_surface_from_arrays ( :ref:`RID<class_RID>` mesh, :ref:`PrimitiveType<enum_VisualServer_PrimitiveType>` primitive, :ref:`Array<class_Array>` arrays, :ref:`Array<class_Array>` blend_shapes=[ ], :ref:`Dictionary<class_Dictionary>` lods={ }, :ref:`int<class_int>` compress_format=31744 )
- void mesh_clear ( :ref:`RID<class_RID>` mesh )
Removes all surfaces from a mesh.
- :ref:`RID<class_RID>` mesh_create ( )
Creates a new mesh and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all mesh_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
To place in a scene, attach this mesh to an instance using :ref:`instance_set_base<class_VisualServer_method_instance_set_base>` using the returned RID.
- :ref:`int<class_int>` mesh_get_blend_shape_count ( :ref:`RID<class_RID>` mesh ) const
Returns a mesh's blend shape count.
- :ref:`BlendShapeMode<enum_VisualServer_BlendShapeMode>` mesh_get_blend_shape_mode ( :ref:`RID<class_RID>` mesh ) const
Returns a mesh's blend shape mode.
- :ref:`AABB<class_AABB>` mesh_get_custom_aabb ( :ref:`RID<class_RID>` mesh ) const
Returns a mesh's custom aabb.
- :ref:`int<class_int>` mesh_get_surface_count ( :ref:`RID<class_RID>` mesh ) const
Returns a mesh's number of surfaces.
- void mesh_set_blend_shape_mode ( :ref:`RID<class_RID>` mesh, :ref:`BlendShapeMode<enum_VisualServer_BlendShapeMode>` mode )
Sets a mesh's blend shape mode.
- void mesh_set_custom_aabb ( :ref:`RID<class_RID>` mesh, :ref:`AABB<class_AABB>` aabb )
Sets a mesh's custom aabb.
- :ref:`Array<class_Array>` mesh_surface_get_arrays ( :ref:`RID<class_RID>` mesh, :ref:`int<class_int>` surface ) const
Returns a mesh's surface's buffer arrays.
- :ref:`Array<class_Array>` mesh_surface_get_blend_shape_arrays ( :ref:`RID<class_RID>` mesh, :ref:`int<class_int>` surface ) const
Returns a mesh's surface's arrays for blend shapes.
- :ref:`int<class_int>` mesh_surface_get_format_offset ( :ref:`int<class_int>` format, :ref:`int<class_int>` vertex_len, :ref:`int<class_int>` index_len, :ref:`int<class_int>` array_index ) const
Function is unused in Godot 3.x.
- :ref:`int<class_int>` mesh_surface_get_format_stride ( :ref:`int<class_int>` format, :ref:`int<class_int>` vertex_len, :ref:`int<class_int>` index_len ) const
Function is unused in Godot 3.x.
- :ref:`RID<class_RID>` mesh_surface_get_material ( :ref:`RID<class_RID>` mesh, :ref:`int<class_int>` surface ) const
Returns a mesh's surface's material.
- void mesh_surface_set_material ( :ref:`RID<class_RID>` mesh, :ref:`int<class_int>` surface, :ref:`RID<class_RID>` material )
Sets a mesh's surface's material.
- void mesh_surface_update_region ( :ref:`RID<class_RID>` mesh, :ref:`int<class_int>` surface, :ref:`int<class_int>` offset, :ref:`PackedByteArray<class_PackedByteArray>` data )
Updates a specific region of a vertex buffer for the specified surface. Warning: this function alters the vertex buffer directly with no safety mechanisms, you can easily corrupt your mesh.
- void multimesh_allocate ( :ref:`RID<class_RID>` multimesh, :ref:`int<class_int>` instances, :ref:`MultimeshTransformFormat<enum_VisualServer_MultimeshTransformFormat>` transform_format, :ref:`bool<class_bool>` color_format=false, :ref:`bool<class_bool>` custom_data_format=false )
- :ref:`RID<class_RID>` multimesh_create ( )
Creates a new multimesh on the VisualServer and returns an :ref:`RID<class_RID>` handle. This RID will be used in all multimesh_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
To place in a scene, attach this multimesh to an instance using :ref:`instance_set_base<class_VisualServer_method_instance_set_base>` using the returned RID.
- :ref:`AABB<class_AABB>` multimesh_get_aabb ( :ref:`RID<class_RID>` multimesh ) const
Calculates and returns the axis-aligned bounding box that encloses all instances within the multimesh.
- :ref:`PackedFloat32Array<class_PackedFloat32Array>` multimesh_get_buffer ( :ref:`RID<class_RID>` multimesh ) const
- :ref:`int<class_int>` multimesh_get_instance_count ( :ref:`RID<class_RID>` multimesh ) const
Returns the number of instances allocated for this multimesh.
- :ref:`RID<class_RID>` multimesh_get_mesh ( :ref:`RID<class_RID>` multimesh ) const
Returns the RID of the mesh that will be used in drawing this multimesh.
- :ref:`int<class_int>` multimesh_get_visible_instances ( :ref:`RID<class_RID>` multimesh ) const
Returns the number of visible instances for this multimesh.
- :ref:`Color<class_Color>` multimesh_instance_get_color ( :ref:`RID<class_RID>` multimesh, :ref:`int<class_int>` index ) const
Returns the color by which the specified instance will be modulated.
- :ref:`Color<class_Color>` multimesh_instance_get_custom_data ( :ref:`RID<class_RID>` multimesh, :ref:`int<class_int>` index ) const
Returns the custom data associated with the specified instance.
- :ref:`Transform<class_Transform>` multimesh_instance_get_transform ( :ref:`RID<class_RID>` multimesh, :ref:`int<class_int>` index ) const
Returns the :ref:`Transform<class_Transform>` of the specified instance.
- :ref:`Transform2D<class_Transform2D>` multimesh_instance_get_transform_2d ( :ref:`RID<class_RID>` multimesh, :ref:`int<class_int>` index ) const
Returns the :ref:`Transform2D<class_Transform2D>` of the specified instance. For use when the multimesh is set to use 2D transforms.
- void multimesh_instance_set_color ( :ref:`RID<class_RID>` multimesh, :ref:`int<class_int>` index, :ref:`Color<class_Color>` color )
Sets the color by which this instance will be modulated. Equivalent to :ref:`MultiMesh.set_instance_color<class_MultiMesh_method_set_instance_color>`.
- void multimesh_instance_set_custom_data ( :ref:`RID<class_RID>` multimesh, :ref:`int<class_int>` index, :ref:`Color<class_Color>` custom_data )
Sets the custom data for this instance. Custom data is passed as a :ref:`Color<class_Color>`, but is interpreted as a vec4 in the shader. Equivalent to :ref:`MultiMesh.set_instance_custom_data<class_MultiMesh_method_set_instance_custom_data>`.
- void multimesh_instance_set_transform ( :ref:`RID<class_RID>` multimesh, :ref:`int<class_int>` index, :ref:`Transform<class_Transform>` transform )
Sets the :ref:`Transform<class_Transform>` for this instance. Equivalent to :ref:`MultiMesh.set_instance_transform<class_MultiMesh_method_set_instance_transform>`.
- void multimesh_instance_set_transform_2d ( :ref:`RID<class_RID>` multimesh, :ref:`int<class_int>` index, :ref:`Transform2D<class_Transform2D>` transform )
Sets the :ref:`Transform2D<class_Transform2D>` for this instance. For use when multimesh is used in 2D. Equivalent to :ref:`MultiMesh.set_instance_transform_2d<class_MultiMesh_method_set_instance_transform_2d>`.
- void multimesh_set_buffer ( :ref:`RID<class_RID>` multimesh, :ref:`PackedFloat32Array<class_PackedFloat32Array>` buffer )
- void multimesh_set_mesh ( :ref:`RID<class_RID>` multimesh, :ref:`RID<class_RID>` mesh )
Sets the mesh to be drawn by the multimesh. Equivalent to :ref:`MultiMesh.mesh<class_MultiMesh_property_mesh>`.
- void multimesh_set_visible_instances ( :ref:`RID<class_RID>` multimesh, :ref:`int<class_int>` visible )
Sets the number of instances visible at a given time. If -1, all instances that have been allocated are drawn. Equivalent to :ref:`MultiMesh.visible_instance_count<class_MultiMesh_property_visible_instance_count>`.
- :ref:`RID<class_RID>` omni_light_create ( )
Creates a new omni light and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID can be used in most light_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
To place in a scene, attach this omni light to an instance using :ref:`instance_set_base<class_VisualServer_method_instance_set_base>` using the returned RID.
- :ref:`RID<class_RID>` particles_create ( )
Creates a particle system and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all particles_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
To place in a scene, attach these particles to an instance using :ref:`instance_set_base<class_VisualServer_method_instance_set_base>` using the returned RID.
- :ref:`AABB<class_AABB>` particles_get_current_aabb ( :ref:`RID<class_RID>` particles )
Calculates and returns the axis-aligned bounding box that contains all the particles. Equivalent to :ref:`Particles.capture_aabb<class_Particles_method_capture_aabb>`.
- :ref:`bool<class_bool>` particles_get_emitting ( :ref:`RID<class_RID>` particles )
Returns true if particles are currently set to emitting.
- :ref:`bool<class_bool>` particles_is_inactive ( :ref:`RID<class_RID>` particles )
Returns true if particles are not emitting and particles are set to inactive.
- void particles_request_process ( :ref:`RID<class_RID>` particles )
Add particle system to list of particle systems that need to be updated. Update will take place on the next frame, or on the next call to :ref:`instances_cull_aabb<class_VisualServer_method_instances_cull_aabb>`, :ref:`instances_cull_convex<class_VisualServer_method_instances_cull_convex>`, or :ref:`instances_cull_ray<class_VisualServer_method_instances_cull_ray>`.
- void particles_restart ( :ref:`RID<class_RID>` particles )
Reset the particles on the next update. Equivalent to :ref:`Particles.restart<class_Particles_method_restart>`.
- void particles_set_amount ( :ref:`RID<class_RID>` particles, :ref:`int<class_int>` amount )
Sets the number of particles to be drawn and allocates the memory for them. Equivalent to :ref:`Particles.amount<class_Particles_property_amount>`.
- void particles_set_custom_aabb ( :ref:`RID<class_RID>` particles, :ref:`AABB<class_AABB>` aabb )
Sets a custom axis-aligned bounding box for the particle system. Equivalent to :ref:`Particles.visibility_aabb<class_Particles_property_visibility_aabb>`.
- void particles_set_draw_order ( :ref:`RID<class_RID>` particles, :ref:`ParticlesDrawOrder<enum_VisualServer_ParticlesDrawOrder>` order )
Sets the draw order of the particles to one of the named enums from :ref:`ParticlesDrawOrder<enum_VisualServer_ParticlesDrawOrder>`. See :ref:`ParticlesDrawOrder<enum_VisualServer_ParticlesDrawOrder>` for options. Equivalent to :ref:`Particles.draw_order<class_Particles_property_draw_order>`.
- void particles_set_draw_pass_mesh ( :ref:`RID<class_RID>` particles, :ref:`int<class_int>` pass, :ref:`RID<class_RID>` mesh )
Sets the mesh to be used for the specified draw pass. Equivalent to :ref:`Particles.draw_pass_1<class_Particles_property_draw_pass_1>`, :ref:`Particles.draw_pass_2<class_Particles_property_draw_pass_2>`, :ref:`Particles.draw_pass_3<class_Particles_property_draw_pass_3>`, and :ref:`Particles.draw_pass_4<class_Particles_property_draw_pass_4>`.
- void particles_set_draw_passes ( :ref:`RID<class_RID>` particles, :ref:`int<class_int>` count )
Sets the number of draw passes to use. Equivalent to :ref:`Particles.draw_passes<class_Particles_property_draw_passes>`.
- void particles_set_emission_transform ( :ref:`RID<class_RID>` particles, :ref:`Transform<class_Transform>` transform )
Sets the :ref:`Transform<class_Transform>` that will be used by the particles when they first emit.
- void particles_set_emitting ( :ref:`RID<class_RID>` particles, :ref:`bool<class_bool>` emitting )
If true, particles will emit over time. Setting to false does not reset the particles, but only stops their emission. Equivalent to :ref:`Particles.emitting<class_Particles_property_emitting>`.
- void particles_set_explosiveness_ratio ( :ref:`RID<class_RID>` particles, :ref:`float<class_float>` ratio )
Sets the explosiveness ratio. Equivalent to :ref:`Particles.explosiveness<class_Particles_property_explosiveness>`.
- void particles_set_fixed_fps ( :ref:`RID<class_RID>` particles, :ref:`int<class_int>` fps )
Sets the frame rate that the particle system rendering will be fixed to. Equivalent to :ref:`Particles.fixed_fps<class_Particles_property_fixed_fps>`.
- void particles_set_fractional_delta ( :ref:`RID<class_RID>` particles, :ref:`bool<class_bool>` enable )
If true, uses fractional delta which smooths the movement of the particles. Equivalent to :ref:`Particles.fract_delta<class_Particles_property_fract_delta>`.
- void particles_set_lifetime ( :ref:`RID<class_RID>` particles, :ref:`float<class_float>` lifetime )
Sets the lifetime of each particle in the system. Equivalent to :ref:`Particles.lifetime<class_Particles_property_lifetime>`.
- void particles_set_one_shot ( :ref:`RID<class_RID>` particles, :ref:`bool<class_bool>` one_shot )
If true, particles will emit once and then stop. Equivalent to :ref:`Particles.one_shot<class_Particles_property_one_shot>`.
- void particles_set_pre_process_time ( :ref:`RID<class_RID>` particles, :ref:`float<class_float>` time )
Sets the preprocess time for the particles animation. This lets you delay starting an animation until after the particles have begun emitting. Equivalent to :ref:`Particles.preprocess<class_Particles_property_preprocess>`.
- void particles_set_process_material ( :ref:`RID<class_RID>` particles, :ref:`RID<class_RID>` material )
Sets the material for processing the particles. Note: this is not the material used to draw the materials. Equivalent to :ref:`Particles.process_material<class_Particles_property_process_material>`.
- void particles_set_randomness_ratio ( :ref:`RID<class_RID>` particles, :ref:`float<class_float>` ratio )
Sets the emission randomness ratio. This randomizes the emission of particles within their phase. Equivalent to :ref:`Particles.randomness<class_Particles_property_randomness>`.
- void particles_set_speed_scale ( :ref:`RID<class_RID>` particles, :ref:`float<class_float>` scale )
Sets the speed scale of the particle system. Equivalent to :ref:`Particles.speed_scale<class_Particles_property_speed_scale>`.
- void particles_set_use_local_coordinates ( :ref:`RID<class_RID>` particles, :ref:`bool<class_bool>` enable )
If true, particles use local coordinates. If false they use global coordinates. Equivalent to :ref:`Particles.local_coords<class_Particles_property_local_coords>`.
- :ref:`RID<class_RID>` reflection_probe_create ( )
Creates a reflection probe and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all reflection_probe_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
To place in a scene, attach this reflection probe to an instance using :ref:`instance_set_base<class_VisualServer_method_instance_set_base>` using the returned RID.
- void reflection_probe_set_as_interior ( :ref:`RID<class_RID>` probe, :ref:`bool<class_bool>` enable )
If true, reflections will ignore sky contribution. Equivalent to :ref:`ReflectionProbe.interior_enable<class_ReflectionProbe_property_interior_enable>`.
- void reflection_probe_set_cull_mask ( :ref:`RID<class_RID>` probe, :ref:`int<class_int>` layers )
Sets the render cull mask for this reflection probe. Only instances with a matching cull mask will be rendered by this probe. Equivalent to :ref:`ReflectionProbe.cull_mask<class_ReflectionProbe_property_cull_mask>`.
- void reflection_probe_set_enable_box_projection ( :ref:`RID<class_RID>` probe, :ref:`bool<class_bool>` enable )
If true, uses box projection. This can make reflections look more correct in certain situations. Equivalent to :ref:`ReflectionProbe.box_projection<class_ReflectionProbe_property_box_projection>`.
- void reflection_probe_set_enable_shadows ( :ref:`RID<class_RID>` probe, :ref:`bool<class_bool>` enable )
If true, computes shadows in the reflection probe. This makes the reflection much slower to compute. Equivalent to :ref:`ReflectionProbe.enable_shadows<class_ReflectionProbe_property_enable_shadows>`.
- void reflection_probe_set_extents ( :ref:`RID<class_RID>` probe, :ref:`Vector3<class_Vector3>` extents )
Sets the size of the area that the reflection probe will capture. Equivalent to :ref:`ReflectionProbe.extents<class_ReflectionProbe_property_extents>`.
- void reflection_probe_set_intensity ( :ref:`RID<class_RID>` probe, :ref:`float<class_float>` intensity )
Sets the intensity of the reflection probe. Intensity modulates the strength of the reflection. Equivalent to :ref:`ReflectionProbe.intensity<class_ReflectionProbe_property_intensity>`.
- void reflection_probe_set_interior_ambient ( :ref:`RID<class_RID>` probe, :ref:`Color<class_Color>` color )
Sets the ambient light color for this reflection probe when set to interior mode. Equivalent to :ref:`ReflectionProbe.interior_ambient_color<class_ReflectionProbe_property_interior_ambient_color>`.
- void reflection_probe_set_interior_ambient_energy ( :ref:`RID<class_RID>` probe, :ref:`float<class_float>` energy )
Sets the energy multiplier for this reflection probes ambient light contribution when set to interior mode. Equivalent to :ref:`ReflectionProbe.interior_ambient_energy<class_ReflectionProbe_property_interior_ambient_energy>`.
- void reflection_probe_set_interior_ambient_probe_contribution ( :ref:`RID<class_RID>` probe, :ref:`float<class_float>` contrib )
Sets the contribution value for how much the reflection affects the ambient light for this reflection probe when set to interior mode. Useful so that ambient light matches the color of the room. Equivalent to :ref:`ReflectionProbe.interior_ambient_contrib<class_ReflectionProbe_property_interior_ambient_contrib>`.
- void reflection_probe_set_max_distance ( :ref:`RID<class_RID>` probe, :ref:`float<class_float>` distance )
Sets the max distance away from the probe an object can be before it is culled. Equivalent to :ref:`ReflectionProbe.max_distance<class_ReflectionProbe_property_max_distance>`.
- void reflection_probe_set_origin_offset ( :ref:`RID<class_RID>` probe, :ref:`Vector3<class_Vector3>` offset )
Sets the origin offset to be used when this reflection probe is in box project mode. Equivalent to :ref:`ReflectionProbe.origin_offset<class_ReflectionProbe_property_origin_offset>`.
- void reflection_probe_set_update_mode ( :ref:`RID<class_RID>` probe, :ref:`ReflectionProbeUpdateMode<enum_VisualServer_ReflectionProbeUpdateMode>` mode )
Sets how often the reflection probe updates. Can either be once or every frame. See :ref:`ReflectionProbeUpdateMode<enum_VisualServer_ReflectionProbeUpdateMode>` for options.
- void request_frame_drawn_callback ( :ref:`Object<class_Object>` where, :ref:`StringName<class_StringName>` method, :ref:`Variant<class_Variant>` userdata )
Schedules a callback to the corresponding named method on where after a frame has been drawn.
The callback method must use only 1 argument which will be called with userdata.
- :ref:`RID<class_RID>` scenario_create ( )
Creates a scenario and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all scenario_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
The scenario is the 3D world that all the visual instances exist in.
- void scenario_set_debug ( :ref:`RID<class_RID>` scenario, :ref:`ScenarioDebugMode<enum_VisualServer_ScenarioDebugMode>` debug_mode )
Sets the :ref:`ScenarioDebugMode<enum_VisualServer_ScenarioDebugMode>` for this scenario. See :ref:`ScenarioDebugMode<enum_VisualServer_ScenarioDebugMode>` for options.
- void scenario_set_environment ( :ref:`RID<class_RID>` scenario, :ref:`RID<class_RID>` environment )
Sets the environment that will be used with this scenario.
- void scenario_set_fallback_environment ( :ref:`RID<class_RID>` scenario, :ref:`RID<class_RID>` environment )
Sets the fallback environment to be used by this scenario. The fallback environment is used if no environment is set. Internally, this is used by the editor to provide a default environment.
- void set_boot_image ( :ref:`Image<class_Image>` image, :ref:`Color<class_Color>` color, :ref:`bool<class_bool>` scale, :ref:`bool<class_bool>` use_filter=true )
Sets a boot image. The color defines the background color. If scale is true, the image will be scaled to fit the screen size. If use_filter is true, the image will be scaled with linear interpolation. If use_filter is false, the image will be scaled with nearest-neighbor interpolation.
- void set_debug_generate_wireframes ( :ref:`bool<class_bool>` generate )
If true, the engine will generate wireframes for use with the wireframe debug mode.
- void set_default_clear_color ( :ref:`Color<class_Color>` color )
Sets the default clear color which is used when a specific clear color has not been selected.
- :ref:`RID<class_RID>` shader_create ( )
Creates an empty shader and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all shader_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
- :ref:`String<class_String>` shader_get_code ( :ref:`RID<class_RID>` shader ) const
Returns a shader's code.
- :ref:`RID<class_RID>` shader_get_default_texture_param ( :ref:`RID<class_RID>` shader, :ref:`StringName<class_StringName>` name ) const
Returns a default texture from a shader searched by name.
- :ref:`Variant<class_Variant>` shader_get_param_default ( :ref:`RID<class_RID>` material, :ref:`StringName<class_StringName>` parameter ) const
- :ref:`Array<class_Array>` shader_get_param_list ( :ref:`RID<class_RID>` shader ) const
Returns the parameters of a shader.
- void shader_set_code ( :ref:`RID<class_RID>` shader, :ref:`String<class_String>` code )
Sets a shader's code.
- void shader_set_default_texture_param ( :ref:`RID<class_RID>` shader, :ref:`StringName<class_StringName>` name, :ref:`RID<class_RID>` texture )
Sets a shader's default texture. Overwrites the texture given by name.
- void skeleton_allocate ( :ref:`RID<class_RID>` skeleton, :ref:`int<class_int>` bones, :ref:`bool<class_bool>` is_2d_skeleton=false )
Allocates the GPU buffers for this skeleton.
- :ref:`Transform<class_Transform>` skeleton_bone_get_transform ( :ref:`RID<class_RID>` skeleton, :ref:`int<class_int>` bone ) const
Returns the :ref:`Transform<class_Transform>` set for a specific bone of this skeleton.
- :ref:`Transform2D<class_Transform2D>` skeleton_bone_get_transform_2d ( :ref:`RID<class_RID>` skeleton, :ref:`int<class_int>` bone ) const
Returns the :ref:`Transform2D<class_Transform2D>` set for a specific bone of this skeleton.
- void skeleton_bone_set_transform ( :ref:`RID<class_RID>` skeleton, :ref:`int<class_int>` bone, :ref:`Transform<class_Transform>` transform )
Sets the :ref:`Transform<class_Transform>` for a specific bone of this skeleton.
- void skeleton_bone_set_transform_2d ( :ref:`RID<class_RID>` skeleton, :ref:`int<class_int>` bone, :ref:`Transform2D<class_Transform2D>` transform )
Sets the :ref:`Transform2D<class_Transform2D>` for a specific bone of this skeleton.
- :ref:`RID<class_RID>` skeleton_create ( )
Creates a skeleton and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all skeleton_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
- :ref:`int<class_int>` skeleton_get_bone_count ( :ref:`RID<class_RID>` skeleton ) const
Returns the number of bones allocated for this skeleton.
- :ref:`RID<class_RID>` sky_create ( )
Creates an empty sky and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all sky_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
- void sky_set_material ( :ref:`RID<class_RID>` sky, :ref:`RID<class_RID>` material )
Sets the material that the sky uses to render the background and reflection maps.
- :ref:`RID<class_RID>` spot_light_create ( )
Creates a spot light and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID can be used in most light_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
To place in a scene, attach this spot light to an instance using :ref:`instance_set_base<class_VisualServer_method_instance_set_base>` using the returned RID.
- :ref:`RID<class_RID>` texture_2d_create ( :ref:`Image<class_Image>` image )
- :ref:`Image<class_Image>` texture_2d_get ( :ref:`RID<class_RID>` texture ) const
- void viewport_attach_camera ( :ref:`RID<class_RID>` viewport, :ref:`RID<class_RID>` camera )
Sets a viewport's camera.
- void viewport_attach_canvas ( :ref:`RID<class_RID>` viewport, :ref:`RID<class_RID>` canvas )
Sets a viewport's canvas.
- void viewport_attach_to_screen ( :ref:`RID<class_RID>` viewport, :ref:`Rect2<class_Rect2>` rect=Rect2( 0, 0, 0, 0 ), :ref:`int<class_int>` screen=0 )
Copies viewport to a region of the screen specified by rect. If :ref:`Viewport.render_direct_to_screen<class_Viewport_property_render_direct_to_screen>` is true, then viewport does not use a framebuffer and the contents of the viewport are rendered directly to screen. However, note that the root viewport is drawn last, therefore it will draw over the screen. Accordingly, you must set the root viewport to an area that does not cover the area that you have attached this viewport to.
For example, you can set the root viewport to not render at all with the following code:
func _ready():
get_viewport().set_attach_to_screen_rect(Rect2())
$Viewport.set_attach_to_screen_rect(Rect2(0, 0, 600, 600))
Using this can result in significant optimization, especially on lower-end devices. However, it comes at the cost of having to manage your viewports manually. For a further optimization see, :ref:`viewport_set_render_direct_to_screen<class_VisualServer_method_viewport_set_render_direct_to_screen>`.
- :ref:`RID<class_RID>` viewport_create ( )
Creates an empty viewport and adds it to the VisualServer. It can be accessed with the RID that is returned. This RID will be used in all viewport_* VisualServer functions.
Once finished with your RID, you will want to free the RID using the VisualServer's :ref:`free_rid<class_VisualServer_method_free_rid>` static method.
- void viewport_detach ( :ref:`RID<class_RID>` viewport )
Detaches the viewport from the screen.
- :ref:`int<class_int>` viewport_get_render_info ( :ref:`RID<class_RID>` viewport, :ref:`ViewportRenderInfo<enum_VisualServer_ViewportRenderInfo>` info )
Returns a viewport's render information. For options, see the :ref:`ViewportRenderInfo<enum_VisualServer_ViewportRenderInfo>` constants.
- :ref:`RID<class_RID>` viewport_get_texture ( :ref:`RID<class_RID>` viewport ) const
Returns the viewport's last rendered frame.
- void viewport_remove_canvas ( :ref:`RID<class_RID>` viewport, :ref:`RID<class_RID>` canvas )
Detaches a viewport from a canvas and vice versa.
- void viewport_set_active ( :ref:`RID<class_RID>` viewport, :ref:`bool<class_bool>` active )
If true, sets the viewport active, else sets it inactive.
- void viewport_set_canvas_stacking ( :ref:`RID<class_RID>` viewport, :ref:`RID<class_RID>` canvas, :ref:`int<class_int>` layer, :ref:`int<class_int>` sublayer )
Sets the stacking order for a viewport's canvas.
layer is the actual canvas layer, while sublayer specifies the stacking order of the canvas among those in the same layer.
- void viewport_set_canvas_transform ( :ref:`RID<class_RID>` viewport, :ref:`RID<class_RID>` canvas, :ref:`Transform2D<class_Transform2D>` offset )
Sets the transformation of a viewport's canvas.
- void viewport_set_clear_mode ( :ref:`RID<class_RID>` viewport, :ref:`ViewportClearMode<enum_VisualServer_ViewportClearMode>` clear_mode )
Sets the clear mode of a viewport. See :ref:`ViewportClearMode<enum_VisualServer_ViewportClearMode>` for options.
- void viewport_set_debug_draw ( :ref:`RID<class_RID>` viewport, :ref:`ViewportDebugDraw<enum_VisualServer_ViewportDebugDraw>` draw )
Sets the debug draw mode of a viewport. See :ref:`ViewportDebugDraw<enum_VisualServer_ViewportDebugDraw>` for options.
- void viewport_set_disable_environment ( :ref:`RID<class_RID>` viewport, :ref:`bool<class_bool>` disabled )
If true, rendering of a viewport's environment is disabled.
- void viewport_set_global_canvas_transform ( :ref:`RID<class_RID>` viewport, :ref:`Transform2D<class_Transform2D>` transform )
Sets the viewport's global transformation matrix.
- void viewport_set_hide_canvas ( :ref:`RID<class_RID>` viewport, :ref:`bool<class_bool>` hidden )
If true, the viewport's canvas is not rendered.
- void viewport_set_hide_scenario ( :ref:`RID<class_RID>` viewport, :ref:`bool<class_bool>` hidden )
Currently unimplemented in Godot 3.x.
- void viewport_set_msaa ( :ref:`RID<class_RID>` viewport, :ref:`ViewportMSAA<enum_VisualServer_ViewportMSAA>` msaa )
Sets the anti-aliasing mode. See :ref:`ViewportMSAA<enum_VisualServer_ViewportMSAA>` for options.
- void viewport_set_parent_viewport ( :ref:`RID<class_RID>` viewport, :ref:`RID<class_RID>` parent_viewport )
Sets the viewport's parent to another viewport.
- void viewport_set_render_direct_to_screen ( :ref:`RID<class_RID>` viewport, :ref:`bool<class_bool>` enabled )
If true, render the contents of the viewport directly to screen. This allows a low-level optimization where you can skip drawing a viewport to the root viewport. While this optimization can result in a significant increase in speed (especially on older devices), it comes at a cost of usability. When this is enabled, you cannot read from the viewport or from the SCREEN_TEXTURE. You also lose the benefit of certain window settings, such as the various stretch modes. Another consequence to be aware of is that in 2D the rendering happens in window coordinates, so if you have a viewport that is double the size of the window, and you set this, then only the portion that fits within the window will be drawn, no automatic scaling is possible, even if your game scene is significantly larger than the window size.
- void viewport_set_scenario ( :ref:`RID<class_RID>` viewport, :ref:`RID<class_RID>` scenario )
Sets a viewport's scenario.
The scenario contains information about the :ref:`ScenarioDebugMode<enum_VisualServer_ScenarioDebugMode>`, environment information, reflection atlas etc.
- void viewport_set_shadow_atlas_quadrant_subdivision ( :ref:`RID<class_RID>` viewport, :ref:`int<class_int>` quadrant, :ref:`int<class_int>` subdivision )
Sets the shadow atlas quadrant's subdivision.
- void viewport_set_shadow_atlas_size ( :ref:`RID<class_RID>` viewport, :ref:`int<class_int>` size )
Sets the size of the shadow atlas's images (used for omni and spot lights). The value will be rounded up to the nearest power of 2.
- void viewport_set_size ( :ref:`RID<class_RID>` viewport, :ref:`int<class_int>` width, :ref:`int<class_int>` height )
Sets the viewport's width and height.
- void viewport_set_transparent_background ( :ref:`RID<class_RID>` viewport, :ref:`bool<class_bool>` enabled )
If true, the viewport renders its background as transparent.
- void viewport_set_update_mode ( :ref:`RID<class_RID>` viewport, :ref:`ViewportUpdateMode<enum_VisualServer_ViewportUpdateMode>` update_mode )
Sets when the viewport should be updated. See :ref:`ViewportUpdateMode<enum_VisualServer_ViewportUpdateMode>` constants for options.
- void viewport_set_use_arvr ( :ref:`RID<class_RID>` viewport, :ref:`bool<class_bool>` use_arvr )
If true, the viewport uses augmented or virtual reality technologies. See :ref:`ARVRInterface<class_ARVRInterface>`.