RenderingServer

Успадковує: Object

Сервер для будь-якого видимого.

Опис

Сервер рендерингу – це API-бекенд для всього видимого. Уся система сцен монтується на ньому для відображення. Сервер рендерингу повністю непрозорий: внутрішні механізми повністю залежать від реалізації та недоступні.

Сервер рендерингу можна використовувати для повного обходу системи сцени/Node. Це може покращити продуктивність у випадках, коли система сцени є вузьким місцем, але не покращить продуктивність в іншому випадку (наприклад, якщо графічний процесор вже повністю завантажений).

Ресурси створюються за допомогою функцій *_create. Ці функції повертають RID, які не є посиланнями на самі об'єкти, а непрозорими вказівниками на ці об'єкти.

Усі об'єкти малюються у вікні перегляду. Ви можете використовувати Viewport, приєднаний до SceneTree, або створити його самостійно за допомогою viewport_create(). Під час використання власного скрипта або полотна, скрипт або полотно потрібно приєднати до вікна перегляду за допомогою viewport_set_scenario() або viewport_attach_canvas().

Сценарії: У 3D усі візуальні об'єкти мають бути пов'язані зі скриптою. Скрипт – це візуальне представлення світу. Якщо доступ до сервера рендерингу здійснюється з запущеної гри, доступ до скрипта можна отримати з дерева сцен з будь-якого вузла Node3D за допомогою методу Node3D.get_world_3d. В іншому випадку скрипт можна створити за допомогою методу scenario_create().

Аналогічно, у 2D для малювання всіх елементів полотна потрібне полотно.

3D: У 3D усі видимі об'єкти складаються з ресурсу та екземпляра. Ресурсом може бути сітка, система частинок, світло або будь-який інший 3D-об'єкт. Щоб бути видимими, ресурси мають бути приєднані до екземпляра за допомогою методу instance_set_base(). Екземпляр також має бути приєднаний до сценарію за допомогою методу instance_set_scenario(), щоб бути видимим. Методи RenderingServer, які не мають префікса, зазвичай є специфічними для 3D (але не завжди).

2D: У 2D усі видимі об'єкти є певною формою елемента полотна. Щоб бути видимим, елемент полотна має бути дочірнім елементом полотна, прикріпленого до області перегляду, або він має бути дочірнім елементом іншого елемента полотна, який зрештою прикріплюється до полотна. Специфічні для 2D методи RenderingServer зазвичай починаються з canvas_*.

Безголовий режим: Запуск рушія з аргументом командного рядка --headless [url=$DOCS_URL/tutorials/editor/command_line_tutorial.html]вимикає всі функції рендерингу та керування вікнами. У цьому випадку більшість функцій з [RenderingServer] повертатимуть фіктивні значення.

Посібники

Оптимізація за допомогою серверів

Властивості

bool	render_loop_enabled

Методи

Array[Image]	bake_render_uv2(base: RID, material_overrides: Array[RID], image_size: Vector2i)
void	call_on_render_thread(callable: Callable)
RID	camera_attributes_create()
void	camera_attributes_set_auto_exposure(camera_attributes: RID, enable: bool, min_sensitivity: float, max_sensitivity: float, speed: float, scale: float)
void	camera_attributes_set_dof_blur(camera_attributes: RID, far_enable: bool, far_distance: float, far_transition: float, near_enable: bool, near_distance: float, near_transition: float, amount: float)
void	camera_attributes_set_dof_blur_bokeh_shape(shape: DOFBokehShape)
void	camera_attributes_set_dof_blur_quality(quality: DOFBlurQuality, use_jitter: bool)
void	camera_attributes_set_exposure(camera_attributes: RID, multiplier: float, normalization: float)
RID	camera_create()
void	camera_set_camera_attributes(camera: RID, effects: RID)
void	camera_set_compositor(camera: RID, compositor: RID)
void	camera_set_cull_mask(camera: RID, layers: int)
void	camera_set_environment(camera: RID, env: RID)
void	camera_set_frustum(camera: RID, size: float, offset: Vector2, z_near: float, z_far: float)
void	camera_set_orthogonal(camera: RID, size: float, z_near: float, z_far: float)
void	camera_set_perspective(camera: RID, fovy_degrees: float, z_near: float, z_far: float)
void	camera_set_transform(camera: RID, transform: Transform3D)
void	camera_set_use_vertical_aspect(camera: RID, enable: bool)
RID	canvas_create()
void	canvas_item_add_animation_slice(item: RID, animation_length: float, slice_begin: float, slice_end: float, offset: float = 0.0)
void	canvas_item_add_circle(item: RID, pos: Vector2, radius: float, color: Color, antialiased: bool = false)
void	canvas_item_add_clip_ignore(item: RID, ignore: bool)
void	canvas_item_add_lcd_texture_rect_region(item: RID, rect: Rect2, texture: RID, src_rect: Rect2, modulate: Color)
void	canvas_item_add_line(item: RID, from: Vector2, to: Vector2, color: Color, width: float = -1.0, antialiased: bool = false)
void	canvas_item_add_mesh(item: RID, mesh: RID, transform: Transform2D = Transform2D(1, 0, 0, 1, 0, 0), modulate: Color = Color(1, 1, 1, 1), texture: RID = RID())
void	canvas_item_add_msdf_texture_rect_region(item: RID, rect: Rect2, texture: RID, src_rect: Rect2, modulate: Color = Color(1, 1, 1, 1), outline_size: int = 0, px_range: float = 1.0, scale: float = 1.0)
void	canvas_item_add_multiline(item: RID, points: PackedVector2Array, colors: PackedColorArray, width: float = -1.0, antialiased: bool = false)
void	canvas_item_add_multimesh(item: RID, mesh: RID, texture: RID = RID())
void	canvas_item_add_nine_patch(item: RID, rect: Rect2, source: Rect2, texture: RID, topleft: Vector2, bottomright: Vector2, x_axis_mode: NinePatchAxisMode = 0, y_axis_mode: NinePatchAxisMode = 0, draw_center: bool = true, modulate: Color = Color(1, 1, 1, 1))
void	canvas_item_add_particles(item: RID, particles: RID, texture: RID)
void	canvas_item_add_polygon(item: RID, points: PackedVector2Array, colors: PackedColorArray, uvs: PackedVector2Array = PackedVector2Array(), texture: RID = RID())
void	canvas_item_add_polyline(item: RID, points: PackedVector2Array, colors: PackedColorArray, width: float = -1.0, antialiased: bool = false)
void	canvas_item_add_primitive(item: RID, points: PackedVector2Array, colors: PackedColorArray, uvs: PackedVector2Array, texture: RID)
void	canvas_item_add_rect(item: RID, rect: Rect2, color: Color, antialiased: bool = false)
void	canvas_item_add_set_transform(item: RID, transform: Transform2D)
void	canvas_item_add_texture_rect(item: RID, rect: Rect2, texture: RID, tile: bool = false, modulate: Color = Color(1, 1, 1, 1), transpose: bool = false)
void	canvas_item_add_texture_rect_region(item: RID, rect: Rect2, texture: RID, src_rect: Rect2, modulate: Color = Color(1, 1, 1, 1), transpose: bool = false, clip_uv: bool = true)
void	canvas_item_add_triangle_array(item: RID, indices: PackedInt32Array, points: PackedVector2Array, colors: PackedColorArray, uvs: PackedVector2Array = PackedVector2Array(), bones: PackedInt32Array = PackedInt32Array(), weights: PackedFloat32Array = PackedFloat32Array(), texture: RID = RID(), count: int = -1)
void	canvas_item_attach_skeleton(item: RID, skeleton: RID)
void	canvas_item_clear(item: RID)
RID	canvas_item_create()
Variant	canvas_item_get_instance_shader_parameter(instance: RID, parameter: StringName) const
Variant	canvas_item_get_instance_shader_parameter_default_value(instance: RID, parameter: StringName) const
Array[Dictionary]	canvas_item_get_instance_shader_parameter_list(instance: RID) const
void	canvas_item_reset_physics_interpolation(item: RID)
void	canvas_item_set_canvas_group_mode(item: RID, mode: CanvasGroupMode, clear_margin: float = 5.0, fit_empty: bool = false, fit_margin: float = 0.0, blur_mipmaps: bool = false)
void	canvas_item_set_clip(item: RID, clip: bool)
void	canvas_item_set_copy_to_backbuffer(item: RID, enabled: bool, rect: Rect2)
void	canvas_item_set_custom_rect(item: RID, use_custom_rect: bool, rect: Rect2 = Rect2(0, 0, 0, 0))
void	canvas_item_set_default_texture_filter(item: RID, filter: CanvasItemTextureFilter)
void	canvas_item_set_default_texture_repeat(item: RID, repeat: CanvasItemTextureRepeat)
void	canvas_item_set_distance_field_mode(item: RID, enabled: bool)
void	canvas_item_set_draw_behind_parent(item: RID, enabled: bool)
void	canvas_item_set_draw_index(item: RID, index: int)
void	canvas_item_set_instance_shader_parameter(instance: RID, parameter: StringName, value: Variant)
void	canvas_item_set_interpolated(item: RID, interpolated: bool)
void	canvas_item_set_light_mask(item: RID, mask: int)
void	canvas_item_set_material(item: RID, material: RID)
void	canvas_item_set_modulate(item: RID, color: Color)
void	canvas_item_set_parent(item: RID, parent: RID)
void	canvas_item_set_self_modulate(item: RID, color: Color)
void	canvas_item_set_sort_children_by_y(item: RID, enabled: bool)
void	canvas_item_set_transform(item: RID, transform: Transform2D)
void	canvas_item_set_use_parent_material(item: RID, enabled: bool)
void	canvas_item_set_visibility_layer(item: RID, visibility_layer: int)
void	canvas_item_set_visibility_notifier(item: RID, enable: bool, area: Rect2, enter_callable: Callable, exit_callable: Callable)
void	canvas_item_set_visible(item: RID, visible: bool)
void	canvas_item_set_z_as_relative_to_parent(item: RID, enabled: bool)
void	canvas_item_set_z_index(item: RID, z_index: int)
void	canvas_item_transform_physics_interpolation(item: RID, transform: Transform2D)
void	canvas_light_attach_to_canvas(light: RID, canvas: RID)
RID	canvas_light_create()
void	canvas_light_occluder_attach_to_canvas(occluder: RID, canvas: RID)
RID	canvas_light_occluder_create()
void	canvas_light_occluder_reset_physics_interpolation(occluder: RID)
void	canvas_light_occluder_set_as_sdf_collision(occluder: RID, enable: bool)
void	canvas_light_occluder_set_enabled(occluder: RID, enabled: bool)
void	canvas_light_occluder_set_interpolated(occluder: RID, interpolated: bool)
void	canvas_light_occluder_set_light_mask(occluder: RID, mask: int)
void	canvas_light_occluder_set_polygon(occluder: RID, polygon: RID)
void	canvas_light_occluder_set_transform(occluder: RID, transform: Transform2D)
void	canvas_light_occluder_transform_physics_interpolation(occluder: RID, transform: Transform2D)
void	canvas_light_reset_physics_interpolation(light: RID)
void	canvas_light_set_blend_mode(light: RID, mode: CanvasLightBlendMode)
void	canvas_light_set_color(light: RID, color: Color)
void	canvas_light_set_enabled(light: RID, enabled: bool)
void	canvas_light_set_energy(light: RID, energy: float)
void	canvas_light_set_height(light: RID, height: float)
void	canvas_light_set_interpolated(light: RID, interpolated: bool)
void	canvas_light_set_item_cull_mask(light: RID, mask: int)
void	canvas_light_set_item_shadow_cull_mask(light: RID, mask: int)
void	canvas_light_set_layer_range(light: RID, min_layer: int, max_layer: int)
void	canvas_light_set_mode(light: RID, mode: CanvasLightMode)
void	canvas_light_set_shadow_color(light: RID, color: Color)
void	canvas_light_set_shadow_enabled(light: RID, enabled: bool)
void	canvas_light_set_shadow_filter(light: RID, filter: CanvasLightShadowFilter)
void	canvas_light_set_shadow_smooth(light: RID, smooth: float)
void	canvas_light_set_texture(light: RID, texture: RID)
void	canvas_light_set_texture_offset(light: RID, offset: Vector2)
void	canvas_light_set_texture_scale(light: RID, scale: float)
void	canvas_light_set_transform(light: RID, transform: Transform2D)
void	canvas_light_set_z_range(light: RID, min_z: int, max_z: int)
void	canvas_light_transform_physics_interpolation(light: RID, transform: Transform2D)
RID	canvas_occluder_polygon_create()
void	canvas_occluder_polygon_set_cull_mode(occluder_polygon: RID, mode: CanvasOccluderPolygonCullMode)
void	canvas_occluder_polygon_set_shape(occluder_polygon: RID, shape: PackedVector2Array, closed: bool)
void	canvas_set_disable_scale(disable: bool)
void	canvas_set_item_mirroring(canvas: RID, item: RID, mirroring: Vector2)
void	canvas_set_item_repeat(item: RID, repeat_size: Vector2, repeat_times: int)
void	canvas_set_modulate(canvas: RID, color: Color)
void	canvas_set_shadow_texture_size(size: int)
RID	canvas_texture_create()
void	canvas_texture_set_channel(canvas_texture: RID, channel: CanvasTextureChannel, texture: RID)
void	canvas_texture_set_shading_parameters(canvas_texture: RID, base_color: Color, shininess: float)
void	canvas_texture_set_texture_filter(canvas_texture: RID, filter: CanvasItemTextureFilter)
void	canvas_texture_set_texture_repeat(canvas_texture: RID, repeat: CanvasItemTextureRepeat)
RID	compositor_create()
RID	compositor_effect_create()
void	compositor_effect_set_callback(effect: RID, callback_type: CompositorEffectCallbackType, callback: Callable)
void	compositor_effect_set_enabled(effect: RID, enabled: bool)
void	compositor_effect_set_flag(effect: RID, flag: CompositorEffectFlags, set: bool)
void	compositor_set_compositor_effects(compositor: RID, effects: Array[RID])
RenderingDevice	create_local_rendering_device() const
Rect2	debug_canvas_item_get_rect(item: RID)
RID	decal_create()
void	decal_set_albedo_mix(decal: RID, albedo_mix: float)
void	decal_set_cull_mask(decal: RID, mask: int)
void	decal_set_distance_fade(decal: RID, enabled: bool, begin: float, length: float)
void	decal_set_emission_energy(decal: RID, energy: float)
void	decal_set_fade(decal: RID, above: float, below: float)
void	decal_set_modulate(decal: RID, color: Color)
void	decal_set_normal_fade(decal: RID, fade: float)
void	decal_set_size(decal: RID, size: Vector3)
void	decal_set_texture(decal: RID, type: DecalTexture, texture: RID)
void	decals_set_filter(filter: DecalFilter)
RID	directional_light_create()
void	directional_shadow_atlas_set_size(size: int, is_16bits: bool)
void	directional_soft_shadow_filter_set_quality(quality: ShadowQuality)
Image	environment_bake_panorama(environment: RID, bake_irradiance: bool, size: Vector2i)
RID	environment_create()
void	environment_glow_set_use_bicubic_upscale(enable: bool)
void	environment_set_adjustment(env: RID, enable: bool, brightness: float, contrast: float, saturation: float, use_1d_color_correction: bool, color_correction: RID)
void	environment_set_ambient_light(env: RID, color: Color, ambient: EnvironmentAmbientSource = 0, energy: float = 1.0, sky_contribution: float = 0.0, reflection_source: EnvironmentReflectionSource = 0)
void	environment_set_background(env: RID, bg: EnvironmentBG)
void	environment_set_bg_color(env: RID, color: Color)
void	environment_set_bg_energy(env: RID, multiplier: float, exposure_value: float)
void	environment_set_camera_id(env: RID, id: int)
void	environment_set_canvas_max_layer(env: RID, max_layer: int)
void	environment_set_fog(env: RID, enable: bool, light_color: Color, light_energy: float, sun_scatter: float, density: float, height: float, height_density: float, aerial_perspective: float, sky_affect: float, fog_mode: EnvironmentFogMode = 0)
void	environment_set_fog_depth(env: RID, curve: float, begin: float, end: float)
void	environment_set_glow(env: RID, enable: bool, levels: PackedFloat32Array, intensity: float, strength: float, mix: float, bloom_threshold: float, blend_mode: EnvironmentGlowBlendMode, hdr_bleed_threshold: float, hdr_bleed_scale: float, hdr_luminance_cap: float, glow_map_strength: float, glow_map: RID)
void	environment_set_sdfgi(env: RID, enable: bool, cascades: int, min_cell_size: float, y_scale: EnvironmentSDFGIYScale, use_occlusion: bool, bounce_feedback: float, read_sky: bool, energy: float, normal_bias: float, probe_bias: float)
void	environment_set_sdfgi_frames_to_converge(frames: EnvironmentSDFGIFramesToConverge)
void	environment_set_sdfgi_frames_to_update_light(frames: EnvironmentSDFGIFramesToUpdateLight)
void	environment_set_sdfgi_ray_count(ray_count: EnvironmentSDFGIRayCount)
void	environment_set_sky(env: RID, sky: RID)
void	environment_set_sky_custom_fov(env: RID, scale: float)
void	environment_set_sky_orientation(env: RID, orientation: Basis)
void	environment_set_ssao(env: RID, enable: bool, radius: float, intensity: float, power: float, detail: float, horizon: float, sharpness: float, light_affect: float, ao_channel_affect: float)
void	environment_set_ssao_quality(quality: EnvironmentSSAOQuality, half_size: bool, adaptive_target: float, blur_passes: int, fadeout_from: float, fadeout_to: float)
void	environment_set_ssil_quality(quality: EnvironmentSSILQuality, half_size: bool, adaptive_target: float, blur_passes: int, fadeout_from: float, fadeout_to: float)
void	environment_set_ssr(env: RID, enable: bool, max_steps: int, fade_in: float, fade_out: float, depth_tolerance: float)
void	environment_set_ssr_roughness_quality(quality: EnvironmentSSRRoughnessQuality)
void	environment_set_tonemap(env: RID, tone_mapper: EnvironmentToneMapper, exposure: float, white: float)
void	environment_set_volumetric_fog(env: RID, enable: bool, density: float, albedo: Color, emission: Color, emission_energy: float, anisotropy: float, length: float, p_detail_spread: float, gi_inject: float, temporal_reprojection: bool, temporal_reprojection_amount: float, ambient_inject: float, sky_affect: float)
void	environment_set_volumetric_fog_filter_active(active: bool)
void	environment_set_volumetric_fog_volume_size(size: int, depth: int)
RID	fog_volume_create()
void	fog_volume_set_material(fog_volume: RID, material: RID)
void	fog_volume_set_shape(fog_volume: RID, shape: FogVolumeShape)
void	fog_volume_set_size(fog_volume: RID, size: Vector3)
void	force_draw(swap_buffers: bool = true, frame_step: float = 0.0)
void	force_sync()
void	free_rid(rid: RID)
String	get_current_rendering_driver_name() const
String	get_current_rendering_method() const
Color	get_default_clear_color()
float	get_frame_setup_time_cpu() const
RenderingDevice	get_rendering_device() const
int	get_rendering_info(info: RenderingInfo)
Array[Dictionary]	get_shader_parameter_list(shader: RID) const
RID	get_test_cube()
RID	get_test_texture()
String	get_video_adapter_api_version() const
String	get_video_adapter_name() const
DeviceType	get_video_adapter_type() const
String	get_video_adapter_vendor() const
RID	get_white_texture()
void	gi_set_use_half_resolution(half_resolution: bool)
void	global_shader_parameter_add(name: StringName, type: GlobalShaderParameterType, default_value: Variant)
Variant	global_shader_parameter_get(name: StringName) const
Array[StringName]	global_shader_parameter_get_list() const
GlobalShaderParameterType	global_shader_parameter_get_type(name: StringName) const
void	global_shader_parameter_remove(name: StringName)
void	global_shader_parameter_set(name: StringName, value: Variant)
void	global_shader_parameter_set_override(name: StringName, value: Variant)
bool	has_changed() const
bool	has_feature(feature: Features) const
bool	has_os_feature(feature: String) const
void	instance_attach_object_instance_id(instance: RID, id: int)
void	instance_attach_skeleton(instance: RID, skeleton: RID)
RID	instance_create()
RID	instance_create2(base: RID, scenario: RID)
Variant	instance_geometry_get_shader_parameter(instance: RID, parameter: StringName) const
Variant	instance_geometry_get_shader_parameter_default_value(instance: RID, parameter: StringName) const
Array[Dictionary]	instance_geometry_get_shader_parameter_list(instance: RID) const
void	instance_geometry_set_cast_shadows_setting(instance: RID, shadow_casting_setting: ShadowCastingSetting)
void	instance_geometry_set_flag(instance: RID, flag: InstanceFlags, enabled: bool)
void	instance_geometry_set_lightmap(instance: RID, lightmap: RID, lightmap_uv_scale: Rect2, lightmap_slice: int)
void	instance_geometry_set_lod_bias(instance: RID, lod_bias: float)
void	instance_geometry_set_material_overlay(instance: RID, material: RID)
void	instance_geometry_set_material_override(instance: RID, material: RID)
void	instance_geometry_set_shader_parameter(instance: RID, parameter: StringName, value: Variant)
void	instance_geometry_set_transparency(instance: RID, transparency: float)
void	instance_geometry_set_visibility_range(instance: RID, min: float, max: float, min_margin: float, max_margin: float, fade_mode: VisibilityRangeFadeMode)
void	instance_set_base(instance: RID, base: RID)
void	instance_set_blend_shape_weight(instance: RID, shape: int, weight: float)
void	instance_set_custom_aabb(instance: RID, aabb: AABB)
void	instance_set_extra_visibility_margin(instance: RID, margin: float)
void	instance_set_ignore_culling(instance: RID, enabled: bool)
void	instance_set_layer_mask(instance: RID, mask: int)
void	instance_set_pivot_data(instance: RID, sorting_offset: float, use_aabb_center: bool)
void	instance_set_scenario(instance: RID, scenario: RID)
void	instance_set_surface_override_material(instance: RID, surface: int, material: RID)
void	instance_set_transform(instance: RID, transform: Transform3D)
void	instance_set_visibility_parent(instance: RID, parent: RID)
void	instance_set_visible(instance: RID, visible: bool)
void	instance_teleport(instance: RID)
PackedInt64Array	instances_cull_aabb(aabb: AABB, scenario: RID = RID()) const
PackedInt64Array	instances_cull_convex(convex: Array[Plane], scenario: RID = RID()) const
PackedInt64Array	instances_cull_ray(from: Vector3, to: Vector3, scenario: RID = RID()) const
bool	is_on_render_thread()
void	light_directional_set_blend_splits(light: RID, enable: bool)
void	light_directional_set_shadow_mode(light: RID, mode: LightDirectionalShadowMode)
void	light_directional_set_sky_mode(light: RID, mode: LightDirectionalSkyMode)
void	light_omni_set_shadow_mode(light: RID, mode: LightOmniShadowMode)
void	light_projectors_set_filter(filter: LightProjectorFilter)
void	light_set_bake_mode(light: RID, bake_mode: LightBakeMode)
void	light_set_color(light: RID, color: Color)
void	light_set_cull_mask(light: RID, mask: int)
void	light_set_distance_fade(decal: RID, enabled: bool, begin: float, shadow: float, length: float)
void	light_set_max_sdfgi_cascade(light: RID, cascade: int)
void	light_set_negative(light: RID, enable: bool)
void	light_set_param(light: RID, param: LightParam, value: float)
void	light_set_projector(light: RID, texture: RID)
void	light_set_reverse_cull_face_mode(light: RID, enabled: bool)
void	light_set_shadow(light: RID, enabled: bool)
void	light_set_shadow_caster_mask(light: RID, mask: int)
RID	lightmap_create()
PackedInt32Array	lightmap_get_probe_capture_bsp_tree(lightmap: RID) const
PackedVector3Array	lightmap_get_probe_capture_points(lightmap: RID) const
PackedColorArray	lightmap_get_probe_capture_sh(lightmap: RID) const
PackedInt32Array	lightmap_get_probe_capture_tetrahedra(lightmap: RID) const
void	lightmap_set_baked_exposure_normalization(lightmap: RID, baked_exposure: float)
void	lightmap_set_probe_bounds(lightmap: RID, bounds: AABB)
void	lightmap_set_probe_capture_data(lightmap: RID, points: PackedVector3Array, point_sh: PackedColorArray, tetrahedra: PackedInt32Array, bsp_tree: PackedInt32Array)
void	lightmap_set_probe_capture_update_speed(speed: float)
void	lightmap_set_probe_interior(lightmap: RID, interior: bool)
void	lightmap_set_textures(lightmap: RID, light: RID, uses_sh: bool)
void	lightmaps_set_bicubic_filter(enable: bool)
RID	make_sphere_mesh(latitudes: int, longitudes: int, radius: float)
RID	material_create()
Variant	material_get_param(material: RID, parameter: StringName) const
void	material_set_next_pass(material: RID, next_material: RID)
void	material_set_param(material: RID, parameter: StringName, value: Variant)
void	material_set_render_priority(material: RID, priority: int)
void	material_set_shader(shader_material: RID, shader: RID)
void	mesh_add_surface(mesh: RID, surface: Dictionary)
void	mesh_add_surface_from_arrays(mesh: RID, primitive: PrimitiveType, arrays: Array, blend_shapes: Array = [], lods: Dictionary = {}, compress_format: BitField[ArrayFormat] = 0)
void	mesh_clear(mesh: RID)
RID	mesh_create()
RID	mesh_create_from_surfaces(surfaces: Array[Dictionary], blend_shape_count: int = 0)
int	mesh_get_blend_shape_count(mesh: RID) const
BlendShapeMode	mesh_get_blend_shape_mode(mesh: RID) const
AABB	mesh_get_custom_aabb(mesh: RID) const
Dictionary	mesh_get_surface(mesh: RID, surface: int)
int	mesh_get_surface_count(mesh: RID) const
void	mesh_set_blend_shape_mode(mesh: RID, mode: BlendShapeMode)
void	mesh_set_custom_aabb(mesh: RID, aabb: AABB)
void	mesh_set_shadow_mesh(mesh: RID, shadow_mesh: RID)
Array	mesh_surface_get_arrays(mesh: RID, surface: int) const
Array[Array]	mesh_surface_get_blend_shape_arrays(mesh: RID, surface: int) const
int	mesh_surface_get_format_attribute_stride(format: BitField[ArrayFormat], vertex_count: int) const
int	mesh_surface_get_format_index_stride(format: BitField[ArrayFormat], vertex_count: int) const
int	mesh_surface_get_format_normal_tangent_stride(format: BitField[ArrayFormat], vertex_count: int) const
int	mesh_surface_get_format_offset(format: BitField[ArrayFormat], vertex_count: int, array_index: int) const
int	mesh_surface_get_format_skin_stride(format: BitField[ArrayFormat], vertex_count: int) const
int	mesh_surface_get_format_vertex_stride(format: BitField[ArrayFormat], vertex_count: int) const
RID	mesh_surface_get_material(mesh: RID, surface: int) const
void	mesh_surface_remove(mesh: RID, surface: int)
void	mesh_surface_set_material(mesh: RID, surface: int, material: RID)
void	mesh_surface_update_attribute_region(mesh: RID, surface: int, offset: int, data: PackedByteArray)
void	mesh_surface_update_index_region(mesh: RID, surface: int, offset: int, data: PackedByteArray)
void	mesh_surface_update_skin_region(mesh: RID, surface: int, offset: int, data: PackedByteArray)
void	mesh_surface_update_vertex_region(mesh: RID, surface: int, offset: int, data: PackedByteArray)
void	multimesh_allocate_data(multimesh: RID, instances: int, transform_format: MultimeshTransformFormat, color_format: bool = false, custom_data_format: bool = false, use_indirect: bool = false)
RID	multimesh_create()
AABB	multimesh_get_aabb(multimesh: RID) const
PackedFloat32Array	multimesh_get_buffer(multimesh: RID) const
RID	multimesh_get_buffer_rd_rid(multimesh: RID) const
RID	multimesh_get_command_buffer_rd_rid(multimesh: RID) const
AABB	multimesh_get_custom_aabb(multimesh: RID) const
int	multimesh_get_instance_count(multimesh: RID) const
RID	multimesh_get_mesh(multimesh: RID) const
int	multimesh_get_visible_instances(multimesh: RID) const
Color	multimesh_instance_get_color(multimesh: RID, index: int) const
Color	multimesh_instance_get_custom_data(multimesh: RID, index: int) const
Transform3D	multimesh_instance_get_transform(multimesh: RID, index: int) const
Transform2D	multimesh_instance_get_transform_2d(multimesh: RID, index: int) const
void	multimesh_instance_reset_physics_interpolation(multimesh: RID, index: int)
void	multimesh_instance_set_color(multimesh: RID, index: int, color: Color)
void	multimesh_instance_set_custom_data(multimesh: RID, index: int, custom_data: Color)
void	multimesh_instance_set_transform(multimesh: RID, index: int, transform: Transform3D)
void	multimesh_instance_set_transform_2d(multimesh: RID, index: int, transform: Transform2D)
void	multimesh_set_buffer(multimesh: RID, buffer: PackedFloat32Array)
void	multimesh_set_buffer_interpolated(multimesh: RID, buffer: PackedFloat32Array, buffer_previous: PackedFloat32Array)
void	multimesh_set_custom_aabb(multimesh: RID, aabb: AABB)
void	multimesh_set_mesh(multimesh: RID, mesh: RID)
void	multimesh_set_physics_interpolated(multimesh: RID, interpolated: bool)
void	multimesh_set_physics_interpolation_quality(multimesh: RID, quality: MultimeshPhysicsInterpolationQuality)
void	multimesh_set_visible_instances(multimesh: RID, visible: int)
RID	occluder_create()
void	occluder_set_mesh(occluder: RID, vertices: PackedVector3Array, indices: PackedInt32Array)
RID	omni_light_create()
RID	particles_collision_create()
void	particles_collision_height_field_update(particles_collision: RID)
void	particles_collision_set_attractor_attenuation(particles_collision: RID, curve: float)
void	particles_collision_set_attractor_directionality(particles_collision: RID, amount: float)
void	particles_collision_set_attractor_strength(particles_collision: RID, strength: float)
void	particles_collision_set_box_extents(particles_collision: RID, extents: Vector3)
void	particles_collision_set_collision_type(particles_collision: RID, type: ParticlesCollisionType)
void	particles_collision_set_cull_mask(particles_collision: RID, mask: int)
void	particles_collision_set_field_texture(particles_collision: RID, texture: RID)
void	particles_collision_set_height_field_mask(particles_collision: RID, mask: int)
void	particles_collision_set_height_field_resolution(particles_collision: RID, resolution: ParticlesCollisionHeightfieldResolution)
void	particles_collision_set_sphere_radius(particles_collision: RID, radius: float)
RID	particles_create()
void	particles_emit(particles: RID, transform: Transform3D, velocity: Vector3, color: Color, custom: Color, emit_flags: int)
AABB	particles_get_current_aabb(particles: RID)
bool	particles_get_emitting(particles: RID)
bool	particles_is_inactive(particles: RID)
void	particles_request_process(particles: RID)
void	particles_request_process_time(particles: RID, time: float)
void	particles_restart(particles: RID)
void	particles_set_amount(particles: RID, amount: int)
void	particles_set_amount_ratio(particles: RID, ratio: float)
void	particles_set_collision_base_size(particles: RID, size: float)
void	particles_set_custom_aabb(particles: RID, aabb: AABB)
void	particles_set_draw_order(particles: RID, order: ParticlesDrawOrder)
void	particles_set_draw_pass_mesh(particles: RID, pass: int, mesh: RID)
void	particles_set_draw_passes(particles: RID, count: int)
void	particles_set_emission_transform(particles: RID, transform: Transform3D)
void	particles_set_emitter_velocity(particles: RID, velocity: Vector3)
void	particles_set_emitting(particles: RID, emitting: bool)
void	particles_set_explosiveness_ratio(particles: RID, ratio: float)
void	particles_set_fixed_fps(particles: RID, fps: int)
void	particles_set_fractional_delta(particles: RID, enable: bool)
void	particles_set_interp_to_end(particles: RID, factor: float)
void	particles_set_interpolate(particles: RID, enable: bool)
void	particles_set_lifetime(particles: RID, lifetime: float)
void	particles_set_mode(particles: RID, mode: ParticlesMode)
void	particles_set_one_shot(particles: RID, one_shot: bool)
void	particles_set_pre_process_time(particles: RID, time: float)
void	particles_set_process_material(particles: RID, material: RID)
void	particles_set_randomness_ratio(particles: RID, ratio: float)
void	particles_set_speed_scale(particles: RID, scale: float)
void	particles_set_subemitter(particles: RID, subemitter_particles: RID)
void	particles_set_trail_bind_poses(particles: RID, bind_poses: Array[Transform3D])
void	particles_set_trails(particles: RID, enable: bool, length_sec: float)
void	particles_set_transform_align(particles: RID, align: ParticlesTransformAlign)
void	particles_set_use_local_coordinates(particles: RID, enable: bool)
void	positional_soft_shadow_filter_set_quality(quality: ShadowQuality)
RID	reflection_probe_create()
void	reflection_probe_set_ambient_color(probe: RID, color: Color)
void	reflection_probe_set_ambient_energy(probe: RID, energy: float)
void	reflection_probe_set_ambient_mode(probe: RID, mode: ReflectionProbeAmbientMode)
void	reflection_probe_set_as_interior(probe: RID, enable: bool)
void	reflection_probe_set_blend_distance(probe: RID, blend_distance: float)
void	reflection_probe_set_cull_mask(probe: RID, layers: int)
void	reflection_probe_set_enable_box_projection(probe: RID, enable: bool)
void	reflection_probe_set_enable_shadows(probe: RID, enable: bool)
void	reflection_probe_set_intensity(probe: RID, intensity: float)
void	reflection_probe_set_max_distance(probe: RID, distance: float)
void	reflection_probe_set_mesh_lod_threshold(probe: RID, pixels: float)
void	reflection_probe_set_origin_offset(probe: RID, offset: Vector3)
void	reflection_probe_set_reflection_mask(probe: RID, layers: int)
void	reflection_probe_set_resolution(probe: RID, resolution: int)
void	reflection_probe_set_size(probe: RID, size: Vector3)
void	reflection_probe_set_update_mode(probe: RID, mode: ReflectionProbeUpdateMode)
void	request_frame_drawn_callback(callable: Callable)
RID	scenario_create()
void	scenario_set_camera_attributes(scenario: RID, effects: RID)
void	scenario_set_compositor(scenario: RID, compositor: RID)
void	scenario_set_environment(scenario: RID, environment: RID)
void	scenario_set_fallback_environment(scenario: RID, environment: RID)
void	screen_space_roughness_limiter_set_active(enable: bool, amount: float, limit: float)
void	set_boot_image(image: Image, color: Color, scale: bool, use_filter: bool = true)
void	set_debug_generate_wireframes(generate: bool)
void	set_default_clear_color(color: Color)
RID	shader_create()
String	shader_get_code(shader: RID) const
RID	shader_get_default_texture_parameter(shader: RID, name: StringName, index: int = 0) const
Variant	shader_get_parameter_default(shader: RID, name: StringName) const
void	shader_set_code(shader: RID, code: String)
void	shader_set_default_texture_parameter(shader: RID, name: StringName, texture: RID, index: int = 0)
void	shader_set_path_hint(shader: RID, path: String)
void	skeleton_allocate_data(skeleton: RID, bones: int, is_2d_skeleton: bool = false)
Transform3D	skeleton_bone_get_transform(skeleton: RID, bone: int) const
Transform2D	skeleton_bone_get_transform_2d(skeleton: RID, bone: int) const
void	skeleton_bone_set_transform(skeleton: RID, bone: int, transform: Transform3D)
void	skeleton_bone_set_transform_2d(skeleton: RID, bone: int, transform: Transform2D)
RID	skeleton_create()
int	skeleton_get_bone_count(skeleton: RID) const
void	skeleton_set_base_transform_2d(skeleton: RID, base_transform: Transform2D)
Image	sky_bake_panorama(sky: RID, energy: float, bake_irradiance: bool, size: Vector2i)
RID	sky_create()
void	sky_set_material(sky: RID, material: RID)
void	sky_set_mode(sky: RID, mode: SkyMode)
void	sky_set_radiance_size(sky: RID, radiance_size: int)
RID	spot_light_create()
void	sub_surface_scattering_set_quality(quality: SubSurfaceScatteringQuality)
void	sub_surface_scattering_set_scale(scale: float, depth_scale: float)
RID	texture_2d_create(image: Image)
Image	texture_2d_get(texture: RID) const
Image	texture_2d_layer_get(texture: RID, layer: int) const
RID	texture_2d_layered_create(layers: Array[Image], layered_type: TextureLayeredType)
RID	texture_2d_layered_placeholder_create(layered_type: TextureLayeredType)
RID	texture_2d_placeholder_create()
void	texture_2d_update(texture: RID, image: Image, layer: int)
RID	texture_3d_create(format: Format, width: int, height: int, depth: int, mipmaps: bool, data: Array[Image])
Array[Image]	texture_3d_get(texture: RID) const
RID	texture_3d_placeholder_create()
void	texture_3d_update(texture: RID, data: Array[Image])
RID	texture_create_from_native_handle(type: TextureType, format: Format, native_handle: int, width: int, height: int, depth: int, layers: int = 1, layered_type: TextureLayeredType = 0)
Format	texture_get_format(texture: RID) const
int	texture_get_native_handle(texture: RID, srgb: bool = false) const
String	texture_get_path(texture: RID) const
RID	texture_get_rd_texture(texture: RID, srgb: bool = false) const
RID	texture_proxy_create(base: RID)
void	texture_proxy_update(texture: RID, proxy_to: RID)
RID	texture_rd_create(rd_texture: RID, layer_type: TextureLayeredType = 0)
void	texture_replace(texture: RID, by_texture: RID)
void	texture_set_force_redraw_if_visible(texture: RID, enable: bool)
void	texture_set_path(texture: RID, path: String)
void	texture_set_size_override(texture: RID, width: int, height: int)
void	viewport_attach_camera(viewport: RID, camera: RID)
void	viewport_attach_canvas(viewport: RID, canvas: RID)
void	viewport_attach_to_screen(viewport: RID, rect: Rect2 = Rect2(0, 0, 0, 0), screen: int = 0)
RID	viewport_create()
float	viewport_get_measured_render_time_cpu(viewport: RID) const
float	viewport_get_measured_render_time_gpu(viewport: RID) const
int	viewport_get_render_info(viewport: RID, type: ViewportRenderInfoType, info: ViewportRenderInfo)
RID	viewport_get_render_target(viewport: RID) const
RID	viewport_get_texture(viewport: RID) const
ViewportUpdateMode	viewport_get_update_mode(viewport: RID) const
void	viewport_remove_canvas(viewport: RID, canvas: RID)
void	viewport_set_active(viewport: RID, active: bool)
void	viewport_set_anisotropic_filtering_level(viewport: RID, anisotropic_filtering_level: ViewportAnisotropicFiltering)
void	viewport_set_canvas_cull_mask(viewport: RID, canvas_cull_mask: int)
void	viewport_set_canvas_stacking(viewport: RID, canvas: RID, layer: int, sublayer: int)
void	viewport_set_canvas_transform(viewport: RID, canvas: RID, offset: Transform2D)
void	viewport_set_clear_mode(viewport: RID, clear_mode: ViewportClearMode)
void	viewport_set_debug_draw(viewport: RID, draw: ViewportDebugDraw)
void	viewport_set_default_canvas_item_texture_filter(viewport: RID, filter: CanvasItemTextureFilter)
void	viewport_set_default_canvas_item_texture_repeat(viewport: RID, repeat: CanvasItemTextureRepeat)
void	viewport_set_disable_2d(viewport: RID, disable: bool)
void	viewport_set_disable_3d(viewport: RID, disable: bool)
void	viewport_set_environment_mode(viewport: RID, mode: ViewportEnvironmentMode)
void	viewport_set_fsr_sharpness(viewport: RID, sharpness: float)
void	viewport_set_global_canvas_transform(viewport: RID, transform: Transform2D)
void	viewport_set_measure_render_time(viewport: RID, enable: bool)
void	viewport_set_msaa_2d(viewport: RID, msaa: ViewportMSAA)
void	viewport_set_msaa_3d(viewport: RID, msaa: ViewportMSAA)
void	viewport_set_occlusion_culling_build_quality(quality: ViewportOcclusionCullingBuildQuality)
void	viewport_set_occlusion_rays_per_thread(rays_per_thread: int)
void	viewport_set_parent_viewport(viewport: RID, parent_viewport: RID)
void	viewport_set_positional_shadow_atlas_quadrant_subdivision(viewport: RID, quadrant: int, subdivision: int)
void	viewport_set_positional_shadow_atlas_size(viewport: RID, size: int, use_16_bits: bool = false)
void	viewport_set_render_direct_to_screen(viewport: RID, enabled: bool)
void	viewport_set_scaling_3d_mode(viewport: RID, scaling_3d_mode: ViewportScaling3DMode)
void	viewport_set_scaling_3d_scale(viewport: RID, scale: float)
void	viewport_set_scenario(viewport: RID, scenario: RID)
void	viewport_set_screen_space_aa(viewport: RID, mode: ViewportScreenSpaceAA)
void	viewport_set_sdf_oversize_and_scale(viewport: RID, oversize: ViewportSDFOversize, scale: ViewportSDFScale)
void	viewport_set_size(viewport: RID, width: int, height: int)
void	viewport_set_snap_2d_transforms_to_pixel(viewport: RID, enabled: bool)
void	viewport_set_snap_2d_vertices_to_pixel(viewport: RID, enabled: bool)
void	viewport_set_texture_mipmap_bias(viewport: RID, mipmap_bias: float)
void	viewport_set_transparent_background(viewport: RID, enabled: bool)
void	viewport_set_update_mode(viewport: RID, update_mode: ViewportUpdateMode)
void	viewport_set_use_debanding(viewport: RID, enable: bool)
void	viewport_set_use_hdr_2d(viewport: RID, enabled: bool)
void	viewport_set_use_occlusion_culling(viewport: RID, enable: bool)
void	viewport_set_use_taa(viewport: RID, enable: bool)
void	viewport_set_use_xr(viewport: RID, use_xr: bool)
void	viewport_set_vrs_mode(viewport: RID, mode: ViewportVRSMode)
void	viewport_set_vrs_texture(viewport: RID, texture: RID)
void	viewport_set_vrs_update_mode(viewport: RID, mode: ViewportVRSUpdateMode)
RID	visibility_notifier_create()
void	visibility_notifier_set_aabb(notifier: RID, aabb: AABB)
void	visibility_notifier_set_callbacks(notifier: RID, enter_callable: Callable, exit_callable: Callable)
void	voxel_gi_allocate_data(voxel_gi: RID, to_cell_xform: Transform3D, aabb: AABB, octree_size: Vector3i, octree_cells: PackedByteArray, data_cells: PackedByteArray, distance_field: PackedByteArray, level_counts: PackedInt32Array)
RID	voxel_gi_create()
PackedByteArray	voxel_gi_get_data_cells(voxel_gi: RID) const
PackedByteArray	voxel_gi_get_distance_field(voxel_gi: RID) const
PackedInt32Array	voxel_gi_get_level_counts(voxel_gi: RID) const
PackedByteArray	voxel_gi_get_octree_cells(voxel_gi: RID) const
Vector3i	voxel_gi_get_octree_size(voxel_gi: RID) const
Transform3D	voxel_gi_get_to_cell_xform(voxel_gi: RID) const
void	voxel_gi_set_baked_exposure_normalization(voxel_gi: RID, baked_exposure: float)
void	voxel_gi_set_bias(voxel_gi: RID, bias: float)
void	voxel_gi_set_dynamic_range(voxel_gi: RID, range: float)
void	voxel_gi_set_energy(voxel_gi: RID, energy: float)
void	voxel_gi_set_interior(voxel_gi: RID, enable: bool)
void	voxel_gi_set_normal_bias(voxel_gi: RID, bias: float)
void	voxel_gi_set_propagation(voxel_gi: RID, amount: float)
void	voxel_gi_set_quality(quality: VoxelGIQuality)
void	voxel_gi_set_use_two_bounces(voxel_gi: RID, enable: bool)

Сигнали

frame_post_draw() 🔗

Після того, як RenderingServer закінчили оновлення всіх портів.

frame_pre_draw() 🔗

На початку кадру, до того, як RenderingServer оновлюється всі порти.

Переліки

enum TextureType: 🔗

TextureType TEXTURE_TYPE_2D = 0

2D текстури.

TextureType TEXTURE_TYPE_LAYERED = 1

Багатошарова текстура.

TextureType TEXTURE_TYPE_3D = 2

3D текстури.

enum TextureLayeredType: 🔗

TextureLayeredType TEXTURE_LAYERED_2D_ARRAY = 0

Арра 2-вимірних фактур (див. Texture2DArray).

TextureLayeredType TEXTURE_LAYERED_CUBEMAP = 1

Текстура кубічної карти (див. Cubemap).

TextureLayeredType TEXTURE_LAYERED_CUBEMAP_ARRAY = 2

Арра кубічних текстур (див. CubemapArray).

enum CubeMapLayer: 🔗

CubeMapLayer CUBEMAP_LAYER_LEFT = 0

Ліва грань Cubemap.

CubeMapLayer CUBEMAP_LAYER_RIGHT = 1

Права грань Cubemap.

CubeMapLayer CUBEMAP_LAYER_BOTTOM = 2

Нижня грань Cubemap.

CubeMapLayer CUBEMAP_LAYER_TOP = 3

Верхня грань Cubemap.

CubeMapLayer CUBEMAP_LAYER_FRONT = 4

Передня сторона Cubemap.

CubeMapLayer CUBEMAP_LAYER_BACK = 5

Зворотна сторона Cubemap.

enum ShaderMode: 🔗

ShaderMode SHADER_SPATIAL = 0

Шейдер - 3D шейдер.

ShaderMode SHADER_CANVAS_ITEM = 1

Шейдер - 2D шейдер.

ShaderMode SHADER_PARTICLES = 2

Шейдер являє собою шейдер частинок (може бути використаний в обох 2D і 3D).

ShaderMode SHADER_SKY = 3

Шейдер - 3D шейдер.

ShaderMode SHADER_FOG = 4

Шейдер - 3D фольговий шейдер.

ShaderMode SHADER_MAX = 5

Представляє розмір ShaderMode enum.

enum ArrayType: 🔗

ArrayType ARRAY_VERTEX = 0

Array є a vertex позиція масиву.

ArrayType ARRAY_NORMAL = 1

Array є нормальним масивом.

ArrayType ARRAY_TANGENT = 2

Array - дубовий масив.

ArrayType ARRAY_COLOR = 3

Array - це кольоровий масив вершини.

ArrayType ARRAY_TEX_UV = 4

Array - координатний масив УФ.

ArrayType ARRAY_TEX_UV2 = 5

Array - УФ-координатний масив для другого набору УФ-координат.

ArrayType ARRAY_CUSTOM0 = 6

Array - це спеціальний масив даних для першого набору користувацьких даних.

ArrayType ARRAY_CUSTOM1 = 7

Array - це спеціальний масив даних для другого набору користувацьких даних.

ArrayType ARRAY_CUSTOM2 = 8

Array - це спеціальний масив даних для третього набору користувацьких даних.

ArrayType ARRAY_CUSTOM3 = 9

Array - це спеціальний масив даних для четвертого набору користувацьких даних.

ArrayType ARRAY_BONES = 10

Array містить інформацію про кістки.

ArrayType ARRAY_WEIGHTS = 11

Array це інформація про вагу.

ArrayType ARRAY_INDEX = 12

Array - індексний масив.

ArrayType ARRAY_MAX = 13

Представляємо розмір ArrayType enum.

enum ArrayCustomFormat: 🔗

ArrayCustomFormat ARRAY_CUSTOM_RGBA8_UNORM = 0

Цінності нормалізуються, не відзначаються плаваючі точки в діапазоні [0.0, 1.0].

ArrayCustomFormat ARRAY_CUSTOM_RGBA8_SNORM = 1

Значення нормалізуються, підписані плаваючі точки в діапазоні [-1.0, 1.0].

ArrayCustomFormat ARRAY_CUSTOM_RG_HALF = 2

Спеціальний масив даних містить 16-bit-per-канал червоний/зелений колір даних. Цінності плаваючі точки на половині прецизії.

ArrayCustomFormat ARRAY_CUSTOM_RGBA_HALF = 3

Цінності плаваючі точки на половині прецизії.

ArrayCustomFormat ARRAY_CUSTOM_R_FLOAT = 4

Спеціальний масив даних містить 32-bit-per-канал червоний колір даних. Значення плаваючі точки в одній точності.

ArrayCustomFormat ARRAY_CUSTOM_RG_FLOAT = 5

Спеціальний масив даних містить 32-bit-per-канал червоний/зелений колір даних. Значення плаваючі точки в одній точності.

ArrayCustomFormat ARRAY_CUSTOM_RGB_FLOAT = 6

Спеціальний масив даних містить 32-bit-per-канал червоний/зелений/синій колір даних. Значення плаваючі точки в одній точності.

ArrayCustomFormat ARRAY_CUSTOM_RGBA_FLOAT = 7

Значення плаваючі точки в одній точності.

ArrayCustomFormat ARRAY_CUSTOM_MAX = 8

Представляємо розмір ArrayCustomFormat enum.

flags ArrayFormat: 🔗

ArrayFormat ARRAY_FORMAT_VERTEX = 1

Прапор, який використовується для позначення вершини позиції вершини.

ArrayFormat ARRAY_FORMAT_NORMAL = 2

Прапор використовується для позначення нормального масиву.

ArrayFormat ARRAY_FORMAT_TANGENT = 4

Прапор використовується для позначення дубажу.

ArrayFormat ARRAY_FORMAT_COLOR = 8

Прапор використовується для позначення кольорового масиву вершини.

ArrayFormat ARRAY_FORMAT_TEX_UV = 16

Прапор використовується для позначення УФ-координат масиву.

ArrayFormat ARRAY_FORMAT_TEX_UV2 = 32

Прапор використовується для позначення УФ-координат масиву для координат другого УФ.

ArrayFormat ARRAY_FORMAT_CUSTOM0 = 64

Прапор, який використовується для позначення масиву користувацьких даних з конвертів для першого набору користувацьких даних.

ArrayFormat ARRAY_FORMAT_CUSTOM1 = 128

Прапор, який використовується для позначення масиву користувацьких даних з конвертів для другого набору користувацьких даних.

ArrayFormat ARRAY_FORMAT_CUSTOM2 = 256

Прапор, який використовується для позначення масиву користувацьких даних з конвертів для третього набору користувацьких даних.

ArrayFormat ARRAY_FORMAT_CUSTOM3 = 512

Прапор, який використовується для позначення масиву користувацьких даних з-за вершини для четвертого набору користувацьких даних.

ArrayFormat ARRAY_FORMAT_BONES = 1024

Прапор використовується для позначення кісткового масиву інформації.

ArrayFormat ARRAY_FORMAT_WEIGHTS = 2048

Прапор використовується для позначення масиву ваги.

ArrayFormat ARRAY_FORMAT_INDEX = 4096

Прапор використовується для позначення індексного масиву.

ArrayFormat ARRAY_FORMAT_BLEND_SHAPE_MASK = 7

Маска сітчастих каналів дозволяється в формі блендера.

ArrayFormat ARRAY_FORMAT_CUSTOM_BASE = 13

Шифт першого користувацького каналу.

ArrayFormat ARRAY_FORMAT_CUSTOM_BITS = 3

Кількість форматних біт на користувальницький канал. ArrayCustomFormat.

ArrayFormat ARRAY_FORMAT_CUSTOM0_SHIFT = 13

Сума для перемикання ArrayCustomFormat для індексу каналів 0.

ArrayFormat ARRAY_FORMAT_CUSTOM1_SHIFT = 16

Сума для перемикання ArrayCustomFormat для індексу каналів 1.

ArrayFormat ARRAY_FORMAT_CUSTOM2_SHIFT = 19

Сума для перемикання ArrayCustomFormat для індексу каналів 2.

ArrayFormat ARRAY_FORMAT_CUSTOM3_SHIFT = 22

Сума для перемикання ArrayCustomFormat для індексу каналів 3.

ArrayFormat ARRAY_FORMAT_CUSTOM_MASK = 7

Маска користувальницьких форматів біт на користувацькому каналі. Необхідно перенести один з констанцій SHIFT. ArrayCustomFormat.

ArrayFormat ARRAY_COMPRESS_FLAGS_BASE = 25

Шифт першого компресорного прапора. Стискачі повинні бути передані в ArrayMesh.add_surface_from_arrays() і SurfaceTool.commit().

ArrayFormat ARRAY_FLAG_USE_2D_VERTICES = 33554432

Прапор використовується для позначення, що масив містить 2D вершини.

ArrayFormat ARRAY_FLAG_USE_DYNAMIC_UPDATE = 67108864

Прапорець, що використовується для позначення того, що дані сітки використовуватимуть GL_DYNAMIC_DRAW на GLES. Не використовується на Vulkan.

ArrayFormat ARRAY_FLAG_USE_8_BONE_WEIGHTS = 134217728

Прапор використовується для позначення, що масив використовує 8 кісток замість 4.

ArrayFormat ARRAY_FLAG_USES_EMPTY_VERTEX_ARRAY = 268435456

Прапор використовується для позначення, що сітка не має масиву вершини і замість того, щоб запліднити позиції вершини в тіні, використовуючи індекси та інші відомості.

ArrayFormat ARRAY_FLAG_COMPRESS_ATTRIBUTES = 536870912

Прапор використовується для позначення, що сітка використовує стиснені атрибути (перетворювачі, норми, тангенси, УФ). Коли ця форма стиснення ввімкнена, позиції вершини будуть упаковані в атрибут RGBA16UNORM і масштабовані в шейдері вершини. Нормальний і tangent буде упаковано в RG16UNORM, що представляє вісь, і 16-бітний плавлення, що зберігається в A-каналі вершини. УФС використовуватимуть 16-бітні нормалізовані плавки замість повної 32-бітової підписаної плавки. При використанні цього режиму стиснення ви повинні використовувати або вершини, нормали, тангенси або тільки вершини. Ви не можете використовувати нормалі без тангенсів. Імпортери автоматично ввімкнуть цю компресію, якщо вони можуть.

ArrayFormat ARRAY_FLAG_FORMAT_VERSION_BASE = 35

Прапор використовується для позначення запуску біт, використовуваних для зберігання сітки версії.

ArrayFormat ARRAY_FLAG_FORMAT_VERSION_SHIFT = 35

Прапор використовується для зміни формату сітки, щоб принести версію в найнижчі цифри.

ArrayFormat ARRAY_FLAG_FORMAT_VERSION_1 = 0

Прапор використовується для запису формату, що використовується за допомогою попередніх версій сітки до введення версії.

ArrayFormat ARRAY_FLAG_FORMAT_VERSION_2 = 34359738368

Прапор використовується для запису другої ітерації прапора сітки. Основна відмінність цього і ARRAY_FLAG_FORMAT_VERSION_1 полягає в тому, що ця версія підтримує ARRAY_FLAG_COMPRESS_ATTRIBUTES і в цьому варіанті позиції вершини виводяться з нормалей і тангенсів.

ArrayFormat ARRAY_FLAG_FORMAT_CURRENT_VERSION = 34359738368

Прапор використовується для запису поточного варіанту, який очікує двигун. В даний час це так само, як ARRAY_FLAG_FORMAT_VERSION_2.

ArrayFormat ARRAY_FLAG_FORMAT_VERSION_MASK = 255

Прапор використовується для ізоляції укусів, які використовуються для сітчастої версії після використання ARRAY_FLAG_FORMAT_VERSION_SHIFT для перемикання їх на місце.

enum PrimitiveType: 🔗

PrimitiveType PRIMITIVE_POINTS = 0

Примітив до малювати складається з точок.

PrimitiveType PRIMITIVE_LINES = 1

Примітивний малюнок складається з ліній.

PrimitiveType PRIMITIVE_LINE_STRIP = 2

Примітив для малювання складається з лінійної смуги від початку до кінця.

PrimitiveType PRIMITIVE_TRIANGLES = 3

Примітив для малювання складається з трикутників.

PrimitiveType PRIMITIVE_TRIANGLE_STRIP = 4

Примітивний малюнок складається з трикутникової смуги ( останні 3 вершини завжди поєднуються, щоб зробити трикутник).

PrimitiveType PRIMITIVE_MAX = 5

Представляємо розмір параметра PrimitiveType.

enum BlendShapeMode: 🔗

BlendShapeMode BLEND_SHAPE_MODE_NORMALIZED = 0

Норматизовані форми суміша.

BlendShapeMode BLEND_SHAPE_MODE_RELATIVE = 1

Блендерні форми відносно базової ваги.

enum MultimeshTransformFormat: 🔗

MultimeshTransformFormat MULTIMESH_TRANSFORM_2D = 0

Використовуйте Transform2D для зберігання мультимеш трансформатора.

MultimeshTransformFormat MULTIMESH_TRANSFORM_3D = 1

Використовуйте Transform3D для зберігання мультимеш трансформатора.

enum MultimeshPhysicsInterpolationQuality: 🔗

MultimeshPhysicsInterpolationQuality MULTIMESH_INTERP_QUALITY_FAST = 0

Інтерполяція фізики MultiMesh надає перевагу швидкості, а не якості.

MultimeshPhysicsInterpolationQuality MULTIMESH_INTERP_QUALITY_HIGH = 1

Інтерполяція фізики MultiMesh надає перевагу якості, а не швидкості.

enum LightProjectorFilter: 🔗

LightProjectorFilter LIGHT_PROJECTOR_FILTER_NEAREST = 0

Найближчий фільтр для світлових проекторів (застосування для проекторів з піксельним артом). Для рендерингу використовуються мапи, що означає світлові проектори на відстані будуть виглядати гостро, але зернові. Це має приблизно однакову вартість виконання, як за допомогою mipmaps.

LightProjectorFilter LIGHT_PROJECTOR_FILTER_LINEAR = 1

Лінійний фільтр для світлових проекторів (використання для непіксельних арт-проекторів). Немає міток використовуються для рендерингу, що означає світлові проектори на відстані будуть виглядати гладкими, але розмитими. Це має приблизно однакову вартість виконання, як за допомогою mipmaps.

LightProjectorFilter LIGHT_PROJECTOR_FILTER_NEAREST_MIPMAPS = 2

Найближчий фільтр для світлових проекторів (застосування для проекторів з піксельним артом). Ізотропні карти використовуються для рендерингу, що означає світлопроектори на відстані будуть виглядати гладкими, але розмитими. Це має приблизно однакову вартість виконання, як і не використовуючи mipmaps.

LightProjectorFilter LIGHT_PROJECTOR_FILTER_LINEAR_MIPMAPS = 3

Лінійний фільтр для світлових проекторів (використання для непіксельних арт-проекторів). Ізотропні карти використовуються для рендерингу, що означає світлопроектори на відстані будуть виглядати гладкими, але розмитими. Це має приблизно однакову вартість виконання, як і не використовуючи mipmaps.

LightProjectorFilter LIGHT_PROJECTOR_FILTER_NEAREST_MIPMAPS_ANISOTROPIC = 4

Найближчий фільтр для світлових проекторів (застосування для проекторів з піксельним артом). Анізотропні карти використовуються для рендерингу, що означає світлові проектори на відстані будуть виглядати гладко і гостро при перегляді кутів коси. Це виглядає краще, ніж ізотропні карти, але повільніше. Рівень анізотропного фільтрування визначається ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level.

LightProjectorFilter LIGHT_PROJECTOR_FILTER_LINEAR_MIPMAPS_ANISOTROPIC = 5

Лінійний фільтр для світлових проекторів (використання для непіксельних арт-проекторів). Анізотропні карти використовуються для рендерингу, що означає світлові проектори на відстані будуть виглядати гладко і гостро при перегляді кутів коси. Це виглядає краще, ніж ізотропні карти, але повільніше. Рівень анізотропного фільтрування визначається ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level.

enum LightType: 🔗

LightType LIGHT_DIRECTIONAL = 0

Прямий (sun/moon) легкий (див. DirectionalLight3D).

LightType LIGHT_OMNI = 1

Omni light (див. OmniLight3D).

LightType LIGHT_SPOT = 2

Spot light (див. SpotLight3D).

enum LightParam: 🔗

LightParam LIGHT_PARAM_ENERGY = 0

Множник легкої енергії.

LightParam LIGHT_PARAM_INDIRECT_ENERGY = 1

Множник легкої енергії (фінансова непряма енергія LIGHT_PARAM_ENERGY * LIGHT_PARAM_INDIRECT_ENERGY].

LightParam LIGHT_PARAM_VOLUMETRIC_FOG_ENERGY = 2

Мультиплікатор легкої енергії фольги (кінцева об'ємна енергія фольги LIGHT_PARAM_ENERGY * LIGHT_PARAM_VOLUMETRIC_FOG_ENERGY).

LightParam LIGHT_PARAM_SPECULAR = 3

Вплив світла на спекулянту.

LightParam LIGHT_PARAM_RANGE = 4

Легкий діапазон.

LightParam LIGHT_PARAM_SIZE = 5

Розмір світла при використанні точкового світла або омні світла. кутовий розмір світла при використанні спрямованого світла.

LightParam LIGHT_PARAM_ATTENUATION = 6

Легке загартування.

LightParam LIGHT_PARAM_SPOT_ANGLE = 7

Кут точкового світильника.

LightParam LIGHT_PARAM_SPOT_ATTENUATION = 8

Захоплення точкового світла.

LightParam LIGHT_PARAM_SHADOW_MAX_DISTANCE = 9

Максимальна відстань для тіньових розколів. Підвищення цього значення дозволить зробити спрямовані тіні, видимі з подальшої відкладки, за вартістю нижньої загальної деталі тіні і продуктивності (звідси більше об'єктів необхідно включити в спрямовану тінь).

LightParam LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET = 10

Пропортування тіньових атласів, зайнятих першим розщепленням.

LightParam LIGHT_PARAM_SHADOW_SPLIT_2_OFFSET = 11

Пропортування тіньових атласів, зайнятих другим розколом.

LightParam LIGHT_PARAM_SHADOW_SPLIT_3_OFFSET = 12

Пропортування тіньових атласів, зайнятих третьою роздільною здатністю. Четвертий спліт займає решту.

LightParam LIGHT_PARAM_SHADOW_FADE_START = 13

Пропорція тіньової максимальної відстані, де тінь почнеться згасати.

LightParam LIGHT_PARAM_SHADOW_NORMAL_BIAS = 14

Нормальні засоби, які використовуються для відключення тіньового вигляду за нормальним об'єктом. Може використовуватися для фіксації самосушильних артефактів.

LightParam LIGHT_PARAM_SHADOW_BIAS = 15

Зміщення для пошуку тіней для виправлення артефактів самозатінення.

LightParam LIGHT_PARAM_SHADOW_PANCAKE_SIZE = 16

Встановлює розмір спрямованого тіньового млинця. Млинець відключає початок роботи камери тіні frustum, щоб забезпечити більш ефективне регулювання глибини для тіні. Однак високий розмір млинця може викликати артефакти в тіні великих об'єктів, які знаходяться поблизу краю фрусту. Зменшення розміру млинця може допомогти. Налаштування розміру до 0 вимкнено ефект каструлі.

LightParam LIGHT_PARAM_SHADOW_OPACITY = 17

Тепла тіньова непрозорість. Значення нижче 1.0 зробити світло через тіні. Це може бути використаний для підробки глобального освітлення при низькій вартості виконання.

LightParam LIGHT_PARAM_SHADOW_BLUR = 18

Розмиваємо краю тіні. Може використовуватися для приховувати піксельні артефакти в shadow map. Висока вартість може зробити тіні, які з'являються зернові та можуть викликати інші небажані артефакти. Намагайтеся тримати якомога ближче за замовчуванням.

LightParam LIGHT_PARAM_TRANSMITTANCE_BIAS = 19

There is currently no description for this enum. Please help us by contributing one!

LightParam LIGHT_PARAM_INTENSITY = 20

Постійне відображення інтенсивності світла, вимірюваного в Лумень при спілкуванні з SpotLight3D або OmniLight3D, або вимірюється в Lux з DirectionalLight3D. true.

LightParam LIGHT_PARAM_MAX = 21

Представляємо розмір LightParam enum.

enum LightBakeMode: 🔗

LightBakeMode LIGHT_BAKE_DISABLED = 0

Світло ігнорується при випіканні. Це найшвидший режим, але світло буде враховуватися при випіканні глобального освітлення. Цей режим, як правило, слід використовувати для динамічних вогнів, які швидко змінюються, оскільки ефект глобального освітлення менш помітний на цих світильниках.

LightBakeMode LIGHT_BAKE_STATIC = 1

Світло враховується у статичному випіканні (VoxelGI, LightmapGI, SDFGI (Environment.sdfgi_enabled)). Світло можна переміщувати або змінювати, але його глобальне освітлення не оновлюватиметься в режимі реального часу. Це підходить для незначних змін (таких як мерехтіння факелів), але загалом не для великих змін, таких як увімкнення та вимкнення світла.

LightBakeMode LIGHT_BAKE_DYNAMIC = 2

Світло враховується в динамічному випіканні (лише для VoxelGI та SDFGI (Environment.sdfgi_enabled)). Світло можна переміщувати або змінювати, оновлюючи глобальне освітлення в режимі реального часу. Зовнішній вигляд глобального освітлення світла дещо відрізнятиметься порівняно з LIGHT_BAKE_STATIC. Це має більші витрати на продуктивність порівняно з LIGHT_BAKE_STATIC. Під час використання SDFGI на швидкість оновлення динамічного освітлення впливає ProjectSettings.rendering/global_illumination/sdfgi/frames_to_update_lights.

enum LightOmniShadowMode: 🔗

LightOmniShadowMode LIGHT_OMNI_SHADOW_DUAL_PARABOLOID = 0

Використовуйте подвійну параболоїдну shadow map для omni вогні.

LightOmniShadowMode LIGHT_OMNI_SHADOW_CUBE = 1

Використовуйте shadow map для omni вогні. Slower але краще якість, ніж подвійний параболоїд.

enum LightDirectionalShadowMode: 🔗

LightDirectionalShadowMode LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL = 0

Використовуйте ортгональну тіньову проекцію для спрямованого світла.

LightDirectionalShadowMode LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS = 1

Використовуйте 2 розколів для Shadow проекції при використанні спрямованого світла.

LightDirectionalShadowMode LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS = 2

Використовуйте 4 розколів для Shadow проекції при використанні спрямованого світла.

enum LightDirectionalSkyMode: 🔗

LightDirectionalSkyMode LIGHT_DIRECTIONAL_SKY_MODE_LIGHT_AND_SKY = 0

Використання DirectionalLight3 D в небі рендерингу та сценічного освітлення.

LightDirectionalSkyMode LIGHT_DIRECTIONAL_SKY_MODE_LIGHT_ONLY = 1

Тільки використовувати DirectionalLight3 D на сцені освітлення.

LightDirectionalSkyMode LIGHT_DIRECTIONAL_SKY_MODE_SKY_ONLY = 2

Тільки використовувати DirectionalLight3 D в небі рендерингу.

enum ShadowQuality: 🔗

ShadowQuality SHADOW_QUALITY_HARD = 0

Найнижча якість фільтрації тіней (найшвидша). М’які тіні недоступні з цим налаштуванням якості, що означає, що властивість Light3D.shadow_blur ігнорується, якщо Light3D.light_size та Light3D.light_angular_distance мають значення 0.0.

Примітка: Змінне розмиття тіні, яке виконується Light3D.light_size та Light3D.light_angular_distance, все ще ефективне при використанні жорсткої фільтрації тіней. У цьому випадку Light3D.shadow_blur враховується. Однак результати не будуть розмитими, натомість величина розмиття розглядається як максимальний радіус для півтіні.

ShadowQuality SHADOW_QUALITY_SOFT_VERY_LOW = 1

Дуже низька якість фільтрації тіней (швидше). Під час використання цього налаштування якості Light3D.shadow_blur автоматично множиться на 0,75×, щоб уникнути надмірного шуму. Це ділення застосовується лише до джерел світла, Light3D.light_size або Light3D.light_angular_distance яких дорівнює 0.0).

ShadowQuality SHADOW_QUALITY_SOFT_LOW = 2

Низька якість тіней фільтрації (смак).

ShadowQuality SHADOW_QUALITY_SOFT_MEDIUM = 3

Середня низька якість тіней фільтрації (середній).

ShadowQuality SHADOW_QUALITY_SOFT_HIGH = 4

Висока якість фільтрації низьких тіней (повільно). Під час використання цього налаштування якості Light3D.shadow_blur автоматично множиться на 1,5×, щоб краще використовувати велику кількість вибірок. Це збільшене розмиття також покращує стабільність динамічних тіней об'єктів. Цей множник застосовується лише до джерел світла, Light3D.light_size або Light3D.light_angular_distance яких дорівнює 0.0).

ShadowQuality SHADOW_QUALITY_SOFT_ULTRA = 5

Найвища якість фільтрації низьких тіней (найповільніша). Під час використання цього налаштування якості Light3D.shadow_blur автоматично множиться на 2×, щоб краще використовувати велику кількість вибірок. Це збільшене розмиття також покращує стабільність динамічних тіней об'єктів. Цей множник застосовується лише до джерел світла, Light3D.light_size або Light3D.light_angular_distance яких дорівнює 0.0).

ShadowQuality SHADOW_QUALITY_MAX = 6

Представляємо розмір ShadowQuality enum.

enum ReflectionProbeUpdateMode: 🔗

ReflectionProbeUpdateMode REFLECTION_PROBE_UPDATE_ONCE = 0

Відображення пробе буде оновлювати відбиття один раз, а потім зупинитися.

ReflectionProbeUpdateMode REFLECTION_PROBE_UPDATE_ALWAYS = 1

Відображення зонда буде оновлювати кожну раму. Цей режим необхідний для захоплення рухомих об'єктів.

enum ReflectionProbeAmbientMode: 🔗

ReflectionProbeAmbientMode REFLECTION_PROBE_AMBIENT_DISABLED = 0

Не застосовувати будь-яке освітлення навколишнього середовища всередині коробки відбиття, визначеної його розміром.

ReflectionProbeAmbientMode REFLECTION_PROBE_AMBIENT_ENVIRONMENT = 1

Застосувати автоматичне освітлення навколишнього середовища всередині коробки відбиття, визначеної його розміром.

ReflectionProbeAmbientMode REFLECTION_PROBE_AMBIENT_COLOR = 2

Застосуйте власне навколишнє освітлення всередині коробки зонда відбиття, визначеної його розміром. Див. reflection_probe_set_ambient_color() та reflection_probe_set_ambient_energy().

enum DecalTexture: 🔗

DecalTexture DECAL_TEXTURE_ALBEDO = 0

Слот текстури альбедо в декалі (Decal.texture_albedo).

DecalTexture DECAL_TEXTURE_NORMAL = 1

Нормальний слот текстури карти в декалі (Decal.texture_normal).

DecalTexture DECAL_TEXTURE_ORM = 2

Occlusion/Roughness/Metallic текстурний слот в декалі (Decal.texture_orm).

DecalTexture DECAL_TEXTURE_EMISSION = 3

Слот текстури випромінювання в декалі (Decal.texture_emission).

DecalTexture DECAL_TEXTURE_MAX = 4

Представляємо розмір DecalTexture enum.

enum DecalFilter: 🔗

DecalFilter DECAL_FILTER_NEAREST = 0

Найсучасніший фільтр для декалі (використання для піксельних суглобів). Для рендерингу використовуються мітки, що означає декалі на відстані будуть виглядати гострі, але зернові. Це має приблизно однакову вартість виконання, як за допомогою mipmaps.

DecalFilter DECAL_FILTER_LINEAR = 1

Лінійний фільтр для декалі (використання для непіксельних суглобів). Немає міток використовуються для рендерингу, що означає декалі на відстані будуть виглядати гладкими, але розмитими. Це має приблизно однакову вартість виконання, як за допомогою mipmaps.

DecalFilter DECAL_FILTER_NEAREST_MIPMAPS = 2

Найсучасніший фільтр для декалі (використання для піксельних суглобів). Ізотропні карти використовуються для рендерингу, що означає декалі на відстані будуть виглядати гладкими, але розмитими. Це має приблизно однакову вартість виконання, як і не використовуючи mipmaps.

DecalFilter DECAL_FILTER_LINEAR_MIPMAPS = 3

Лінійний фільтр для декалі (використання для непіксельних суглобів). Ізотропні карти використовуються для рендерингу, що означає декалі на відстані будуть виглядати гладкими, але розмитими. Це має приблизно однакову вартість виконання, як і не використовуючи mipmaps.

DecalFilter DECAL_FILTER_NEAREST_MIPMAPS_ANISOTROPIC = 4

Фільтр найближчого сусіда для декалей (використовується для декалей піксельної графіки). Анізотропні міп-мапи використовуються для рендерингу, що означає, що декалі на відстані виглядатимуть гладкими та чіткими, якщо дивитися під косим кутом. Це виглядає краще порівняно з ізотропними міп-мапами, але повільніше. Рівень анізотропної фільтрації визначається параметром ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level.

DecalFilter DECAL_FILTER_LINEAR_MIPMAPS_ANISOTROPIC = 5

Лінійний фільтр для декалей (використовуйте для декалей, що не є піксельною графікою). Для рендерингу використовуються анізотропні міп-мапи, що означає, що декалі на відстані виглядатимуть гладкими та чіткими, якщо дивитися на них під косим кутом. Це виглядає краще порівняно з ізотропними міп-мапами, але повільніше. Рівень анізотропної фільтрації визначається параметром ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level.

enum VoxelGIQuality: 🔗

VoxelGIQuality VOXEL_GI_QUALITY_LOW = 0

Низькі VoxelGI забезпечують якість використання 4 конусів.

VoxelGIQuality VOXEL_GI_QUALITY_HIGH = 1

Висока VoxelGI забезпечує якість за допомогою 6 конусів.

enum ParticlesMode: 🔗

ParticlesMode PARTICLES_MODE_2D = 0

2D частинки.

ParticlesMode PARTICLES_MODE_3D = 1

3D частинки.

enum ParticlesTransformAlign: 🔗

ParticlesTransformAlign PARTICLES_TRANSFORM_ALIGN_DISABLED = 0

There is currently no description for this enum. Please help us by contributing one!

ParticlesTransformAlign PARTICLES_TRANSFORM_ALIGN_Z_BILLBOARD = 1

There is currently no description for this enum. Please help us by contributing one!

ParticlesTransformAlign PARTICLES_TRANSFORM_ALIGN_Y_TO_VELOCITY = 2

There is currently no description for this enum. Please help us by contributing one!

ParticlesTransformAlign PARTICLES_TRANSFORM_ALIGN_Z_BILLBOARD_Y_TO_VELOCITY = 3

There is currently no description for this enum. Please help us by contributing one!

enum ParticlesDrawOrder: 🔗

ParticlesDrawOrder PARTICLES_DRAW_ORDER_INDEX = 0

Нанесення частинок в порядку, що вони з'являються в масиві частинок.

ParticlesDrawOrder PARTICLES_DRAW_ORDER_LIFETIME = 1

Сортування частинок на основі їх життя. Іншими словами, частинка з найвищим терміном придатна на фронті.

ParticlesDrawOrder PARTICLES_DRAW_ORDER_REVERSE_LIFETIME = 2

Сортування частинок на основі інверсу їх життя. Іншими словами, частинка з найнижчим терміном наноситься на передній.

ParticlesDrawOrder PARTICLES_DRAW_ORDER_VIEW_DEPTH = 3

Сортування частинок на основі їх відстані до камери.

enum ParticlesCollisionType: 🔗

ParticlesCollisionType PARTICLES_COLLISION_TYPE_SPHERE_ATTRACT = 0

There is currently no description for this enum. Please help us by contributing one!

ParticlesCollisionType PARTICLES_COLLISION_TYPE_BOX_ATTRACT = 1

There is currently no description for this enum. Please help us by contributing one!

ParticlesCollisionType PARTICLES_COLLISION_TYPE_VECTOR_FIELD_ATTRACT = 2

There is currently no description for this enum. Please help us by contributing one!

ParticlesCollisionType PARTICLES_COLLISION_TYPE_SPHERE_COLLIDE = 3

There is currently no description for this enum. Please help us by contributing one!

ParticlesCollisionType PARTICLES_COLLISION_TYPE_BOX_COLLIDE = 4

There is currently no description for this enum. Please help us by contributing one!

ParticlesCollisionType PARTICLES_COLLISION_TYPE_SDF_COLLIDE = 5

There is currently no description for this enum. Please help us by contributing one!

ParticlesCollisionType PARTICLES_COLLISION_TYPE_HEIGHTFIELD_COLLIDE = 6

There is currently no description for this enum. Please help us by contributing one!

enum ParticlesCollisionHeightfieldResolution: 🔗

ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_256 = 0

There is currently no description for this enum. Please help us by contributing one!

ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_512 = 1

There is currently no description for this enum. Please help us by contributing one!

ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_1024 = 2

There is currently no description for this enum. Please help us by contributing one!

ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_2048 = 3

There is currently no description for this enum. Please help us by contributing one!

ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_4096 = 4

There is currently no description for this enum. Please help us by contributing one!

ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_8192 = 5

There is currently no description for this enum. Please help us by contributing one!

ParticlesCollisionHeightfieldResolution PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_MAX = 6

Представляє розмір частинокCollisionHeightfieldResolution enum.

enum FogVolumeShape: 🔗

FogVolumeShape FOG_VOLUME_SHAPE_ELLIPSOID = 0

FogVolume буде формуватися як еліпсоїд (загальна сфера).

FogVolumeShape FOG_VOLUME_SHAPE_CONE = 1

FogVolume буде у вигляді конуса, що вказує вгору (у місцевих координати). Кут конуса встановлюється автоматично, щоб заповнити розмір. Конус буде пристосований для влаштування в межах розміру. Обертайте вузол FogVolume, щоб переорієнтуватися конуса. Неоднорідне масштабування за розмірами не підтримується (розміри вузол FogVolume).

FogVolumeShape FOG_VOLUME_SHAPE_CYLINDER = 2

FogVolume буде у формі вертикального циліндра (у місцевих координатах). Обертайте вузол FogVolume для переорієнтування циліндра. Циліндр буде регулюватися, щоб відповідати розміру. Неоднорідне масштабування за розмірами не підтримується (розміри вузол FogVolume).

FogVolumeShape FOG_VOLUME_SHAPE_BOX = 3

FogVolume буде у вигляді коробки.

FogVolumeShape FOG_VOLUME_SHAPE_WORLD = 4

FogVolume не буде формувати, покриє весь світ і не буде культивуватися.

FogVolumeShape FOG_VOLUME_SHAPE_MAX = 5

Представляє розмір FogVolumeShape enum.

enum ViewportScaling3DMode: 🔗

ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_BILINEAR = 0

Використовуйте дволінійне масштабування для перегляду 3D буфера. Сума масштабування може бути встановлена за допомогою Viewport.scaling_3d_scale. Значення менше 1.0 призведе до занурення значень при більшій кількості значень 1.0 призведе до перенапруги. Значення 1.0 відключає масштабування.

ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_FSR = 1

Використовуйте масштабування AMD FidelityFX Super Resolution 1.0 для 3D-буфера області перегляду. Величину масштабування можна встановити за допомогою Viewport.scaling_3d_scale. Значення менші за 1.0 призведуть до масштабування області перегляду за допомогою FSR. Значення більші за 1.0 не підтримуються, замість них буде використовуватися білінійне зниження роздільної здатності. Значення 1.0 вимикає масштабування.

ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_FSR2 = 2

Використовуйте масштабування AMD FidelityFX Super Resolution 2.2 для 3D-буфера області перегляду. Величину масштабування можна встановити за допомогою Viewport.scaling_3d_scale. Значення менші за 1.0 призведуть до масштабування області перегляду за допомогою FSR2. Значення більші за 1.0 не підтримуються, і замість них буде використовуватися білінійне зниження роздільної здатності. Значення 1.0 використовуватиме FSR2 з рідною роздільною здатністю як рішення TAA.

ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_METALFX_SPATIAL = 3

Використовуйте просторове масштабування MetalFX для 3D-буфера області перегляду. Величину масштабування можна встановити за допомогою Viewport.scaling_3d_scale. Значення менші за 1.0 призведуть до масштабування області перегляду за допомогою MetalFX. Значення більші за 1.0 не підтримуються, замість них використовуватиметься білінійне зниження роздільної здатності. Значення 1.0 вимикає масштабування.

Примітка: Підтримується лише тоді, коли використовується драйвер рендерингу Metal, що обмежує цей режим масштабування macOS та iOS.

ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_METALFX_TEMPORAL = 4

Використовуйте часове масштабування MetalFX для 3D-буфера області перегляду. Величину масштабування можна встановити за допомогою Viewport.scaling_3d_scale. Значення менші за 1.0 призведуть до масштабування області перегляду за допомогою MetalFX. Значення більші за 1.0 не підтримуються, і замість них буде використовуватися білінійне зниження роздільної здатності. Значення 1.0 використовуватиме MetalFX з рідною роздільною здатністю як рішення TAA.

Примітка: Підтримується лише тоді, коли використовується драйвер рендерингу Metal, що обмежує цей режим масштабування macOS та iOS.

ViewportScaling3DMode VIEWPORT_SCALING_3D_MODE_MAX = 5

Представляє розмір ViewportScaling3DMode enum.

enum ViewportUpdateMode: 🔗

ViewportUpdateMode VIEWPORT_UPDATE_DISABLED = 0

Не оновлюйте цільову інформацію.

ViewportUpdateMode VIEWPORT_UPDATE_ONCE = 1

Оновіть цільову інформацію, після чого ввімкніть до VIEWPORT_UPDATE_DISABLED.

ViewportUpdateMode VIEWPORT_UPDATE_WHEN_VISIBLE = 2

Оновити цільову інформацію, коли це видно. Це значення за замовчуванням.

ViewportUpdateMode VIEWPORT_UPDATE_WHEN_PARENT_VISIBLE = 3

Оновіть цільову інформацію, коли його видно.

ViewportUpdateMode VIEWPORT_UPDATE_ALWAYS = 4

Завжди оновлюємо цільову інформацію.

enum ViewportClearMode: 🔗

ViewportClearMode VIEWPORT_CLEAR_ALWAYS = 0

Завжди очищайте цільову інформацію перед кресленням.

ViewportClearMode VIEWPORT_CLEAR_NEVER = 1

Ніколи не очищайте цільову інформацію.

ViewportClearMode VIEWPORT_CLEAR_ONLY_NEXT_FRAME = 2

Очистити цільову інформацію про порти на наступному кадрі, потім перейти до VIEWPORT_CLEAR_NEVER.

enum ViewportEnvironmentMode: 🔗

ViewportEnvironmentMode VIEWPORT_ENVIRONMENT_DISABLED = 0

Вимкнено рендеринг 3D середовища на 2D полотно.

ViewportEnvironmentMode VIEWPORT_ENVIRONMENT_ENABLED = 1

Увімкнути рендеринг 3D середовища понад 2D полотно.

ViewportEnvironmentMode VIEWPORT_ENVIRONMENT_INHERIT = 2

Увімкнути/вимкнути значення з батьків. Якщо у верхній частині батьків також встановлений VIEWPORT_ENVIRONMENT_INHERIT, то це ж поведінка, як VIEWPORT_ENVIRONMENT_ENABLED.

ViewportEnvironmentMode VIEWPORT_ENVIRONMENT_MAX = 3

Представляємо розмір ViewportEnvironmentMode enum.

enum ViewportSDFOversize: 🔗

ViewportSDFOversize VIEWPORT_SDF_OVERSIZE_100_PERCENT = 0

Не перезавантажуйте поле відстані 2D. Включає в себе при дотику країв Перегляду, і GPUParticles3D зіткнення може зупинити роботу раніше, ніж призначене. Це має найнижчі вимоги GPU.

ViewportSDFOversize VIEWPORT_SDF_OVERSIZE_120_PERCENT = 1

2D підписано поле дистанції охоплює 20% від розміру портів за межами портфоліо з кожного боку (верх, праворуч, низ, зліва).

ViewportSDFOversize VIEWPORT_SDF_OVERSIZE_150_PERCENT = 2

2D підписане поле дистанції охоплює 50% від розміру портів, що виходять за межі країни (верх, праворуч, низ, зліва).

ViewportSDFOversize VIEWPORT_SDF_OVERSIZE_200_PERCENT = 3

2D підписано поле дистанції охоплює 100% від розміру перегляда за межами порту з кожного боку (верхова справа, низ, зліва). Це має найвищі вимоги до GPU.

ViewportSDFOversize VIEWPORT_SDF_OVERSIZE_MAX = 4

Представляє розмір Viewportfoversize enum.

enum ViewportSDFScale: 🔗

ViewportSDFScale VIEWPORT_SDF_SCALE_100_PERCENT = 0

Повна роздільна здатність 2D підписана польова вага. Це має найвищі вимоги до GPU.

ViewportSDFScale VIEWPORT_SDF_SCALE_50_PERCENT = 1

Половина роздільної здатності 2D підписана польова вага на кожну віссю (25% від кількості піксельних пікселів).

ViewportSDFScale VIEWPORT_SDF_SCALE_25_PERCENT = 2

Квартальна роздільна здатність 2D підписана польова шкала на кожній осі (6.25% від кількості піксельних пікселів). Це має найнижчі вимоги GPU.

ViewportSDFScale VIEWPORT_SDF_SCALE_MAX = 3

Представляє розмір ViewportSDFScale enum.

enum ViewportMSAA: 🔗

ViewportMSAA VIEWPORT_MSAA_DISABLED = 0

Multisample antialiasing для 3D вимкнено. Це значення за замовчуванням, а також найшвидше налаштування.

ViewportMSAA VIEWPORT_MSAA_2X = 1

Multisample antialiasing використовує 2 зразки на піксель для 3D. Це має помірний вплив на продуктивність.

ViewportMSAA VIEWPORT_MSAA_4X = 2

Multisample antialiasing використовує 4 зразки на піксель для 3D. Це має високий вплив на продуктивність.

ViewportMSAA VIEWPORT_MSAA_8X = 3

Multisample antialiasing використовує 8 зразків на піксель для 3D. Це має дуже високий вплив на продуктивність. По-справжньому не підтримується на низькому і старшому апараті.

ViewportMSAA VIEWPORT_MSAA_MAX = 4

Представляємо розмір ViewportMSAA enum.

enum ViewportAnisotropicFiltering: 🔗

ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_DISABLED = 0

Анізотропна фільтрація вимкнена.

ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_2X = 1

Використовуйте 2× анізотропну фільтрацію.

ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_4X = 2

Використовуйте 4× анізотропну фільтрацію. Це значення за умовчанням.

ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_8X = 3

Використовуйте анізотропну фільтрацію 8×.

ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_16X = 4

Використовуйте анізотропну фільтрацію 16×.

ViewportAnisotropicFiltering VIEWPORT_ANISOTROPY_MAX = 5

Представляє розмір переліку ViewportAnisotropicFiltering.

enum ViewportScreenSpaceAA: 🔗

ViewportScreenSpaceAA VIEWPORT_SCREEN_SPACE_AA_DISABLED = 0

Не виконує будь-які антиалії в повному екрані після обробки.

ViewportScreenSpaceAA VIEWPORT_SCREEN_SPACE_AA_FXAA = 1

Використовуйте швидкий приблизний антиалії. FXAA - популярний метод антиалюзування екрану, який швидко, але зробить образ розмитим, особливо на нижніх роздільних розв'язках. Він ще може працювати відносно добре при великих роздільних рішеннях, таких як 1440p і 4K.

ViewportScreenSpaceAA VIEWPORT_SCREEN_SPACE_AA_SMAA = 2

Використовуйте субпіксельне морфологічне згладжування. SMAA може давати чіткіші результати, ніж FXAA, але з дещо вищими витратами на продуктивність.

ViewportScreenSpaceAA VIEWPORT_SCREEN_SPACE_AA_MAX = 3

Представляємо розмір ViewportScreenSpaceAA enum.

enum ViewportOcclusionCullingBuildQuality: 🔗

ViewportOcclusionCullingBuildQuality VIEWPORT_OCCLUSION_BUILD_QUALITY_LOW = 0

Низька оклюзія BVH якість збірки (як визначено Embree). Результати в найнижчому використанні процесора, але найменш ефективній кульлінгі.

ViewportOcclusionCullingBuildQuality VIEWPORT_OCCLUSION_BUILD_QUALITY_MEDIUM = 1

Середня оклюзія культовий BVH якість збірки (як визначено Embree).

ViewportOcclusionCullingBuildQuality VIEWPORT_OCCLUSION_BUILD_QUALITY_HIGH = 2

Висока оклюзійна кулькова BVH якість збірки (як визначено Embree). Результати у найбільшому використанні процесора, але найефективніше вирощування.

enum ViewportRenderInfo: 🔗

ViewportRenderInfo VIEWPORT_RENDER_INFO_OBJECTS_IN_FRAME = 0

Кількість об'єктів, намальованих в одному каркасі.

ViewportRenderInfo VIEWPORT_RENDER_INFO_PRIMITIVES_IN_FRAME = 1

Кількість точок, ліній, або трикутників, складених в одному каркасі.

ViewportRenderInfo VIEWPORT_RENDER_INFO_DRAW_CALLS_IN_FRAME = 2

Кількість висувних дзвінків під час цієї рами.

ViewportRenderInfo VIEWPORT_RENDER_INFO_MAX = 3

Представляємо розмір ViewportRenderInfo enum.

enum ViewportRenderInfoType: 🔗

ViewportRenderInfoType VIEWPORT_RENDER_INFO_TYPE_VISIBLE = 0

Передача в'язаного рендеру (за винятком тіней).

ViewportRenderInfoType VIEWPORT_RENDER_INFO_TYPE_SHADOW = 1

Shadow рендер. Об'єкти будуть надані кілька разів залежно від кількості вогнів з тіні та кількості спрямованих тіней.

ViewportRenderInfoType VIEWPORT_RENDER_INFO_TYPE_CANVAS = 2

Накладка канва. Це включає в себе всі 2D рендеринг.

ViewportRenderInfoType VIEWPORT_RENDER_INFO_TYPE_MAX = 3

Представляємо розмір ViewportRenderInfoType enum.

enum ViewportDebugDraw: 🔗

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_DISABLED = 0

Вимкнення Debug вимкнено. Налаштування за замовчуванням.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_UNSHADED = 1

Об'єкти відображаються без легкої інформації.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_LIGHTING = 2

Об'єкти відображаються лише з інформацією про світло.

Примітка: Під час використання цього режиму налагоджувального малювання користувацькі шейдери ігноруються, оскільки всі матеріали в сцені тимчасово використовують налагоджувальний матеріал. Це означає, що результат від функцій користувацьких шейдерів (таких як зміщення вершин) більше не буде видимим під час використання цього режиму налагоджувального малювання.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_OVERDRAW = 3

Об'єкти відображаються напівпрозорими з адитивним змішуванням, щоб ви могли бачити, де вони малюються один поверх одного. Більше перекриття (представлене яскравішими кольорами) означає, що ви витрачаєте продуктивність на малювання пікселів, які приховані за іншими.

Примітка: Під час використання цього режиму малювання налагодження користувацькі шейдери ігноруються, оскільки всі матеріали в сцені тимчасово використовують налагоджувальний матеріал. Це означає, що результат від функцій користувацьких шейдерів (таких як зміщення вершин) більше не буде видимим під час використання цього режиму малювання налагодження.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_WIREFRAME = 4

Налагодження малювання малює об’єкти в каркасі.

Примітка: set_debug_generate_wireframes() має бути викликаний перед завантаженням будь-яких сіток, щоб каркаси були видимими під час використання інструменту відтворення сумісності.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_NORMAL_BUFFER = 5

Нормальний буфер тягнеться замість звичайної сцени, так що ви можете бачити нормалі перпікселів, які будуть використані після обробки ефектів.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_VOXEL_GI_ALBEDO = 6

Об'єкти відображаються лише зі значенням альбедо з VoxelGI. Потрібен принаймні один видимий вузол VoxelGI, який був запечений, щоб мати видимий ефект.

Примітка: Підтримується лише під час використання методу рендерингу Forward+.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_VOXEL_GI_LIGHTING = 7

Об'єкти відображаються лише зі значенням освітлення з VoxelGI. Потрібен принаймні один видимий вузол VoxelGI, який був запечений, щоб мати видимий ефект.

Примітка: Підтримується лише під час використання методу рендерингу Forward+.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_VOXEL_GI_EMISSION = 8

Об'єкти відображаються лише з кольором випромінювання з VoxelGI. Потрібен принаймні один видимий вузол VoxelGI, який був запечений, щоб мати видимий ефект.

Примітка: Підтримується лише під час використання методу рендерингу Forward+.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SHADOW_ATLAS = 9

Накладає тіньову накладку, яка зберігає тіні з OmniLight3D і SpotLight3D у верхній лівій квадранті Viewport.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_DIRECTIONAL_SHADOW_ATLAS = 10

Накладає тіньову накладку, яка зберігає тіні з DirectionalLight3D у верхній лівій квадранті Viewport.

Нарізка камери фрусту, пов'язаної з каскадом shadow map, накладається для візуалізації покриття. Колір кожного скибочка відповідає кольору, що використовуються для VIEWPORT_DEBUG_DRAW_PSSM_SPLITS. Коли тіні каскади розбавляють перекриття, враховують при намальовуванні скибочок фрусту.

Останній каскад показує всі скибочки з фруктами, щоб ілюструвати покриття всіх скибочок.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SCENE_LUMINANCE = 11

Малює приблизну яскравість сцени. Це текстура 1×1, яка генерується, коли ввімкнено автоматичну експозицію для керування експозицією сцени.

Примітка: Підтримується лише під час використання методів рендерингу Forward+ або Mobile.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SSAO = 12

Малює текстуру ambient occlusion у просторі екрана замість сцени, щоб ви могли чітко бачити, як вона впливає на об'єкти. Щоб цей режим відображення працював, у вашому WorldEnvironment має бути встановлено параметр Environment.ssao_enabled.

Примітка: Підтримується лише під час використання методу рендерингу Forward+.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SSIL = 13

Малює текстуру непрямого освітлення простору екрана замість сцени, щоб ви могли чітко бачити, як вона впливає на об'єкти. Щоб цей режим відображення працював, у вашому WorldEnvironment має бути встановлено параметр Environment.ssil_enabled.

Примітка: Підтримується лише під час використання методу рендерингу Forward+.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_PSSM_SPLITS = 14

Забарвлює кожен розкол PSSM для DirectionalLight3D у сцені в інший колір, щоб ви могли бачити, де знаходяться розколи. По порядку (від найближчого до найдальшого від камери) вони забарвлюються в червоний, зелений, синій та жовтий кольори.

Примітка: Під час використання цього режиму малювання налагодження користувацькі шейдери ігноруються, оскільки всі матеріали в сцені тимчасово використовують налагоджувальний матеріал. Це означає, що результат від функцій користувацьких шейдерів (таких як зміщення вершин) більше не буде видно під час використання цього режиму малювання налагодження.

Примітка: Підтримується лише під час використання методів рендерингу Forward+ або Mobile.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_DECAL_ATLAS = 15

Малює атлас декалів, який зберігає текстури декалів з Decal.

Примітка: Підтримується лише під час використання методів рендерингу Forward+ або Mobile.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SDFGI = 16

Малює каскадні дані SDFGI. Це структура даних, яка використовується для відбиття освітлення та створення відблисків.

Примітка: Підтримується лише при використанні методу рендерингу Forward+.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_SDFGI_PROBES = 17

Малює дані зонда SDFGI. Це структура даних, яка використовується для створення динамічних об'єктів непрямого освітлення, що рухаються в сцені.

Примітка: Підтримується лише при використанні методу рендерингу Forward+.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_GI_BUFFER = 18

Малює глобальний буфер освітлення з VoxelGI або SDFGI. Для видимого ефекту потрібно ввімкнути VoxelGI (принаймні один видимий запечений вузол VoxelGI) або SDFGI (Environment.sdfgi_enabled).

Примітка: Підтримується лише під час використання методу рендерингу Forward+.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_DISABLE_LOD = 19

Сітчаста сітка LOD. Всі сітки натяжуються повною деталлю, яку можна використовувати для порівняння продуктивності.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_CLUSTER_OMNI_LIGHTS = 20

Малює кластер OmniLight3D. Кластеризація визначає розташування джерел світла в екранному просторі, що дозволяє движку обробляти лише ці частини екрана для освітлення.

Примітка: Підтримується лише при використанні методу рендерингу Forward+.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_CLUSTER_SPOT_LIGHTS = 21

Малює кластер SpotLight3D. Кластеризація визначає розташування джерел світла в просторі екрана, що дозволяє движку обробляти лише ці частини екрана для освітлення.

Примітка: Підтримується лише при використанні методу рендерингу Forward+.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_CLUSTER_DECALS = 22

Малює кластер Decal. Кластеризація визначає, де розташовані декалі в екранному просторі, що дозволяє движку обробляти лише ці частини екрана для декалів.

Примітка: Підтримується лише при використанні методу рендерингу Forward+.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_CLUSTER_REFLECTION_PROBES = 23

Малює кластер ReflectionProbe. Кластеризація визначає, де розташовані зонди відбиття в екранному просторі, що дозволяє рушію обробляти лише ці частини екрана для зондів відбиття.

Примітка: Підтримується лише при використанні методу рендерингу Forward+.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_OCCLUDERS = 24

Малює буфер відсіювання перекриття. Цей буфер відсіювання перекриття з низькою роздільною здатністю растеризується на процесорі та використовується для перевірки, чи екземпляри перекриваються іншими об'єктами.

Примітка: Підтримується лише під час використання методів рендерингу Forward+ або Mobile.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_MOTION_VECTORS = 25

Малює буфер векторів руху. Використовується тимчасовим згладжуванням для корекції руху, що відбувається під час гри.

Примітка: Підтримується лише при використанні методу рендерингу Forward+.

ViewportDebugDraw VIEWPORT_DEBUG_DRAW_INTERNAL_BUFFER = 26

Замість звичайної сцени відображається внутрішній буфер, щоб ви могли бачити попіксельний вивід, який буде використано ефектами постобробки.

Примітка: Підтримується лише під час використання методів рендерингу Forward+ або Mobile.

enum ViewportVRSMode: 🔗

ViewportVRSMode VIEWPORT_VRS_DISABLED = 0

Вимкнено різну форму ставок.

ViewportVRSMode VIEWPORT_VRS_TEXTURE = 1

Варіабельна обробка швидкості використовує фактуру. Примітка, для стереоскопічного використання текстури атласу з текстурою для кожного виду.

ViewportVRSMode VIEWPORT_VRS_XR = 2

Варіабельна текстура шліфування подається первинною XRInterface. Зверніть увагу, що це може перевизначити режим оновлення.

ViewportVRSMode VIEWPORT_VRS_MAX = 3

Представляємо розмір ViewportVRSMode enum.

enum ViewportVRSUpdateMode: 🔗

ViewportVRSUpdateMode VIEWPORT_VRS_UPDATE_DISABLED = 0

Введення текстури для змінного струму не буде оброблятися.

ViewportVRSUpdateMode VIEWPORT_VRS_UPDATE_ONCE = 1

Введення текстури для змінного струму буде оброблятися один раз.

ViewportVRSUpdateMode VIEWPORT_VRS_UPDATE_ALWAYS = 2

Вводна текстура для змінного струму обробка буде оброблятися кожен каркас.

ViewportVRSUpdateMode VIEWPORT_VRS_UPDATE_MAX = 3

Представляє розмір ViewportVRSUpdateMode enum.

enum SkyMode: 🔗

SkyMode SKY_MODE_AUTOMATIC = 0

Автоматично вибирає відповідний режим процесу на основі вашого шейрака неба. Якщо ваш шейдер використовує TIME або POSITION ``, це буде використовуватися :ref:`SKY_MODE_REALTIME<class_RenderingServer_constant_SKY_MODE_REALTIME>`. Якщо ваш шейдер використовує будь-яку з ``LIGHT_* змінних або будь-яких спеціальних уніформ, це використовує SKY_MODE_INCREMENTAL. В іншому випадку це за замовчуванням SKY_MODE_QUALITY.

SkyMode SKY_MODE_QUALITY = 1

Використовує якісне значення вибірки для обробки карти променевості. В цілому, це призводить до значно більш високої якості, ніж SKY_MODE_REALTIME але займає набагато довше, щоб генерувати. Якщо ви плануєте змінити небо в режимі runtime. Якщо ви знаходилися, що відбиття недостатньо розмитне і показує блиск або пожежі, спробуйте збільшити ProjectSettings.rendering/reflections/sky_reflections/ggx_samples.

SkyMode SKY_MODE_INCREMENTAL = 2

Використовуйте те ж саме високу якість, що важливо для обробки карти променевості, як SKY_MODE_QUALITY, але оновлення декількох кадрів. Кількість кадрів визначається ProjectSettings.rendering/reflections/sky_reflections/roughness_layers. Використовуйте це, коли вам потрібна найвища якість випромінювальних карт, але мають небо, яке повільно оновлюється.

SkyMode SKY_MODE_REALTIME = 3

Використовуйте алгоритм швидкого фільтрування для обробки карти променевості. В цілому це призводить до низької якості, але значно швидше часу запуску. Якщо вам потрібна краща якість, але все ще потрібно оновити небо кожного кадру, розгляньте поворот на ProjectSettings.rendering/reflections/sky_reflections/fast_filter_high_quality.

Примітка: Швидке алгоритм фільтрування обмежується 256 × 256 кубиками, тому sky_set_radiance_size() необхідно встановити до 256. Інакше, попередження друкується і ігнорується розмір випромінювача.

enum CompositorEffectFlags: 🔗

CompositorEffectFlags COMPOSITOR_EFFECT_FLAG_ACCESS_RESOLVED_COLOR = 1

Ефект рендерингу вимагає від колірного буфера, щоб бути вирішеним, якщо увімкнено MSAA.

CompositorEffectFlags COMPOSITOR_EFFECT_FLAG_ACCESS_RESOLVED_DEPTH = 2

Ефект рендерингу вимагає глибинного буфера, щоб бути вирішеним, якщо увімкнено MSAA.

CompositorEffectFlags COMPOSITOR_EFFECT_FLAG_NEEDS_MOTION_VECTORS = 4

Ефект рендерингу вимагає векторів руху.

CompositorEffectFlags COMPOSITOR_EFFECT_FLAG_NEEDS_ROUGHNESS = 8

Ефект рендерингу вимагає норм і шорсткості g-буфера, щоб бути виготовлений (тільки для +).

CompositorEffectFlags COMPOSITOR_EFFECT_FLAG_NEEDS_SEPARATE_SPECULAR = 16

Ефект рендерингу вимагає відокремити дзеркальні дані (вперед+ тільки).

enum CompositorEffectCallbackType: 🔗

CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_PRE_OPAQUE = 0

Зворотній зв'язок називається перед нашим непрозорим рендерингом, але після проходу глибини (за наявності).

CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_POST_OPAQUE = 1

Зворотній зв'язок називається після того, як наш непрозорий рендеринг, але перед нашим небом продається.

CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_POST_SKY = 2

Зворотній зв'язок називається після того, як наш небо буде продано, але перед нашими задньими буферами створюються (і якщо увімкнено, перед розсіюванням та/або відображенням простору екрану).

CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_PRE_TRANSPARENT = 3

Зворотній зв'язок називається перед нашим прозорим рендеринговим пасом, але після того, як наш небо продається, і ми створили наші задні буфери.

CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_POST_TRANSPARENT = 4

Зворотний виклик викликається після нашого проходу прозорого рендерингу, але перед будь-якими вбудованими ефектами постобробки та виведенням на нашу ціль візуалізації.

CompositorEffectCallbackType COMPOSITOR_EFFECT_CALLBACK_TYPE_ANY = -1

There is currently no description for this enum. Please help us by contributing one!

enum EnvironmentBG: 🔗

EnvironmentBG ENV_BG_CLEAR_COLOR = 0

Використовуйте чіткий колір як фон.

EnvironmentBG ENV_BG_COLOR = 1

Використовуйте зазначений колір як фон.

EnvironmentBG ENV_BG_SKY = 2

Використовуйте небо ресурс для фону.

EnvironmentBG ENV_BG_CANVAS = 3

Використовуйте зазначений шар полотна як фон. Це може бути корисним для миттєвого використання 2D сцени в світі 3D.

EnvironmentBG ENV_BG_KEEP = 4

Не очистіть фон, скористайтеся тим, що був рендерований останній кадр як фон.

EnvironmentBG ENV_BG_CAMERA_FEED = 5

Відображення камери живлення на фоні.

EnvironmentBG ENV_BG_MAX = 6

Представляємо розмір EnvironmentBG enum.

enum EnvironmentAmbientSource: 🔗

EnvironmentAmbientSource ENV_AMBIENT_SOURCE_BG = 0

Зберігайте навколишнє світло, з якого джерела вказано як фон.

EnvironmentAmbientSource ENV_AMBIENT_SOURCE_DISABLED = 1

Вимкнений світло навколишнього середовища.

EnvironmentAmbientSource ENV_AMBIENT_SOURCE_COLOR = 2

Вкажіть конкретну Color для навколишнього світла.

EnvironmentAmbientSource ENV_AMBIENT_SOURCE_SKY = 3

Збирайте розсіяне світло з Sky незалежно від фону.

enum EnvironmentReflectionSource: 🔗

EnvironmentReflectionSource ENV_REFLECTION_SOURCE_BG = 0

Використовуйте фон для відображення.

EnvironmentReflectionSource ENV_REFLECTION_SOURCE_DISABLED = 1

Вимкнути відбиття.

EnvironmentReflectionSource ENV_REFLECTION_SOURCE_SKY = 2

Використовуйте Sky для відображення незалежно від того, що фон є.

enum EnvironmentGlowBlendMode: 🔗

EnvironmentGlowBlendMode ENV_GLOW_BLEND_MODE_ADDITIVE = 0

Адитивний режим блендера glow. В основному використовується для частинок, світлих (блюм), лінз, світлих джерел.

EnvironmentGlowBlendMode ENV_GLOW_BLEND_MODE_SCREEN = 1

Режим блендера екрана. Підвищує яскравість, часто використовується з цвітінням.

EnvironmentGlowBlendMode ENV_GLOW_BLEND_MODE_SOFTLIGHT = 2

Режим м'якого світла світіння. Модифікує контрастність, виводить тіні і родзинки (вітане цвітіння).

EnvironmentGlowBlendMode ENV_GLOW_BLEND_MODE_REPLACE = 3

Замініть режим блендера glow. Замінює всі кольори пікселів за значенням світіння. Це може бути використаний для імітації повноекранного ефекту розмиття шляхом відбиття параметрів світіння, щоб відповідати оригінальному яскравості зображення.

EnvironmentGlowBlendMode ENV_GLOW_BLEND_MODE_MIX = 4

Змішує світанку з основним кольором, щоб уникнути збільшення яскравості стільки ж, поки ще не підтримує ефект світіння.

enum EnvironmentFogMode: 🔗

EnvironmentFogMode ENV_FOG_MODE_EXPONENTIAL = 0

Використовуйте фізичну модель фольга, визначену в першу чергу щільністю корму.

EnvironmentFogMode ENV_FOG_MODE_DEPTH = 1

Використовуйте просту модель, визначену початковими та кінцевими позиціями та користувацькою кривою. У той час як не фізично точна, ця модель може бути корисною, коли вам потрібно більше художнього контролю.

enum EnvironmentToneMapper: 🔗

EnvironmentToneMapper ENV_TONE_MAPPER_LINEAR = 0

Не змінює колірні дані, що призводить до лінійної кривої відображення тонів, яка неприродно відсікає яскраві значення, через що яскраве освітлення виглядає тьмяним. Найпростіший і найшвидший тональний картограф.

EnvironmentToneMapper ENV_TONE_MAPPER_REINHARD = 1

Проста крива відображення тону, яка зменшує яскраві значення, щоб запобігти відсіканню. Це призводить до того, що зображення може виглядати тьмяним і низькоконтрастним. Повільніше, ніж ENV_TONE_MAPPER_LINEAR.

Примітка. Якщо Environment.tonemap_white залишити значенням за замовчуванням 1.0, ENV_TONE_MAPPER_REINHARD створює зображення, ідентичне ENV_TONE_MAPPER_LINEAR.

EnvironmentToneMapper ENV_TONE_MAPPER_FILMIC = 2

Використовує плівкову криву відображення тонів, щоб запобігти відсіканню яскравих значень і забезпечити кращий контраст, ніж ENV_TONE_MAPPER_REINHARD. Трохи повільніше, ніж ENV_TONE_MAPPER_REINHARD.

EnvironmentToneMapper ENV_TONE_MAPPER_ACES = 3

Використовує висококонтрастну криву відтворення тонів, подібну до плівки, і зменшує насиченість яскравих значень для більш реалістичного вигляду. Трохи повільніше, ніж ENV_TONE_MAPPER_FILMIC.

**Примітка: ** Цей оператор тонального відображення називається «ACES Fitted» у Godot 3.x.

EnvironmentToneMapper ENV_TONE_MAPPER_AGX = 4

Використовує плівкову криву відображення тонів і зменшує насиченість яскравих значень для більш реалістичного вигляду. Краще, ніж інші картографи тонів, підтримує відтінок кольорів, коли вони стають яскравішими. Найповільніший варіант тонального відображення.

Примітка. Environment.tonemap_white має значення 16.29, що робить ENV_TONE_MAPPER_AGX непридатною для використання з методом візуалізації Mobile.

enum EnvironmentSSRRoughnessQuality: 🔗

EnvironmentSSRRoughnessQuality ENV_SSR_ROUGHNESS_QUALITY_DISABLED = 0

Найменша якість шорсткості фільтра для відображення екранів. Грубий матеріал не має розмитих екранно-космічних відбиттях порівняно з гладкими (не грубими) матеріалами. Це найшвидший варіант.

EnvironmentSSRRoughnessQuality ENV_SSR_ROUGHNESS_QUALITY_LOW = 1

Низька якість шорсткості фільтра для відображення екранів.

EnvironmentSSRRoughnessQuality ENV_SSR_ROUGHNESS_QUALITY_MEDIUM = 2

Середня якість шорсткості фільтра для відображення екранів.

EnvironmentSSRRoughnessQuality ENV_SSR_ROUGHNESS_QUALITY_HIGH = 3

Висока якість шорсткості фільтра для відображення екранів. Це найшвидший варіант.

enum EnvironmentSSAOQuality: 🔗

EnvironmentSSAOQuality ENV_SSAO_QUALITY_VERY_LOW = 0

Найменша якість прикусу екрану.

EnvironmentSSAOQuality ENV_SSAO_QUALITY_LOW = 1

Низька якість екрана-космічна оклюзія.

EnvironmentSSAOQuality ENV_SSAO_QUALITY_MEDIUM = 2

Середня якість екрана-космічна оклюзія.

EnvironmentSSAOQuality ENV_SSAO_QUALITY_HIGH = 3

Висока якість екрана-космічної неоднозначності.

EnvironmentSSAOQuality ENV_SSAO_QUALITY_ULTRA = 4

Найвища якість екрана-космічна оклюзія. Використовує адаптивну цільову настройку, яка може бути динамічно налаштована для безперебійного балансу та візуальної якості.

enum EnvironmentSSILQuality: 🔗

EnvironmentSSILQuality ENV_SSIL_QUALITY_VERY_LOW = 0

Найменша якість екранно-просторового непрямого освітлення.

EnvironmentSSILQuality ENV_SSIL_QUALITY_LOW = 1

Низька якість екрана-космічного непрямого освітлення.

EnvironmentSSILQuality ENV_SSIL_QUALITY_MEDIUM = 2

Висока якість екрана-космічного непрямого освітлення.

EnvironmentSSILQuality ENV_SSIL_QUALITY_HIGH = 3

Висока якість екрана-космічного непрямого освітлення.

EnvironmentSSILQuality ENV_SSIL_QUALITY_ULTRA = 4

Найвища якість екрана-космічного непрямого освітлення. Використовує адаптивну цільову настройку, яка може бути динамічно налаштована для безперебійного балансу та візуальної якості.

enum EnvironmentSDFGIYScale: 🔗

EnvironmentSDFGIYScale ENV_SDFGI_Y_SCALE_50_PERCENT = 0

Використовуйте 50% ваги для SDFGI на осі Y (вертикальний) СДФГ клітини будуть двічі як короткі, так як вони широкі. Це дозволяє збільшити деталі GI і зменшити протікання світла з тонкими підлогами і стельами. Це, як правило, найкращий вибір для сцен, які не мають особливо вертикальності.

EnvironmentSDFGIYScale ENV_SDFGI_Y_SCALE_75_PERCENT = 1

Використовуйте 75% ваги для SDFGI на осі Y (вертикальний) Це баланс між 50% і 100% SDFGI Y масштабами.

EnvironmentSDFGIYScale ENV_SDFGI_Y_SCALE_100_PERCENT = 2

Використання 100% ваги для SDFGI на осі Y (вертикальний) Y. СДФГ клітини будуть максимально високими, оскільки вони широкі. Це, як правило, найкращий вибір для високотемпературних сцен. Знизу є те, що світлове витікання може стати більш помітним з тонкими підлогами і стельами.

enum EnvironmentSDFGIRayCount: 🔗

EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_4 = 0

Посунути 4 промені за кадром при схрещуванні SDFGI. Це має найнижчі вимоги GPU, але створює найбільш гучний результат.

EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_8 = 1

Посунути 8 променів за кадром при схрещуванні SDFGI.

EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_16 = 2

Посунути 16 променів за кадром при схрещуванні SDFGI.

EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_32 = 3

Посунути 32 промені за кадром при схрещуванні SDFGI.

EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_64 = 4

Посунути 64 промені за кадром при схрещуванні SDFGI.

EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_96 = 5

Засувка 96 променів за кадром при стику SDFGI. Це має високі вимоги GPU.

EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_128 = 6

Посунути 128 променів за кадром при схрещуванні SDFGI. Це має дуже високі вимоги GPU, але створює найменший результат.

EnvironmentSDFGIRayCount ENV_SDFGI_RAY_COUNT_MAX = 7

Представляємо розмір EnvironmentSDFGIRayCount enum.

enum EnvironmentSDFGIFramesToConverge: 🔗

EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_5_FRAMES = 0

Converge SDFGI понад 5 кадрів. Це найвідповідальніший, але створює найбільш гучний результат з урахуванням даної кількості променів.

EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_10_FRAMES = 1

Налаштування SDFGI повністю конвержувати понад 10 кадрів.

EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_15_FRAMES = 2

Налаштування SDFGI повністю конвержувати понад 15 кадрів.

EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_20_FRAMES = 3

Налаштування SDFGI повністю конвержувати понад 20 кадрів.

EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_25_FRAMES = 4

Налаштування SDFGI повністю конвержувати понад 25 кадрів.

EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_IN_30_FRAMES = 5

Налаштування SDFGI повністю конвержувати понад 30 кадрів. Це найменший чуйний, але створює найменший результат з урахуванням променів.

EnvironmentSDFGIFramesToConverge ENV_SDFGI_CONVERGE_MAX = 6

Представляємо розмір EnvironmentSDFGIFramesToConverge enum.

enum EnvironmentSDFGIFramesToUpdateLight: 🔗

EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_IN_1_FRAME = 0

Оновлення непрямого світла від динамічних вогнів в SDFGI понад 1 кадр. Це найбільш відповідальний, але має найвищі вимоги до GPU.

EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_IN_2_FRAMES = 1

Оновлення непрямого світла з динамічних вогнів в SDFGI понад 2 кадри.

EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_IN_4_FRAMES = 2

Оновлення непрямого світла від динамічних вогнів в SDFGI понад 4 кадри.

EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_IN_8_FRAMES = 3

Оновлення непрямого світла від динамічних вогнів в SDFGI понад 8 кадрів.

EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_IN_16_FRAMES = 4

Оновлення непрямого світла з динамічних вогнів в SDFGI понад 16 кадрів. Це найменш чуйний, але має найнижчі вимоги GPU.

EnvironmentSDFGIFramesToUpdateLight ENV_SDFGI_UPDATE_LIGHT_MAX = 5

Представляємо розмір EnvironmentSDFGIFramesToUpdateLight enum.

enum SubSurfaceScatteringQuality: 🔗

SubSurfaceScatteringQuality SUB_SURFACE_SCATTERING_QUALITY_DISABLED = 0

Повністю вимикає підповерхневе розсіювання, навіть на матеріалах, для яких BaseMaterial3D.subsurf_scatter_enabled встановлено значення true. Це має найнижчі вимоги до графічного процесора.

SubSurfaceScatteringQuality SUB_SURFACE_SCATTERING_QUALITY_LOW = 1

Низька якість розсіювання під тиском.

SubSurfaceScatteringQuality SUB_SURFACE_SCATTERING_QUALITY_MEDIUM = 2

Середня якість підсерфінгу.

SubSurfaceScatteringQuality SUB_SURFACE_SCATTERING_QUALITY_HIGH = 3

Висока якість розсіювання поверхневих поверхонь. Це має найвищі вимоги до GPU.

enum DOFBokehShape: 🔗

DOFBokehShape DOF_BOKEH_BOX = 0

Розрахунок розмиття DOF за допомогою фільтра коробки. Найшвидший варіант, але результати в явних лініях у шаблоні розмиття.

DOFBokehShape DOF_BOKEH_HEXAGON = 1

Розрахунок розмиття DOF за допомогою шестигранної форми фільтра.

DOFBokehShape DOF_BOKEH_CIRCLE = 2

Розрахунок розмиття DOF за допомогою колоподібного фільтра. Найкраща якість і найбільш реалістична, але повільна. Використовуйте тільки для ділянок, де можна приділити багато виступів для постобробки (наприклад, зрізи).

enum DOFBlurQuality: 🔗

DOFBlurQuality DOF_BLUR_QUALITY_VERY_LOW = 0

Найменша якість DOF розмиття. Це найшвидше налаштування, але ви можете бачити фільтруючі артефакти.

DOFBlurQuality DOF_BLUR_QUALITY_LOW = 1

Низька якість DOF розмиття.

DOFBlurQuality DOF_BLUR_QUALITY_MEDIUM = 2

Середня якість DOF розмиття.

DOFBlurQuality DOF_BLUR_QUALITY_HIGH = 3

Найвища якість DOF розмиття. Результати в плавному пошуку розмиття, виходячи з більшості зразків, але також значно уповільнюється.

enum InstanceType: 🔗

InstanceType INSTANCE_NONE = 0

Не має типу.

InstanceType INSTANCE_MESH = 1

Приклад сітки.

InstanceType INSTANCE_MULTIMESH = 2

Наприклад, багатомеш.

InstanceType INSTANCE_PARTICLES = 3

Екземпляр є випромінювачем частинок.

InstanceType INSTANCE_PARTICLES_COLLISION = 4

Екземпляр - форма зіткнення GPUPaarticle.

InstanceType INSTANCE_LIGHT = 5

Приклад легкий.

InstanceType INSTANCE_REFLECTION_PROBE = 6

Приклад – це відбиття.

InstanceType INSTANCE_DECAL = 7

Наприклад, декаль.

InstanceType INSTANCE_VOXEL_GI = 8

Воксельгі.

InstanceType INSTANCE_LIGHTMAP = 9

Приклад - легкий варіант.

InstanceType INSTANCE_OCCLUDER = 10

Наприклад, є оклюзійним елементом.

InstanceType INSTANCE_VISIBLITY_NOTIFIER = 11

Приклад є видимим на екрані.

InstanceType INSTANCE_FOG_VOLUME = 12

Приклад є об'ємом фольгу.

InstanceType INSTANCE_MAX = 13

Представляємо розмір InstanceType enum.

InstanceType INSTANCE_GEOMETRY_MASK = 14

Поєднання прапорів геометрійних екземплярів (меш, м'якоть, безпосередні і частинки).

enum InstanceFlags: 🔗

InstanceFlags INSTANCE_FLAG_USE_BAKED_LIGHT = 0

Дозволяє використовувати екземпляр в запеченому освітленні.

InstanceFlags INSTANCE_FLAG_USE_DYNAMIC_GI = 1

Дозволяє використовувати екземпляр з динамічним глобальним освітленням.

InstanceFlags INSTANCE_FLAG_DRAW_NEXT_FRAME_IF_VISIBLE = 2

При налаштуванні вручну запити на малювати геометрію на наступному кадрі.

InstanceFlags INSTANCE_FLAG_IGNORE_OCCLUSION_CULLING = 3

Завжди малювати, навіть якщо екземпляр буде культивований оклюзією. Чи не впливає на перегляд фрусту.

InstanceFlags INSTANCE_FLAG_MAX = 4

Представляємо розмір InstanceFlags enum.

enum ShadowCastingSetting: 🔗

ShadowCastingSetting SHADOW_CASTING_SETTING_OFF = 0

Вимкнені тіні з цього екземпляра.

ShadowCastingSetting SHADOW_CASTING_SETTING_ON = 1

Виконайте тіні з цього екземпляра.

ShadowCastingSetting SHADOW_CASTING_SETTING_DOUBLE_SIDED = 2

Вимкнено підкладку під час надання тіні об'єкта. Це трохи повільніше, але може призвести до більш правильної тіні.

ShadowCastingSetting SHADOW_CASTING_SETTING_SHADOWS_ONLY = 3

Тільки надають тіні з об'єкта. Сам об'єкт не буде намальований.

enum VisibilityRangeFadeMode: 🔗

VisibilityRangeFadeMode VISIBILITY_RANGE_FADE_DISABLED = 0

Вимкнений діапазон видимості для даного екземпляра.

VisibilityRangeFadeMode VISIBILITY_RANGE_FADE_SELF = 1

Зазначте дану інстанцію, коли вона підійме її межі видимості.

VisibilityRangeFadeMode VISIBILITY_RANGE_FADE_DEPENDENCIES = 2

У залежності від вказаного екземпляра при досягненні його межі видимості.

enum BakeChannels: 🔗

BakeChannels BAKE_CHANNEL_ALBEDO_ALPHA = 0

Індекс Image в масиві Image повернуто bake_render_uv2(). Зображення використовує Image. FORMAT_RGBA8 і містить колір альбедо в .rgb канали і альфа в каналі .a.

BakeChannels BAKE_CHANNEL_NORMAL = 1

Індекс Image в масиві Image повернуто bake_render_uv2(). Зображення використовує Image. FORMAT_RGBA8 і містить перпіксельний норма об'єкта в каналі .rgb і нічого в каналі .a. Нормальний перпіксельний кодований як нормальний * 0.5 + 0.5.

BakeChannels BAKE_CHANNEL_ORM = 2

Індекс Image в масиві Image повернуто bake_render_uv2(). Зображення використовує Image. FORMAT_RGBA8 і містить неоднорідну оклюзію (від матеріалів і декальцій тільки) в каналі .r, шорсткість в .g канал, металік в каналі .b і під поверхневе розсіювання кількості в .a канал.

BakeChannels BAKE_CHANNEL_EMISSION = 3

Індекс Image в масиві Image повернуто bake_render_uv2(). Зображення використовує Image. FORMAT_RGBAH і містить колір емісії в каналі .rgb і нічого в .a.

enum CanvasTextureChannel: 🔗

CanvasTextureChannel CANVAS_TEXTURE_CHANNEL_DIFFUSE = 0

Дифузна текстура полотна (CanvasTexture.diffuse_texture).

CanvasTextureChannel CANVAS_TEXTURE_CHANNEL_NORMAL = 1

Текстура полотна карти нормалей (CanvasTexture.normal_texture).

CanvasTextureChannel CANVAS_TEXTURE_CHANNEL_SPECULAR = 2

Характерна текстура полотна (CanvasTexture.specular_texture).

enum NinePatchAxisMode: 🔗

NinePatchAxisMode NINE_PATCH_STRETCH = 0

У дев'яти патчах простягається де потрібно.

NinePatchAxisMode NINE_PATCH_TILE = 1

На дев'ять патчах заповнюється плиткою, де потрібно.

NinePatchAxisMode NINE_PATCH_TILE_FIT = 2

На дев'ять патчах заповнюється плиткою, де потрібно і трохи розтягує.

enum CanvasItemTextureFilter: 🔗

CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_DEFAULT = 0

Використовуйте режим фільтра за замовчуванням для цього Перегляд.

CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_NEAREST = 1

Фільтр текстур читає лише з найближчого пікселя. Це робить текстуру піксельною зблизька та зернистою на відстані (через те, що MIP-карти не вибираються).

CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_LINEAR = 2

Фільтр текстури змішується між найближчими 4 пікселями. Це робить текстуру гладкою зблизька та зернистою на відстані (через те, що MIP-карти не вибираються).

CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS = 3

Фільтр текстур зчитує з найближчого пікселя та змішує між двома найближчими картами mipmap (або використовує найближчу карту mipmap, якщо ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter має значення true). Це робить текстуру піксельною зблизька та гладкою на відстані.

Використовуйте це для непіксельних текстур, які можна переглядати в низькому масштабі (наприклад, через масштабування Camera2D або масштабування спрайтів), оскільки міп-мапи важливі для згладжування пікселів, які менші за пікселі на екрані.

CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS = 4

Фільтр текстур змішує найближчі 4 пікселі з найближчими 2 картами mipmap (або використовує найближчу карту mipmap, якщо ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter має значення true). Це робить текстуру гладкою зблизька та гладкою на відстані.

Використовуйте це для непіксельних текстур, які можна переглядати в низькому масштабі (наприклад, через масштабування Camera2D або масштабування спрайтів), оскільки міп-мапи важливі для згладжування пікселів, які менші за пікселі на екрані.

CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC = 5

Текстурний фільтр зчитує дані з найближчого пікселя та змішує їх між двома міп-картами (або використовує найближчу міп-карту, якщо ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter має значення true) на основі кута між поверхнею та полем зору камери. Це робить текстуру пікселізованою зблизька та гладкою здалеку. Анізотропна фільтрація покращує якість текстури на поверхнях, які майже розташовані на одній лінії з камерою, але трохи повільніша. Рівень анізотропної фільтрації можна змінити, налаштувавши ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level.

Примітка: Цей текстурний фільтр рідко корисний у 2D-проектах. У цьому випадку зазвичай доречніше значення CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS.

CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC = 6

Текстурний фільтр змішує найближчі 4 пікселі та змішує 2 міпмапи (або використовує найближчу міпмапу, якщо ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter має значення true) на основі кута між поверхнею та полем зору камери. Це робить текстуру гладкою зблизька та гладкою здалеку. Анізотропна фільтрація покращує якість текстури на поверхнях, які майже розташовані на одній лінії з камерою, але трохи повільніша. Рівень анізотропної фільтрації можна змінити, налаштувавши ProjectSettings.rendering/textures/default_filters/anisotropic_filtering_level.

Примітка: Цей текстурний фільтр рідко корисний у 2D-проектах. У цьому випадку зазвичай доречніше значення CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS.

CanvasItemTextureFilter CANVAS_ITEM_TEXTURE_FILTER_MAX = 7

Макс значення для CanvasItemTextureFilter enum.

enum CanvasItemTextureRepeat: 🔗

CanvasItemTextureRepeat CANVAS_ITEM_TEXTURE_REPEAT_DEFAULT = 0

Використовує режим повторення за замовчуванням для цього Viewport.

CanvasItemTextureRepeat CANVAS_ITEM_TEXTURE_REPEAT_DISABLED = 1

Відключення текстур повторення. Замість, коли читання УФів за межі 0-1, значення буде затискати до краю текстури, що призводить до розтягування погляду на межі текстури.

CanvasItemTextureRepeat CANVAS_ITEM_TEXTURE_REPEAT_ENABLED = 2

Дозволяє повторювати текстуру, коли UV-координати виходять за межі діапазону 0-1. Якщо використовується один із лінійних режимів фільтрації, це може призвести до артефактів на краях текстури, коли семплер фільтрує по краях текстури.

CanvasItemTextureRepeat CANVAS_ITEM_TEXTURE_REPEAT_MIRROR = 3

Закріпіть текстуру при повторенні так, щоб крайові лінії не змінилися.

CanvasItemTextureRepeat CANVAS_ITEM_TEXTURE_REPEAT_MAX = 4

Макс значення для CanvasItemTextureRepeat enum.

enum CanvasGroupMode: 🔗

CanvasGroupMode CANVAS_GROUP_MODE_DISABLED = 0

Дитина малює над батьком і не обрізається.

CanvasGroupMode CANVAS_GROUP_MODE_CLIP_ONLY = 1

Батьківський елемент використовується лише для вирізання. Дочірній елемент прикріплений до видимої області батька, батько не намальований.

CanvasGroupMode CANVAS_GROUP_MODE_CLIP_AND_DRAW = 2

Батьківський елемент використовується для відсікання дочірнього елемента, але перед відсіканням дочірнього елемента до його видимої області батьківський елемент також малюється під дочірнім елементом, як зазвичай.

CanvasGroupMode CANVAS_GROUP_MODE_TRANSPARENT = 3

There is currently no description for this enum. Please help us by contributing one!

enum CanvasLightMode: 🔗

CanvasLightMode CANVAS_LIGHT_MODE_POINT = 0

2D точка світла (див. PointLight2D).

CanvasLightMode CANVAS_LIGHT_MODE_DIRECTIONAL = 1

2D спрямоване (sun/moon) світло (див. DirectionalLight2D).

enum CanvasLightBlendMode: 🔗

CanvasLightBlendMode CANVAS_LIGHT_BLEND_MODE_ADD = 0

Додає світло-кольорову добавка до полотна.

CanvasLightBlendMode CANVAS_LIGHT_BLEND_MODE_SUB = 1

Додає світло-кольоровий субтрактивний полотно.

CanvasLightBlendMode CANVAS_LIGHT_BLEND_MODE_MIX = 2

Світло додає колір в залежності від прозорості.

enum CanvasLightShadowFilter: 🔗

CanvasLightShadowFilter CANVAS_LIGHT_FILTER_NONE = 0

Не наносити фільтр на полотні світлотіні.

CanvasLightShadowFilter CANVAS_LIGHT_FILTER_PCF5 = 1

Використовуйте фільтрацію PCF5 для фільтрування світлих тіней.

CanvasLightShadowFilter CANVAS_LIGHT_FILTER_PCF13 = 2

Використовуйте фільтрацію PCF13 для фільтрування світлих тіней.

CanvasLightShadowFilter CANVAS_LIGHT_FILTER_MAX = 3

Макс. значення CanvasLightShadowFilter enum.

enum CanvasOccluderPolygonCullMode: 🔗

CanvasOccluderPolygonCullMode CANVAS_OCCLUDER_POLYGON_CULL_DISABLED = 0

Вимкнення полотна оклюцером.

CanvasOccluderPolygonCullMode CANVAS_OCCLUDER_POLYGON_CULL_CLOCKWISE = 1

Кульчування полотна оклюцера цілодобово.

CanvasOccluderPolygonCullMode CANVAS_OCCLUDER_POLYGON_CULL_COUNTER_CLOCKWISE = 2

Укриття полотна оклюцера проти годинникової стрілки.

enum GlobalShaderParameterType: 🔗

GlobalShaderParameterType GLOBAL_VAR_TYPE_BOOL = 0

Boolean глобальний параметр шейдера (глобальна форма bool ...).

GlobalShaderParameterType GLOBAL_VAR_TYPE_BVEC2 = 1

2-вимірний булевий вектор глобального параметра шейдера (глобальна форма bvec2 ...).

GlobalShaderParameterType GLOBAL_VAR_TYPE_BVEC3 = 2

3-вимірний булевий вектор глобального параметра шейра (глобальна форма bvec3 ...).

GlobalShaderParameterType GLOBAL_VAR_TYPE_BVEC4 = 3

4-вимірний булевий вектор глобального шейдерного параметра (глобальна форма bvec4 ...).

GlobalShaderParameterType GLOBAL_VAR_TYPE_INT = 4

Цілочисельний параметр глобального шейдера (global uniform int ...).

GlobalShaderParameterType GLOBAL_VAR_TYPE_IVEC2 = 5

2-вимірний загальний вектор глобального параметра шейдера (глобальна форма ivec2 ...).

GlobalShaderParameterType GLOBAL_VAR_TYPE_IVEC3 = 6

3-вимірний загальний вектор глобального параметра шейдера (глобальна форма ivec3 ...).

GlobalShaderParameterType GLOBAL_VAR_TYPE_IVEC4 = 7

4-вимірний загальний вектор глобального параметра шейдера (глобальна форма ivec4 ...).

GlobalShaderParameterType GLOBAL_VAR_TYPE_RECT2I = 8

2-вимірний цілий прямокутник глобального параметра шейдера (глобальна форма ivec4 ...). Equivalent to GLOBAL_VAR_TYPE_IVEC4 в коді шейдера, але піддаються Rect2i в редакторі UI.

GlobalShaderParameterType GLOBAL_VAR_TYPE_UINT = 9

Непризначений загальний глобальний параметр відтінку (глобальна форма uint ...).

GlobalShaderParameterType GLOBAL_VAR_TYPE_UVEC2 = 10

2-вимірний непризначений загальний вектор глобального параметра шейдера (глобальна форма uvec2 ...).

GlobalShaderParameterType GLOBAL_VAR_TYPE_UVEC3 = 11

3-вимірний невизнаний загальний вектор глобального параметра шейдера (global форма uvec3 ...).

GlobalShaderParameterType GLOBAL_VAR_TYPE_UVEC4 = 12

4-вимірний невизнаний загальний вектор глобального параметра шейдера (глобальна форма uvec4 ...).

GlobalShaderParameterType GLOBAL_VAR_TYPE_FLOAT = 13

Одиночна плаваюча точка глобального шейдера (глобальна форма float ...).

GlobalShaderParameterType GLOBAL_VAR_TYPE_VEC2 = 14

2-мірний вектор глобального шейдера (глобальна форма vec2 ...).

GlobalShaderParameterType GLOBAL_VAR_TYPE_VEC3 = 15

3-вимірний вектор глобального шейдера (глобальна форма vec3 ...).

GlobalShaderParameterType GLOBAL_VAR_TYPE_VEC4 = 16

4-вимірний вектор глобального шейдера (глобальна форма vec4 ...).

GlobalShaderParameterType GLOBAL_VAR_TYPE_COLOR = 17

Кольоровий глобальний параметр шейдера (глобальна форма vec4 ...). Equivalent to GLOBAL_VAR_TYPE_VEC4 в коді шейдера, але піддаються Color в редакторі UI.

GlobalShaderParameterType GLOBAL_VAR_TYPE_RECT2 = 18

2-вимірна плаваюча точка прямокутника глобального шейдера (глобальна форма vec4 ...). Equivalent to GLOBAL_VAR_TYPE_VEC4 в коді шейдера, але піддаються Rect2 в редакторі UI.

GlobalShaderParameterType GLOBAL_VAR_TYPE_MAT2 = 19

2×2 матриця глобального параметра шейдера (глобальна форма мат2 ...). У редакторі UI надано PackedInt32Array.

GlobalShaderParameterType GLOBAL_VAR_TYPE_MAT3 = 20

3×3 матриця глобального параметра шейдера (глобальна форма мат3 ...). Надіслано в редакторі UI Basis.

GlobalShaderParameterType GLOBAL_VAR_TYPE_MAT4 = 21

4 × 4 матриця глобального параметра шейра (глобальна форма мат4 ...). Представляється як Проект в редакторі UI.

GlobalShaderParameterType GLOBAL_VAR_TYPE_TRANSFORM_2D = 22

2-вимірна трансформація глобального параметра шейдера (глобальна форма мат2x3 ...). Представляємо як Transform2D в редакторі UI.

GlobalShaderParameterType GLOBAL_VAR_TYPE_TRANSFORM = 23

3-вимірна трансформація глобального параметра шейдера (глобальна форма мат3x4 ...). Надіслано як Transform3D в редакторі UI.

GlobalShaderParameterType GLOBAL_VAR_TYPE_SAMPLER2D = 24

2D пробовідбірник глобального параметра шейдера (глобальна форма пробки2D ...). Надіслано як Texture2D в редакторі UI.

GlobalShaderParameterType GLOBAL_VAR_TYPE_SAMPLER2DARRAY = 25

2D вибірковий масив глобального параметра шейдера (глобальна форма пробки2DArray ...). Надіслано як Texture2DArray в редакторі UI.

GlobalShaderParameterType GLOBAL_VAR_TYPE_SAMPLER3D = 26

3D-проектор глобального параметра шейдера (глобальні однорідні пробектори3D ...). Надіслано як Texture3D в редакторі UI.

GlobalShaderParameterType GLOBAL_VAR_TYPE_SAMPLERCUBE = 27

Параметр глобального шейдера семплера Cubemap (global uniform samplerCube ...). Відображається як Cubemap в інтерфейсі редактора.

GlobalShaderParameterType GLOBAL_VAR_TYPE_SAMPLEREXT = 28

Параметр глобального шейдера зовнішнього семплера (global uniform samplerExternalOES ...). Відображається як ExternalTexture в інтерфейсі редактора.

GlobalShaderParameterType GLOBAL_VAR_TYPE_MAX = 29

Представляємо розмір GlobalShaderParameterType enum.

enum RenderingInfo: 🔗

RenderingInfo RENDERING_INFO_TOTAL_OBJECTS_IN_FRAME = 0

Кількість об'єктів, що надаються в поточному режимі 3D. В залежності від положення камери і обертання.

RenderingInfo RENDERING_INFO_TOTAL_PRIMITIVES_IN_FRAME = 1

Кількість точок, ліній або трикутників, що подаються в поточній 3D-сцені. В залежності від положення камери і обертання.

RenderingInfo RENDERING_INFO_TOTAL_DRAW_CALLS_IN_FRAME = 2

Кількість дзвінків, що виконуються для рендерінгу в поточному режимі 3D. В залежності від положення камери і обертання.

RenderingInfo RENDERING_INFO_TEXTURE_MEM_USED = 3

Текстура пам'яті використовується (в байтах).

RenderingInfo RENDERING_INFO_BUFFER_MEM_USED = 4

Пам'ять буфера використовується (в байтах). Це включає дані вершини, однорідні наповнювачі, і багато інших типів буферів, які використовуються внутрішньо.

RenderingInfo RENDERING_INFO_VIDEO_MEM_USED = 5

Використана відеопам'ять (у байтах). Під час використання засобів візуалізації Forward+ або Mobile це завжди більше, ніж сума RENDERING_INFO_TEXTURE_MEM_USED і RENDERING_INFO_BUFFER_MEM_USED, оскільки є різні дані, які не враховуються цими двома показниками. Якщо використовується рендерер сумісності, це дорівнює сумі RENDERING_INFO_TEXTURE_MEM_USED і RENDERING_INFO_BUFFER_MEM_USED.

RenderingInfo RENDERING_INFO_PIPELINE_COMPILATIONS_CANVAS = 6

Кількість конвеєрних компіляцій, ініційованих засобом візуалізації 2D-полотна.

RenderingInfo RENDERING_INFO_PIPELINE_COMPILATIONS_MESH = 7

Кількість конвеєрних компіляцій, ініційованих завантаженням сіток. Ці компіляції відображатимуться як довший час завантаження під час першого запуску гри користувачем і потрібен конвеєр.

RenderingInfo RENDERING_INFO_PIPELINE_COMPILATIONS_SURFACE = 8

Кількість компіляцій конвеєра, які були запущені шляхом створення кешу поверхні перед рендерингом сцени. Ці компіляції відображатимуться як заїкання під час завантаження сцени, коли користувач вперше запускає гру, і конвеєр потрібен.

RenderingInfo RENDERING_INFO_PIPELINE_COMPILATIONS_DRAW = 9

Кількість конвеєрних компіляцій, які були запущені під час малювання сцени. Ці компіляції відображатимуться як заїкання під час гри, коли користувач запускає гру вперше, і потрібен конвеєр.

RenderingInfo RENDERING_INFO_PIPELINE_COMPILATIONS_SPECIALIZATION = 10

Кількість конвеєрних компіляцій, запущених для оптимізації поточної сцени. Ці компіляції виконуються у фоновому режимі та не повинні спричиняти жодних зависань.

enum PipelineSource: 🔗

PipelineSource PIPELINE_SOURCE_CANVAS = 0

Конвеєрна компіляція, ініційована засобом візуалізації двовимірного полотна.

PipelineSource PIPELINE_SOURCE_MESH = 1

Конвеєрна компіляція, яка була ініційована завантаженням сітки.

PipelineSource PIPELINE_SOURCE_SURFACE = 2

Конвеєрна компіляція, яка була ініційована створенням поверхневого кешу перед відтворенням сцени.

PipelineSource PIPELINE_SOURCE_DRAW = 3

Конвеєрна компіляція, яка була запущена під час малювання сцени.

PipelineSource PIPELINE_SOURCE_SPECIALIZATION = 4

Конвеєрна компіляція, яка була запущена для оптимізації поточної сцени.

PipelineSource PIPELINE_SOURCE_MAX = 5

Представляє розмір переліку PipelineSource.

enum Features: 🔗

Features FEATURE_SHADERS = 0

Застаріло: This constant has not been used since Godot 3.0.

Features FEATURE_MULTITHREADED = 1

Застаріло: This constant has not been used since Godot 3.0.

Константи

NO_INDEX_ARRAY = -1 🔗

Відзначає помилку, яка показує, що індексний масив порожній.

ARRAY_WEIGHTS_SIZE = 4 🔗

Кількість ваг/бонів на вершину.

CANVAS_ITEM_Z_MIN = -4096 🔗

Мінімальний Z-шар для предметів полотна.

CANVAS_ITEM_Z_MAX = 4096 🔗

Максимальний Z-шар для предметів полотна.

CANVAS_LAYER_MIN = -2147483648 🔗

Мінімальний шар полотна.

CANVAS_LAYER_MAX = 2147483647 🔗

Максимальний шар полотна.

MAX_GLOW_LEVELS = 7 🔗

Максимальна кількість рівнів світіння, які можна використовувати з ефектом після обробки жовчі.

MAX_CURSORS = 8 🔗

Застаріло: This constant is not used by the engine.

MAX_2D_DIRECTIONAL_LIGHTS = 8 🔗

Максимальна кількість спрямованих вогнів, які можуть бути надані в режимі 2D.

MAX_MESH_SURFACES = 256 🔗

Максимальна кількість поверхонь сітки може мати.

MATERIAL_RENDER_PRIORITY_MIN = -128 🔗

Мінімальне співвідношення всіх матеріалів.

MATERIAL_RENDER_PRIORITY_MAX = 127 🔗

Максимальна рендерність всіх матеріалів.

ARRAY_CUSTOM_COUNT = 4 🔗

Кількість користувацьких масивів даних (ARRAY_CUSTOM0, ARRAY_CUSTOM1, ARRAY_CUSTOM2, ARRAY_CUSTOM3.

PARTICLES_EMIT_FLAG_POSITION = 1 🔗

There is currently no description for this constant. Please help us by contributing one!

PARTICLES_EMIT_FLAG_ROTATION_SCALE = 2 🔗

There is currently no description for this constant. Please help us by contributing one!

PARTICLES_EMIT_FLAG_VELOCITY = 4 🔗

There is currently no description for this constant. Please help us by contributing one!

PARTICLES_EMIT_FLAG_COLOR = 8 🔗

There is currently no description for this constant. Please help us by contributing one!

PARTICLES_EMIT_FLAG_CUSTOM = 16 🔗

There is currently no description for this constant. Please help us by contributing one!

Описи властивостей

bool render_loop_enabled 🔗

void set_render_loop_enabled(value: bool)
bool is_render_loop_enabled()

Якщо false, рендеринг повністю вимикається, але логіка движка все ще обробляється. Ви можете викликати force_draw() для малювання кадру, навіть якщо рендеринг вимкнено.

Описи методів

Array[Image] bake_render_uv2(base: RID, material_overrides: Array[RID], image_size: Vector2i) 🔗

За допомогою параметра material_overrides до набору Image розмірів image_size. Повертає масив Image, що містить властивості матеріалу, зазначені в BakeChannels.

void call_on_render_thread(callable: Callable) 🔗

Оскільки фактична логіка RenderingServer може виконуватися в окремому потоці, доступ до її внутрішніх функцій з головного (або будь-якого іншого) потоку призведе до помилок. Щоб спростити виконання коду, який може безпечно отримувати доступ до внутрішніх функцій рендерингу (таких як RenderingDevice та подібні класи RD), надішліть викликану функцію через цю функцію, щоб вона виконувалася в потоці рендерингу.

RID camera_attributes_create() 🔗

Створює об'єкт атрибутів камери і додає його на RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх camera_attributes_ RenderingServer функції.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: При еквіваленті ресурсу CameraAttributes.

void camera_attributes_set_auto_exposure(camera_attributes: RID, enable: bool, min_sensitivity: float, max_sensitivity: float, speed: float, scale: float) 🔗

Налаштовує параметри для використання з автоматичною дією. Ці параметри беруть на той же сенс, як їх аналоги в CameraAttributes і CameraAttributesPractical.

void camera_attributes_set_dof_blur(camera_attributes: RID, far_enable: bool, far_distance: float, far_transition: float, near_enable: bool, near_distance: float, near_transition: float, amount: float) 🔗

Налаштовує параметри для використання з ефектом розмиття DOF. Ці параметри беруть на той же зміст, як їх аналоги в CameraAttributesPractical.

void camera_attributes_set_dof_blur_bokeh_shape(shape: DOFBokehShape) 🔗

Встановлює форму візерунка боке глибини різкості на shape. Для досягнення художнього ефекту або для досягнення цільових показників продуктивності можна використовувати різні форми.

void camera_attributes_set_dof_blur_quality(quality: DOFBlurQuality, use_jitter: bool) 🔗

Встановлює рівень якості ефекту розмиття глибини різкості на quality. Параметр use_jitter можна використовувати для регулювання коливань зразків, взятих під час розмиття, щоб приховати артефакти, але ціною більшої розмитості.

void camera_attributes_set_exposure(camera_attributes: RID, multiplier: float, normalization: float) 🔗

Встановлює значення експозиції, які використовуватимуться рендерерами. Величина нормалізації використовується для включення заданого значення експозиції (EV) у обчислення візуалізації для зменшення динамічного діапазону сцени.

Коефіцієнт нормалізації можна розрахувати за значенням експозиції (EV100) наступним чином:

func get_exposure_normalization(ev100: float):
    return 1,0 / (pow(2,0, ev100) * 1,2)

Значення експозиції можна розрахувати на основі діафрагми (у діафрагмах), витримки (у секундах) і чутливості (у ISO) таким чином:

func get_exposure(aperture: float, shutter_speed: float, sensitivity: float):
    return log((aperture * aperture) / shutter_speed * (100,0 / sensitivity)) / log(2)

RID camera_create() 🔗

Створює відеокамеру 3D і додає її на RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх camera_* RenderingServer функції.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: Важкий вузол Camera3D.

void camera_set_camera_attributes(camera: RID, effects: RID) 🔗

Встановлює атрибути camera_attributes, створені за допомогою camera_attributes_create(), для заданої камери.

void camera_set_compositor(camera: RID, compositor: RID) 🔗

Встановлює композитор, який використовується цією камерою. Еквівалентно Camera3D.compositor.

void camera_set_cull_mask(camera: RID, layers: int) 🔗

Встановлює маску відсікання, пов'язану з цією камерою. Маска відсікання описує, які 3D-шари відтворюються цією камерою. Еквівалентно Camera3D.cull_mask.

void camera_set_environment(camera: RID, env: RID) 🔗

Встановлює середовище, яке використовуватиме ця камера. Еквівалентно Camera3D.environment.

void camera_set_frustum(camera: RID, size: float, offset: Vector2, z_near: float, z_far: float) 🔗

Налаштування камери для використання проекції frustum. Цей режим дозволяє регулювати аргумент offset для створення "притягнутих frustum" ефектів.

void camera_set_orthogonal(camera: RID, size: float, z_near: float, z_far: float) 🔗

Встановлює камеру для використання ортогональної проекції, також відомий як ортографічна проекція. Об'єкти залишаються однаковими розмірами на екрані незалежно від того, як вони знаходяться далеко.

void camera_set_perspective(camera: RID, fovy_degrees: float, z_near: float, z_far: float) 🔗

Налаштовує камеру для використання перспективного проекції. Об'єкти на екрані стають меншими, коли вони знаходяться далеко.

void camera_set_transform(camera: RID, transform: Transform3D) 🔗

Набори Transform3D камери.

void camera_set_use_vertical_aspect(camera: RID, enable: bool) 🔗

Якщо true, зберігає горизонтальний коефіцієнт аспекту, який еквівалентний камера3D.KEEP_WIDTH. Якщо false, зберігає вертикальне співвідношення сторін, що еквівалентне Camera3D.KEEP_HEIGHT.

RID canvas_create() 🔗

Створює полотно та повертає призначений RID. До нього можна отримати доступ за допомогою повернутого RID. Цей RID буде використовуватися у всіх функціях RenderingServer canvas_*

Після завершення роботи з RID вам потрібно буде звільнити його за допомогою методу free_rid() RenderingServer.

Canvas не має еквівалента Resource або Node.

void canvas_item_add_animation_slice(item: RID, animation_length: float, slice_begin: float, slice_end: float, offset: float = 0.0) 🔗

Подальші команди малювання ігноруватимуться, якщо вони не потраплять у вказаний фрагмент анімації. Це швидший спосіб реалізувати анімацію, яка повторюється на фоні, а не постійно перемальовується.

void canvas_item_add_circle(item: RID, pos: Vector2, radius: float, color: Color, antialiased: bool = false) 🔗

Малює коло на CanvasItem, на який вказує item RID. Див. також CanvasItem.draw_circle().

void canvas_item_add_clip_ignore(item: RID, ignore: bool) 🔗

Якщо ignore має значення true, ігноруйте відсікання елементів, намальованих цим елементом полотна, доки це не буде викликано знову з ignore, встановленим на false.

void canvas_item_add_lcd_texture_rect_region(item: RID, rect: Rect2, texture: RID, src_rect: Rect2, modulate: Color) 🔗

Дивитись також CanvasItem.draw_lcd_texture_rect_region().

void canvas_item_add_line(item: RID, from: Vector2, to: Vector2, color: Color, width: float = -1.0, antialiased: bool = false) 🔗

Малює лінію на CanvasItem, на який вказує item RID. Див. також CanvasItem.draw_line().

void canvas_item_add_mesh(item: RID, mesh: RID, transform: Transform2D = Transform2D(1, 0, 0, 1, 0, 0), modulate: Color = Color(1, 1, 1, 1), texture: RID = RID()) 🔗

Малює сітку, створену за допомогою mesh_create(), із заданими параметрами transform, modulate color та texture. Це використовується внутрішньо MeshInstance2D.

void canvas_item_add_msdf_texture_rect_region(item: RID, rect: Rect2, texture: RID, src_rect: Rect2, modulate: Color = Color(1, 1, 1, 1), outline_size: int = 0, px_range: float = 1.0, scale: float = 1.0) 🔗

Дивитись також CanvasItem.draw_msdf_texture_rect_region().

void canvas_item_add_multiline(item: RID, points: PackedVector2Array, colors: PackedColorArray, width: float = -1.0, antialiased: bool = false) 🔗

Малює 2D-мультилінію на CanvasItem, на який вказує item RID. Див. також CanvasItem.draw_multiline() та CanvasItem.draw_multiline_colors().

void canvas_item_add_multimesh(item: RID, mesh: RID, texture: RID = RID()) 🔗

Малює 2D MultiMesh на CanvasItem, на який вказує item RID. Див. також CanvasItem.draw_multimesh().

void canvas_item_add_nine_patch(item: RID, rect: Rect2, source: Rect2, texture: RID, topleft: Vector2, bottomright: Vector2, x_axis_mode: NinePatchAxisMode = 0, y_axis_mode: NinePatchAxisMode = 0, draw_center: bool = true, modulate: Color = Color(1, 1, 1, 1)) 🔗

Малює прямокутник із дев'яти ділянок на CanvasItem, на який вказує item RID.

void canvas_item_add_particles(item: RID, particles: RID, texture: RID) 🔗

Накладні частинки на CanvasItem вказують на item RID.

void canvas_item_add_polygon(item: RID, points: PackedVector2Array, colors: PackedColorArray, uvs: PackedVector2Array = PackedVector2Array(), texture: RID = RID()) 🔗

Малює двовимірний багатокутник на CanvasItem, на який вказує item RID. Якщо вам потрібна більша гнучкість (наприклад, можливість використовувати кістки), замість цього використовуйте canvas_item_add_triangle_array(). Дивіться також CanvasItem.draw_polygon().

Примітка. Якщо ви часто перемальовуєте один і той самий багатокутник із великою кількістю вершин, розгляньте можливість попереднього розрахунку тріангуляції за допомогою Geometry2D.triangulate_polygon() і використання CanvasItem.draw_mesh(), CanvasItem.draw_multimesh() або canvas_item_add_triangle_array().

void canvas_item_add_polyline(item: RID, points: PackedVector2Array, colors: PackedColorArray, width: float = -1.0, antialiased: bool = false) 🔗

Малює 2D полілінію на CanvasItem, на який вказує item RID. Див. також CanvasItem.draw_polyline() та CanvasItem.draw_polyline_colors().

void canvas_item_add_primitive(item: RID, points: PackedVector2Array, colors: PackedColorArray, uvs: PackedVector2Array, texture: RID) 🔗

Малює 2D-примітив на CanvasItem, на який вказує item RID. Див. також CanvasItem.draw_primitive().

void canvas_item_add_rect(item: RID, rect: Rect2, color: Color, antialiased: bool = false) 🔗

Малює прямокутник на CanvasItem, на який вказує item RID. Див. також CanvasItem.draw_rect().

void canvas_item_add_set_transform(item: RID, transform: Transform2D) 🔗

Налаштовує Transform2D, який буде використовуватися для перетворення наступних команд канви.

void canvas_item_add_texture_rect(item: RID, rect: Rect2, texture: RID, tile: bool = false, modulate: Color = Color(1, 1, 1, 1), transpose: bool = false) 🔗

Малює 2D текстурований прямокутник на CanvasItem, на який вказує item RID. Див. також CanvasItem.draw_texture_rect() та Texture2D.draw_rect().

void canvas_item_add_texture_rect_region(item: RID, rect: Rect2, texture: RID, src_rect: Rect2, modulate: Color = Color(1, 1, 1, 1), transpose: bool = false, clip_uv: bool = true) 🔗

Малює задану область 2D текстурованого прямокутника на CanvasItem, на який вказує item RID. Див. також CanvasItem.draw_texture_rect_region() та Texture2D.draw_rect_region().

void canvas_item_add_triangle_array(item: RID, indices: PackedInt32Array, points: PackedVector2Array, colors: PackedColorArray, uvs: PackedVector2Array = PackedVector2Array(), bones: PackedInt32Array = PackedInt32Array(), weights: PackedFloat32Array = PackedFloat32Array(), texture: RID = RID(), count: int = -1) 🔗

Малює масив трикутників на CanvasItem, на який вказує item RID. Це використовується внутрішньо методами Line2D та StyleBoxFlat для рендерингу. canvas_item_add_triangle_array() є дуже гнучким, але складнішим у використанні, ніж canvas_item_add_polygon().

Примітка: Якщо count встановлено на невід'ємне значення, будуть відображені лише перші індекси count * 3 (що відповідають count трикутників). В іншому випадку відображаються всі індекси.

void canvas_item_attach_skeleton(item: RID, skeleton: RID) 🔗

Прикріплює скелет до CanvasItem. Видаляє попередній скелет.

void canvas_item_clear(item: RID) 🔗

Очистити CanvasItem і видаліть всі команди в ньому.

RID canvas_item_create() 🔗

Створює новий екземпляр CanvasItem і повертає його RID. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх canvas_item_* Функції RenderingServer.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: еквівалентний вузол CanvasItem.

Variant canvas_item_get_instance_shader_parameter(instance: RID, parameter: StringName) const 🔗

Повертає значення уніформи шейдера для кожного екземпляра з указаного екземпляра елемента полотна. Еквівалент CanvasItem.get_instance_shader_parameter().

Variant canvas_item_get_instance_shader_parameter_default_value(instance: RID, parameter: StringName) const 🔗

Повертає значення за замовчуванням уніформи шейдера для кожного екземпляра з указаного екземпляра елемента полотна. Еквівалент CanvasItem.get_instance_shader_parameter().

Array[Dictionary] canvas_item_get_instance_shader_parameter_list(instance: RID) const 🔗

Повертає словник однорідних імен шейдерів для кожного екземпляра уніформи шейдера для кожного екземпляра з указаного екземпляра елемента полотна.

Повернений словник має формат PropertyInfo з ключами назва, назва_класу, тип, підказка, рядок_підказки і використання.

void canvas_item_reset_physics_interpolation(item: RID) 🔗

Запобігає переполяції фізики на точну фізичну клітку.

Це корисно при переїзді канви на нове місце, щоб дати миттєву зміну, а не перепилення з попереднього місця.

void canvas_item_set_canvas_group_mode(item: RID, mode: CanvasGroupMode, clear_margin: float = 5.0, fit_empty: bool = false, fit_margin: float = 0.0, blur_mipmaps: bool = false) 🔗

Встановлює режим групи полотна, що використовується під час 2D-рендерингу для елемента полотна, визначеного RID item. Для швидшого, але більш обмеженого відсікання використовуйте замість цього canvas_item_set_clip().

Примітка: Еквівалентна функціональність вузла знаходиться в CanvasGroup та CanvasItem.clip_children.

void canvas_item_set_clip(item: RID, clip: bool) 🔗

Якщо clip є true, робить предмет полотна, вказаний item RID нічого не виділяє за межі своїх координат. Цей кліпінг є швидким, але працює тільки з вісь вирівняними прямокутниками. Це означає, що обертання ігнорується за допомогою клипінг прямокутника. Для більш просунутих форм затиску використовуйте canvas_item_set_canvas_group_mode() замість.

Примітка: Визначена функціональність вершини міститься в Label.clip_text, RichTextLabel (ввімкнено ввімкнено) і багато іншого.

void canvas_item_set_copy_to_backbuffer(item: RID, enabled: bool, rect: Rect2) 🔗

Встановлює CanvasItem для копіювання пункту до backbuffer.

void canvas_item_set_custom_rect(item: RID, use_custom_rect: bool, rect: Rect2 = Rect2(0, 0, 0, 0)) 🔗

Якщо use_custom_rect є true, встановлює користувацький прямокутник видимості (використаний для культування) до rect для предмета полотна, зазначеного item. Налаштування користувацького значення може зменшити навантаження процесора при навантаженні лотів 2D екземплярів. Якщо use_custom_rect є false, автоматично обчислює видимість прямокутника на основі малярних команд.

void canvas_item_set_default_texture_filter(item: RID, filter: CanvasItemTextureFilter) 🔗

Встановлює режим фільтра текстури за замовчуванням для елемента полотна, визначеного RID item. Еквівалентно CanvasItem.texture_filter.

void canvas_item_set_default_texture_repeat(item: RID, repeat: CanvasItemTextureRepeat) 🔗

Встановлює режим повторення текстури за замовчуванням для елемента полотна, визначеного RID item. Еквівалентно CanvasItem.texture_repeat.

void canvas_item_set_distance_field_mode(item: RID, enabled: bool) 🔗

Якщо ввімкнено є true, дозволяє багатоканальний підписаний режим відображення відстані для пункту полотна, зазначеного пункт RID. Для отримання шрифту, або з спеціально створеними зображеннями за допомогою msdfgen.

void canvas_item_set_draw_behind_parent(item: RID, enabled: bool) 🔗

Якщо enabled має значення true, елемент полотна, визначений RID item, розміщується позаду його батьківського елемента. Еквівалентно CanvasItem.show_behind_parent.

void canvas_item_set_draw_index(item: RID, index: int) 🔗

Встановлює індекс для CanvasItem.

void canvas_item_set_instance_shader_parameter(instance: RID, parameter: StringName, value: Variant) 🔗

Встановлює уніфікований шейдер для кожного екземпляра на вказаному екземплярі елемента полотна. Еквівалент CanvasItem.set_instance_shader_parameter().

void canvas_item_set_interpolated(item: RID, interpolated: bool) 🔗

Якщо interpolated є true, виходить на фізичну інтерполяцію для предмета полотна.

void canvas_item_set_light_mask(item: RID, mask: int) 🔗

Встановлює світло mask для елемента полотна, визначеного RID item. Еквівалентно CanvasItem.light_mask.

void canvas_item_set_material(item: RID, material: RID) 🔗

Встановлює новий material для елемента полотна, визначеного RID item. Еквівалентно CanvasItem.material.

void canvas_item_set_modulate(item: RID, color: Color) 🔗

Множить колір елемента полотна, заданого RID item, впливаючи при цьому на його дочірні елементи. Див. також canvas_item_set_self_modulate(). Еквівалентно CanvasItem.modulate.

void canvas_item_set_parent(item: RID, parent: RID) 🔗

Встановлює батьківщину CanvasItem в CanvasItem. Цей елемент буде перетворюватися, модуляція і видимість від свого батька, як CanvasItem вершини в декорі.

void canvas_item_set_self_modulate(item: RID, color: Color) 🔗

Множить колір елемента полотна, заданого параметром item RID, не впливаючи на його дочірні елементи. Див. також метод canvas_item_set_modulate(). Еквівалентно CanvasItem.self_modulate.

void canvas_item_set_sort_children_by_y(item: RID, enabled: bool) 🔗

Якщо enabled є true, дочірні вузли з найнижчою позицією Y намальовані перед тими, що мають вищу позицію Y. Y-сортування тільки впливає на дітей, які успадкуються від предмета полотна, вказаного item RID, а не сам предмет полотна. Equivalent до CanvasItem.y_sort_enabled.

void canvas_item_set_transform(item: RID, transform: Transform2D) 🔗

Встановлює transform елемента полотна, визначеного RID item. Це впливає на те, де і як буде відображатися елемент. Трансформації дочірніх елементів полотна множаться на трансформацію батьківських елементів. Еквівалентно Node2D.transform.

void canvas_item_set_use_parent_material(item: RID, enabled: bool) 🔗

Встановлює, чи використовує його батьківський матеріал.

void canvas_item_set_visibility_layer(item: RID, visibility_layer: int) 🔗

Налаштовує шар видимості, пов'язаний з цим CanvasItem. Тільки Viewport вершини з відповідною маскою, що надає цей ПолотноItem.

void canvas_item_set_visibility_notifier(item: RID, enable: bool, area: Rect2, enter_callable: Callable, exit_callable: Callable) 🔗

Встановлює заданий CanvasItem як сповіщувач видимості. area визначає область виявлення видимості. enter_callable викликається, коли CanvasItem виходить на екран, exit_callable викликається, коли CanvasItem залишає екран. Якщо enable має значення false, елемент більше не функціонуватиме як сповіщувач.

Цей метод можна використовувати для ручної імітації VisibleOnScreenNotifier2D.

void canvas_item_set_visible(item: RID, visible: bool) 🔗

Налаштовує видимість CanvasItem.

void canvas_item_set_z_as_relative_to_parent(item: RID, enabled: bool) 🔗

Якщо це ввімкнено, індекс Z батьків додано до індексу Z.

void canvas_item_set_z_index(item: RID, z_index: int) 🔗

Налаштовує індекс Z CanvasItem, тобто його порядок малювання (нижчі індекси нараховуються першими).

void canvas_item_transform_physics_interpolation(item: RID, transform: Transform2D) 🔗

Трансформує як поточну, так і попередню збережену трансформацію на предмет полотна.

Це дозволяє перетворювати полотно без створення «блискавки» в інтерполяції, що особливо корисно для великих світів, що використовують зсувне походження.

void canvas_light_attach_to_canvas(light: RID, canvas: RID) 🔗

Прикріплює полотно світлом до полотна. Знімає її з попереднього полотна.

RID canvas_light_create() 🔗

Створює полотно світла і додає її до рендерингсера. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх canvas_light_* Функції RenderingServer.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: Об'ємний вузол Light2D.

void canvas_light_occluder_attach_to_canvas(occluder: RID, canvas: RID) 🔗

Прикріплює світлий восьмикутник до полотна. Знімає її з попереднього полотна.

RID canvas_light_occluder_create() 🔗

Створює легкий октейнер і додає його до RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх canvas_light_occluder_* RenderingServer функції.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: еквівалентний вузол LightOccluder2D.

void canvas_light_occluder_reset_physics_interpolation(occluder: RID) 🔗

Запобігає переполяції фізики на точну фізичну клітку.

Це корисно при переїзді оклюцера на нове місце, щоб дати миттєві зміни, а не перепилення з попереднього місця.

void canvas_light_occluder_set_as_sdf_collision(occluder: RID, enable: bool) 🔗

There is currently no description for this method. Please help us by contributing one!

void canvas_light_occluder_set_enabled(occluder: RID, enabled: bool) 🔗

Увімкнути або вимкнути легкий оклюцер.

void canvas_light_occluder_set_interpolated(occluder: RID, interpolated: bool) 🔗

Якщо interpolated є true, перетворюється на фізичну інтерполяцію для легкого оклюцера.

void canvas_light_occluder_set_light_mask(occluder: RID, mask: int) 🔗

Легка маска. Детальніше про легкі маски.

void canvas_light_occluder_set_polygon(occluder: RID, polygon: RID) 🔗

Налаштовує легкий оклюцеровий полігон.

void canvas_light_occluder_set_transform(occluder: RID, transform: Transform2D) 🔗

Встановлює світлозахисну завісу Transform2D.

void canvas_light_occluder_transform_physics_interpolation(occluder: RID, transform: Transform2D) 🔗

Трансформує як струм, так і попередню збережену трансформацію для світлого оклюцера.

Це дозволяє перетворювати оклюцер, не створивши «блискавку» в інтерполяції, який особливо корисний для великих світів, що використовують зсувне походження.

void canvas_light_reset_physics_interpolation(light: RID) 🔗

Запобігає переполяції фізики на точну фізичну клітку.

Це корисно при переїзді канви на нове місце, щоб дати миттєву зміну, а не перепилення з попереднього місця.

void canvas_light_set_blend_mode(light: RID, mode: CanvasLightBlendMode) 🔗

Встановлює режим змішування для заданого світла на полотні на mode. Еквівалентно Light2D.blend_mode.

void canvas_light_set_color(light: RID, color: Color) 🔗

Встановлює колір для світла.

void canvas_light_set_enabled(light: RID, enabled: bool) 🔗

Увімкнути або вимкнути полотно світло.

void canvas_light_set_energy(light: RID, energy: float) 🔗

Налаштовує енергію полотна світла.

void canvas_light_set_height(light: RID, height: float) 🔗

Встановлює висоту полотна світла.

void canvas_light_set_interpolated(light: RID, interpolated: bool) 🔗

Якщо interpolated є true, виходить на фізику інтерполяції для полотна світла.

void canvas_light_set_item_cull_mask(light: RID, mask: int) 🔗

Легка маска. Детальніше про легкі маски.

void canvas_light_set_item_shadow_cull_mask(light: RID, mask: int) 🔗

Біржова маска використовується для визначення яких шарів цієї полотнища світлотіні. Детальніше про легкі маски.

void canvas_light_set_layer_range(light: RID, min_layer: int, max_layer: int) 🔗

Асортимент шарів, який отримується з цим світлом.

void canvas_light_set_mode(light: RID, mode: CanvasLightMode) 🔗

Встановлює режим освітлення полотна.

void canvas_light_set_shadow_color(light: RID, color: Color) 🔗

Налаштовує колір тіні світла полотна.

void canvas_light_set_shadow_enabled(light: RID, enabled: bool) 🔗

Увімкнути або вимкнути тінь світла полотна.

void canvas_light_set_shadow_filter(light: RID, filter: CanvasLightShadowFilter) 🔗

Встановлює фільтр тіні світла на полотні.

void canvas_light_set_shadow_smooth(light: RID, smooth: float) 🔗

Згладжує тінь. Нижня, гладка.

void canvas_light_set_texture(light: RID, texture: RID) 🔗

Встановлює текстуру, яка використовуватиметься PointLight2D. Еквівалентно PointLight2D.texture.

void canvas_light_set_texture_offset(light: RID, offset: Vector2) 🔗

Встановлює зміщення текстури PointLight2D. Еквівалентно PointLight2D.offset.

void canvas_light_set_texture_scale(light: RID, scale: float) 🔗

Встановлює коефіцієнт масштабування текстури PointLight2D. Еквівалентно PointLight2D.texture_scale.

void canvas_light_set_transform(light: RID, transform: Transform2D) 🔗

Набори полотна світла Transform2D.

void canvas_light_set_z_range(light: RID, min_z: int, max_z: int) 🔗

Встановлює діапазон Z об'єктів, на які впливатиме це світло. Еквівалентно Light2D.range_z_min та Light2D.range_z_max.

void canvas_light_transform_physics_interpolation(light: RID, transform: Transform2D) 🔗

Трансформує як поточне, так і попереднє збережене перетворення для світла полотна.

Це дозволяє трансформувати світло без створення «глюка» в інтерполяції, що особливо корисно для великих світів, які використовують змінне походження.

RID canvas_occluder_polygon_create() 🔗

Створює новий легкий оклюцерний полігон і додає його до RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх canvas_occluder_polygon_* RenderingServer функції.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: Вигідний ресурс OccluderPolygon2D.

void canvas_occluder_polygon_set_cull_mode(occluder_polygon: RID, mode: CanvasOccluderPolygonCullMode) 🔗

Встановлює режим відсікання полігону-оклюдера.

void canvas_occluder_polygon_set_shape(occluder_polygon: RID, shape: PackedVector2Array, closed: bool) 🔗

Встановлює форму оклюцерного полігону.

void canvas_set_disable_scale(disable: bool) 🔗

There is currently no description for this method. Please help us by contributing one!

void canvas_set_item_mirroring(canvas: RID, item: RID, mirroring: Vector2) 🔗

Копія полотна буде намальована місцевим зміщенням mirroring.

Примітка: Це еквівалентно дзвонити canvas_set_item_repeat(), як canvas_set_item_repeat (item, дзеркала, 1), з додатковою перевіркою забезпечення canvas є батьком item.

void canvas_set_item_repeat(item: RID, repeat_size: Vector2, repeat_times: int) 🔗

Копія елемента полотна буде намальована з локальним зміщенням repeat_size на кількість разів, визначену в repeat_times. Зі збільшенням repeat_times копії будуть розходитися від початкової текстури.

void canvas_set_modulate(canvas: RID, color: Color) 🔗

Модулює всі кольори в даній полотні.

void canvas_set_shadow_texture_size(size: int) 🔗

Встановлює ProjectSettings.rendering/2d/shadow_atlas/size для використання для рендерингу тіней Light2D (у пікселях). Значення округляється до найближчого степеня 2.

RID canvas_texture_create() 🔗

Створює текстуру полотна та додає її до RenderingServer. Доступ до неї можна отримати за допомогою повернутого RID. Цей RID буде використовуватися у всіх функціях RenderingServer canvas_texture_*.

Після завершення створення RID вам потрібно буде звільнити його за допомогою методу RenderingServer free_rid(). Див. також texture_2d_create().

Примітка: Еквівалентним ресурсом є CanvasTexture, який призначений лише для використання у 2D-рендерингу, а не у 3D.

void canvas_texture_set_channel(canvas_texture: RID, channel: CanvasTextureChannel, texture: RID) 🔗

Встановлює параметр texture параметра channel для текстури полотна, визначеної RID canvas_texture. Еквівалентно параметрам CanvasTexture.diffuse_texture, CanvasTexture.normal_texture та CanvasTexture.specular_texture.

void canvas_texture_set_shading_parameters(canvas_texture: RID, base_color: Color, shininess: float) 🔗

Налаштовує base_color і shininess для використання для текстури полотна, зазначеної canvas_texture RID. Equivalent to CanvasTexture.specular_color і CanvasTexture.specular_shininess.

void canvas_texture_set_texture_filter(canvas_texture: RID, filter: CanvasItemTextureFilter) 🔗

Встановлює режим текстури filter для використання з текстурою полотна, визначеною RID canvas_texture.

void canvas_texture_set_texture_repeat(canvas_texture: RID, repeat: CanvasItemTextureRepeat) 🔗

Встановлює режим текстури repeat для використання з текстурою полотна, визначеною RID canvas_texture.

RID compositor_create() 🔗

Створює новий композитор і додає його до RenderingServer. До нього можна отримати доступ за допомогою повернутого RID.

Після завершення створення RID вам потрібно звільнити його за допомогою методу free_rid() RenderingServer.

RID compositor_effect_create() 🔗

Створює новий ефект рендерингу та додає його до RenderingServer. До нього можна отримати доступ за допомогою повернутого RID.

Після завершення створення RID вам потрібно звільнити його за допомогою методу free_rid() RenderingServer.

void compositor_effect_set_callback(effect: RID, callback_type: CompositorEffectCallbackType, callback: Callable) 🔗

Налаштовує тип зворотного виклику (callback_type) і метод зворотного виклику (callback) для цього рендерингового ефекту.

void compositor_effect_set_enabled(effect: RID, enabled: bool) 🔗

Увімкнути / вимкнути цей ефект рендерингу.

void compositor_effect_set_flag(effect: RID, flag: CompositorEffectFlags, set: bool) 🔗

Налаштовує прапор (прапор) за цей ефект рендерингу true або false (set).

void compositor_set_compositor_effects(compositor: RID, effects: Array[RID]) 🔗

Встановлює ефекти композитора для вказаного RID композитора. effects має бути масивом, що містить RID, створені за допомогою compositor_effect_create().

RenderingDevice create_local_rendering_device() const 🔗

Створює RenderingDevice, який можна використовувати для виконання операцій малювання та обчислення в окремому потоці. Неможливо малювати на екрані або ділитися даними з глобальним RenderingDevice.

Примітка: Під час використання драйвера візуалізації OpenGL або під час роботи в безголовому режимі ця функція завжди повертає null.

Rect2 debug_canvas_item_get_rect(item: RID) 🔗

Повертає межу прямокутника на предмет полотна у місцевому просторі, як розрахований рендерером. Ця межа використовується внутрішньо для вирощування.

Попередження: Ця функція призначена для налагодження в редакторі, і буде проходити через і повернути нульову Rect2 в експортованих проектах.

RID decal_create() 🔗

Створює декаль і додає її рендерингу. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх decal_* Функції RenderingServer.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Щоб розміститися в сцені, прикріпіть цей декаль до екземпляра за допомогою instance_set_base() за допомогою повернутого RID.

Note: еквівалентний вузол Decal.

void decal_set_albedo_mix(decal: RID, albedo_mix: float) 🔗

Встановлює albedo_mix у деколі, визначеному RID decal. Еквівалентно Decal.albedo_mix.

void decal_set_cull_mask(decal: RID, mask: int) 🔗

Встановлює маску параметра decal для вибракування в деколі, визначеному RID decal. Еквівалентно Decal.cull_mask.

void decal_set_distance_fade(decal: RID, enabled: bool, begin: float, length: float) 🔗

Встановлює параметри поступового згасання на відстані в декалі, визначеному RID decal. Еквівалентно Decal.distance_fade_enabled, Decal.distance_fade_begin та Decal.distance_fade_length.

void decal_set_emission_energy(decal: RID, energy: float) 🔗

Встановлює значення випромінювання energy у деколі, визначеному RID decal. Еквівалентно Decal.emission_energy.

void decal_set_fade(decal: RID, above: float, below: float) 🔗

Встановлює верхнє (above) та нижнє (below) затемнення у деколі, визначеному RID decal. Еквівалентно Decal.upper_fade та Decal.lower_fade.

void decal_set_modulate(decal: RID, color: Color) 🔗

Встановлює множник кольору в декалі, визначеному RID decal, на color. Еквівалентно Decal.modulate.

void decal_set_normal_fade(decal: RID, fade: float) 🔗

Встановлює нормальне гасіння fade у деколі, визначеному RID decal. Еквівалентно Decal.normal_fade.

void decal_set_size(decal: RID, size: Vector3) 🔗

Встановлює size наклейки, визначеної RID decal. Еквівалентно Decal.size.

void decal_set_texture(decal: RID, type: DecalTexture, texture: RID) 🔗

Встановлює texture у заданому слоті текстури type для зазначеної деколі. Еквівалентно Decal.set_texture().

void decals_set_filter(filter: DecalFilter) 🔗

Налаштовує фактуру filter режим використання при рендерингу декалі. Цей параметр є глобальним і не може бути встановленим на основі.

RID directional_light_create() 🔗

Створює спрямоване світло і додає його на RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID може використовуватися в більшості light_* Функції RenderingServer.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Щоб розміститися в сцені, прикріпіть цей спрямований світло до екземпляра за допомогою instance_set_base() за допомогою повернутого RID.

Примітка: Вирівнююча вершина DirectionalLight3D.

void directional_shadow_atlas_set_size(size: int, is_16bits: bool) 🔗

Встановлює size спрямованих світлових тіней у 3D. Див. також ProjectSettings.rendering/lights_and_shadows/directional_shadow/size. Цей параметр є глобальним і не може бути встановлений для кожного окремого вікна перегляду.

void directional_soft_shadow_filter_set_quality(quality: ShadowQuality) 🔗

Встановлює фільтр quality для спрямованих світлотіней у 3D. Див. також ProjectSettings.rendering/lights_and_shadows/directional_shadow/soft_shadow_filter_quality. Цей параметр є глобальним і не може бути встановлений для кожного окремого вікна перегляду.

Image environment_bake_panorama(environment: RID, bake_irradiance: bool, size: Vector2i) 🔗

Генерує та повертає Image, що містить карту яскравості для неба, зазначеного в environment RID. Це підтримує вбудований матеріал неба та власні шейдери неба. Якщо bake_irradiance має значення true, карта яскравості зберігається замість карти яскравості. Карта яскравості використовується для візуалізації відбитого світла, тоді як карта яскравості використовується для візуалізації навколишнього світла. Див. також sky_bake_panorama().

Примітка: Зображення зберігається в лінійному колірному просторі без будь-якого тонального відображення, що означає, що воно виглядатиме занадто темним, якщо переглядати його безпосередньо в редакторі зображень.

Примітка: size має бути зі співвідношенням сторін 2:1, щоб згенерована панорама мала квадратні пікселі. Для карт яскравості немає сенсу використовувати висоту, більшу за Sky.radiance_size, оскільки це не збільшить деталізацію. Карти опроміненості містять лише низькочастотні дані, тому зазвичай немає сенсу перевищувати розмір 128×64 пікселів під час збереження карти опроміненості.

RID environment_create() 🔗

Створює навколишнє середовище і додає його до RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх environment_* RenderingServer функції.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: При еквіваленті ресурсу Environment.

void environment_glow_set_use_bicubic_upscale(enable: bool) 🔗

Якщо enable має значення true, вмикається бікубічне масштабування для світіння, що покращує якість, але знижує продуктивність. Еквівалентно ProjectSettings.rendering/environment/glow/upscale_mode.

Примітка: Цей параметр ефективний лише під час використання методів рендерингу Forward+ або Mobile, оскільки Compatibility використовує іншу реалізацію світіння.

void environment_set_adjustment(env: RID, enable: bool, brightness: float, contrast: float, saturation: float, use_1d_color_correction: bool, color_correction: RID) 🔗

Налаштовує значення, які слід використовувати за допомогою параметра «регулювання». Детальніше.

void environment_set_ambient_light(env: RID, color: Color, ambient: EnvironmentAmbientSource = 0, energy: float = 1.0, sky_contribution: float = 0.0, reflection_source: EnvironmentReflectionSource = 0) 🔗

Налаштовує значення, які використовуються для амбішного світла. Детальніше.

void environment_set_background(env: RID, bg: EnvironmentBG) 🔗

Встановлює фоновий режим середовища. Еквівалентно Environment.background_mode.

void environment_set_bg_color(env: RID, color: Color) 🔗

Колір відображається для чітких зон сцени. Тільки ефективний при використанні фонового режиму ENV_BG_COLOR.

void environment_set_bg_energy(env: RID, multiplier: float, exposure_value: float) 🔗

Встановлює інтенсивність фонового кольору.

void environment_set_camera_id(env: RID, id: int) 🔗

Встановлює ідентифікатор камери, який буде використовуватися як фон середовища.

void environment_set_canvas_max_layer(env: RID, max_layer: int) 🔗

Налаштовує максимальний шар для використання при використанні фонового режиму Canvas.

void environment_set_fog(env: RID, enable: bool, light_color: Color, light_energy: float, sun_scatter: float, density: float, height: float, height_density: float, aerial_perspective: float, sky_affect: float, fog_mode: EnvironmentFogMode = 0) 🔗

Налаштовує туман для вказаного середовища RID. fog_* властивості Environment для отримання додаткової інформації.

void environment_set_fog_depth(env: RID, curve: float, begin: float, end: float) 🔗

Налаштовує глибину туману для вказаного середовища RID. Має ефект лише тоді, коли режим туману середовища має значення ENV_FOG_MODE_DEPTH. Див. властивості fog_depth_* у Environment для отримання додаткової інформації.

void environment_set_glow(env: RID, enable: bool, levels: PackedFloat32Array, intensity: float, strength: float, mix: float, bloom_threshold: float, blend_mode: EnvironmentGlowBlendMode, hdr_bleed_threshold: float, hdr_bleed_scale: float, hdr_luminance_cap: float, glow_map_strength: float, glow_map: RID) 🔗

Налаштування світіння для вказаного середовища RID. Див. glow_* властивості в Environment для отримання додаткової інформації.

void environment_set_sdfgi(env: RID, enable: bool, cascades: int, min_cell_size: float, y_scale: EnvironmentSDFGIYScale, use_occlusion: bool, bounce_feedback: float, read_sky: bool, energy: float, normal_bias: float, probe_bias: float) 🔗

Налаштовує підписане поле дистанційного керування глобальним освітленням для вказаного середовища RID. sdfgi_* властивості Environment для отримання додаткової інформації.

void environment_set_sdfgi_frames_to_converge(frames: EnvironmentSDFGIFramesToConverge) 🔗

Встановлює кількість кадрів, які будуть використані для збіжної глобальної освітленості поля знакової відстані. Еквівалентно ProjectSettings.rendering/global_illumination/sdfgi/frames_to_converge.

void environment_set_sdfgi_frames_to_update_light(frames: EnvironmentSDFGIFramesToUpdateLight) 🔗

Встановлює швидкість оновлення для непрямого освітлення динамічних вогнів під час обчислення глобального освітлення поля знакової відстані. Еквівалентно ProjectSettings.rendering/global_illumination/sdfgi/frames_to_update_lights.

void environment_set_sdfgi_ray_count(ray_count: EnvironmentSDFGIRayCount) 🔗

Встановлює кількість променів, що відкидаються на кадр під час обчислення глобальної освітленості поля знакової відстані. Еквівалентно ProjectSettings.rendering/global_illumination/sdfgi/probe_ray_count.

void environment_set_sky(env: RID, sky: RID) 🔗

Налаштовує Sky використовувати як фон навколишнього середовища при використанні BGMode небо. Еквівалентно Environment.sky.

void environment_set_sky_custom_fov(env: RID, scale: float) 🔗

Встановлює власне поле зору для фону Небо. Еквівалент Environment.sky_custom_fov.

void environment_set_sky_orientation(env: RID, orientation: Basis) 🔗

Встановлює обертання фону Sky, виражене як Basis. Еквівалентно Environment.sky_rotation, де вектор обертання використовується для побудови Basis.

void environment_set_ssao(env: RID, enable: bool, radius: float, intensity: float, power: float, detail: float, horizon: float, sharpness: float, light_affect: float, ao_channel_affect: float) 🔗

Встановлює змінні, що використовуються з ефектом пост-обробки екранного простору ambient occlusion (SSAO). Див. Environment для отримання додаткової інформації.

void environment_set_ssao_quality(quality: EnvironmentSSAOQuality, half_size: bool, adaptive_target: float, blur_passes: int, fadeout_from: float, fadeout_to: float) 🔗

Встановлює рівень якості ефекту пост-обробки екранного простору ambient occlusion (SSAO). Див. Environment для отримання додаткової інформації.

void environment_set_ssil_quality(quality: EnvironmentSSILQuality, half_size: bool, adaptive_target: float, blur_passes: int, fadeout_from: float, fadeout_to: float) 🔗

Встановлює рівень якості ефекту пост-обробки непрямого освітлення екранного простору (SSIL). Докладніше див. у розділі Environment.

void environment_set_ssr(env: RID, enable: bool, max_steps: int, fade_in: float, fade_out: float, depth_tolerance: float) 🔗

Встановлює змінні, що використовуються з ефектом постобробки відбиттів екранного простору (SSR). Див. Environment для отримання додаткової інформації.

void environment_set_ssr_roughness_quality(quality: EnvironmentSSRRoughnessQuality) 🔗

There is currently no description for this method. Please help us by contributing one!

void environment_set_tonemap(env: RID, tone_mapper: EnvironmentToneMapper, exposure: float, white: float) 🔗

Встановлює змінні, які будуть використовуватися з ефектом пост-обробки "тональна карта". Див. Environment для отримання додаткової інформації.

void environment_set_volumetric_fog(env: RID, enable: bool, density: float, albedo: Color, emission: Color, emission_energy: float, anisotropy: float, length: float, p_detail_spread: float, gi_inject: float, temporal_reprojection: bool, temporal_reprojection_amount: float, ambient_inject: float, sky_affect: float) 🔗

Встановлює змінні, які будуть використовуватися з ефектом пост-обробки об'ємного туману. Див. Environment для отримання додаткової інформації.

void environment_set_volumetric_fog_filter_active(active: bool) 🔗

Увімкнути фільтрацію об'ємної фольги розсіювання буфера. Це призводить до значно гладких об'ємів з дуже малою кількістю підсмакувальних артефактів.

void environment_set_volumetric_fog_volume_size(size: int, depth: int) 🔗

Налаштовує роздільну здатність об'ємного туману froxel. size модифікований співвідношенням сторін екрана, а потім використовується для встановлення ширини та висоти буфера. В той час як depth безпосередньо використовується для встановлення глибини буфера.

RID fog_volume_create() 🔗

Створює новий об'єм фольги і додає його на RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх fog_volume_* RenderingServer функції.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: Важкий вузол FogVolume.

void fog_volume_set_material(fog_volume: RID, material: RID) 🔗

Налаштовує Material об'єму фольги. Може бути або FogMaterial або на замовлення ShaderMaterial.

void fog_volume_set_shape(fog_volume: RID, shape: FogVolumeShape) 🔗

Налаштовує форму об'єму фольги або FOG_VOLUME_SHAPE_ELLIPSOID, FOG_VOLUME_SHAPE_CONE, FOG_VOLUME_SHAPE_CYLINDER, FOG_VOLUME_SHAPE_BOX або FOG_VOLUME_SHAPE_WORLD.

void fog_volume_set_size(fog_volume: RID, size: Vector3) 🔗

Налаштовує розмір об'єму fog при формі FOG_VOLUME_SHAPE_ELLIPSOID, FOG_VOLUME_SHAPE_CONE, FOG_VOLUME_SHAPE_CYLINDER або FOG_VOLUME_SHAPE_BOX.

void force_draw(swap_buffers: bool = true, frame_step: float = 0.0) 🔗

Видобуток всіх видів транспорту одночасно. Необхідно назвати з основної нитки.

void force_sync() 🔗

Сили синхронізації між процесором та GPU, які можуть знадобитися в певних випадках. Тільки зателефонуйте це при необхідності, оскільки синхронізація процесора-GPU має вартість виконання.

void free_rid(rid: RID) 🔗

Виконується безкоштовно об'єкт в RenderingServer. Щоб уникнути витоків пам'яті, це слід назвати після використання об'єкта, як управління пам'яттю не відбувається автоматично при використанні RenderingServer безпосередньо.

String get_current_rendering_driver_name() const 🔗

Повертає ім'я поточного драйвера рендерингу. Це може бути vulkan, d3d12, metal, opengl3, opengl3_es або opengl3_angle. Див. також get_current_rendering_method().

Коли ProjectSettings.rendering/renderer/rendering_method дорівнює forward_plus або mobile, драйвер рендеринга визначається ProjectSettings.rendering/rendering_device/driver.

Коли ProjectSettings.rendering/renderer/rendering_method дорівнює gl_compatibility, драйвер рендеринга визначається ProjectSettings.rendering/gl_compatibility/driver.

Драйвер рендеринга також визначається аргументом командного рядка --rendering-driver, який замінює це налаштування проекту, або автоматичним резервним варіантом, що застосовується залежно від апаратного забезпечення.

String get_current_rendering_method() const 🔗

Повертає назву поточного методу візуалізації. Це може бути forward_plus, mobile або gl_compatibility. Дивіться також get_current_rendering_driver_name().

Метод візуалізації визначається ProjectSettings.rendering/renderer/rendering_method, аргументом командного рядка --rendering-method, який замінює це налаштування проекту, або автоматичним резервним варіантом, який застосовується залежно від апаратного забезпечення.

Color get_default_clear_color() 🔗

Повертає стандартний прозорий колір, який використовується, коли певний прозорий колір не вибрано. Див. також set_default_clear_color().

float get_frame_setup_time_cpu() const 🔗

Повертає час, необхідний для налаштування рендерингу на процесорі, у мілісекундах. Це значення є спільним для всіх вікон перегляду та не вимагає, щоб метод viewport_set_measure_render_time() був увімкнений на вікні перегляду для запиту. Див. також metod viewport_get_measured_render_time_cpu.

RenderingDevice get_rendering_device() const 🔗

Повертає глобальний RenderingDevice.

Примітка: Під час використання драйвера візуалізації OpenGL або під час роботи в безголовому режимі ця функція завжди повертає null.

int get_rendering_info(info: RenderingInfo) 🔗

Повертає статистику про механізм рендерингу, яку можна використовувати для профілювання продуктивності. Див. також viewport_get_render_info(), який повертає інформацію, специфічну для області перегляду.

Примітка: Деякі з цих значень, такі як кількість викликів малювання, наразі враховують лише 3D-рендеринг.

Примітка: Інформація про рендеринг недоступна, доки механізм не відрендерить принаймні 2 кадри. Якщо інформація про рендеринг недоступна, get_rendering_info() повертає 0. Щоб успішно вивести інформацію про рендеринг у _ready(), використовуйте наступне:

func _ready():
for _i in 2:
await get_tree().process_frame

print(RenderingServer.get_rendering_info(RENDERING_INFO_TOTAL_DRAW_CALLS_IN_FRAME))

Array[Dictionary] get_shader_parameter_list(shader: RID) const 🔗

Повертає параметри шейдера.

RID get_test_cube() 🔗

Повертає RID тестового куба. Ця сітка буде створена та повернута під час першого виклику методу get_test_cube(), потім вона буде кешована для наступних викликів. Див. також make_sphere_mesh().

RID get_test_texture() 🔗

Повертає RID текстури 256 × 256 із тестовим шаблоном на ній (у форматі Image.FORMAT_RGB8). Ця текстура буде створена та повернена під час першого виклику get_test_texture(), потім вона буде кешована для наступних викликів. Дивіться також get_white_texture().

Приклад: Отримайте тестову текстуру та застосуйте її до вузла Sprite2D:

var texture_rid = RenderingServer.get_test_texture()
var texture = ImageTexture.create_from_image(RenderingServer.texture_2d_get(texture_rid))
$Sprite2D.texture = texture

String get_video_adapter_api_version() const 🔗

Повертає версію відео адаптера графіки *, відповідно, у використанні * (наприклад, "1.2.189" для Vulkan, "3.3.0 NVIDIA 510.60.02" для OpenGL). Ця версія може відрізнятися від фактичної останньої версії, що підтримується обладнанням, оскільки Godot не завжди може вимагати останню версію. Дивіться також OS.get_video_adapter_driver_info().

Примітка: При запуску безголовного або сервера бінарних, ця функція повертає порожній рядок.

String get_video_adapter_name() const 🔗

Повертає назву відео адаптера (наприклад, "GeForce GTX 1080/PCIe/SSE2").

Примітка: При запуску безголовного або сервера бінарних, ця функція повертає порожній рядок.

Примітка: На веб-платформі деякі браузери, такі як Firefox, можуть повідомити різну, фіксовану назву GPU, таку як "GeForce GTX 980" (незалежно від фактичної моделі GPU користувача). Це робиться, щоб зробити відбитки пальців більш складним.

DeviceType get_video_adapter_type() const 🔗

Повертає тип відеоадаптера. Оскільки виділені графічні карти певного покоління зазвичай будуть значно швидшими за інтегровану відеокарту того самого покоління, тип пристрою можна використовувати як основу для автоматичного налаштування графічних налаштувань. Однак це не завжди так, тому переконайтеся, що надали користувачам спосіб вручну змінити налаштування графіки.

Примітка. Під час використання драйвера візуалізації OpenGL або під час роботи в безголовому режимі ця функція завжди повертає RenderingDevice.DEVICE_TYPE_OTHER.

String get_video_adapter_vendor() const 🔗

Повернення постачальника відео адаптера (наприклад, «NVIDIA Corporation»).

Примітка: При запуску безголовного або сервера бінарних, ця функція повертає порожній рядок.

RID get_white_texture() 🔗

Повертає ідентифікатор білої текстури 4×4 (у форматі Image.FORMAT_RGB8). Ця текстура буде створена та повернена під час першого виклику get_white_texture(), потім вона буде кешована для наступних викликів. Дивіться також get_test_texture().

Приклад: Отримайте білу текстуру та застосуйте її до вузла Sprite2D:

var texture_rid = RenderingServer.get_white_texture()
var texture = ImageTexture.create_from_image(RenderingServer.texture_2d_get(texture_rid))
$Sprite2D.texture = texture

void gi_set_use_half_resolution(half_resolution: bool) 🔗

Якщо half_resolution має значення true, буфери VoxelGI та SDFGI (Environment.sdfgi_enabled) рендеряться з роздільною здатністю, зменшеною вдвічі, на кожній осі (наприклад, 960×540, коли розмір області перегляду становить 1920×1080). Це значно покращує продуктивність, коли VoxelGI або SDFGI увімкнено, але за рахунок артефактів, які можуть бути видимими на ребрах полігону. Втрата якості стає менш помітною зі збільшенням роздільної здатності області перегляду. Цей параметр не впливає на рендеринг LightmapGI. Еквівалентно ProjectSettings.rendering/global_illumination/gi/use_half_resolution.

void global_shader_parameter_add(name: StringName, type: GlobalShaderParameterType, default_value: Variant) 🔗

Створення нової глобальної форми тіні.

Note: Ім'я параметра глобального шейдера є випадковим.

Variant global_shader_parameter_get(name: StringName) const 🔗

Повертає значення глобальної уніформи шейдера, заданої параметром name.

Примітка: Метод global_shader_parameter_get() має значне зниження продуктивності, оскільки потік рендерингу потребує синхронізації з потоком, що викликає, що є повільним. Не використовуйте цей метод під час гри, щоб уникнути заїкання. Якщо вам потрібно зчитувати значення зі скрипта після їх встановлення, подумайте про створення автозавантаження, де ви зберігатимете значення, які потрібно запитувати, одночасно встановлюючи їх як глобальні параметри.

Array[StringName] global_shader_parameter_get_list() const 🔗

Повертає список назв глобальних уніформ шейдерів.

Примітка: global_shader_parameter_get() має значне зниження продуктивності, оскільки потік рендерингу має синхронізуватися з потоком, що викликає, що є повільним. Не використовуйте цей метод під час гри, щоб уникнути заїкання. Якщо вам потрібно зчитувати значення у скрипті після їх встановлення, подумайте про створення автозавантаження, де ви зберігатимете значення, які потрібно запитувати, одночасно встановлюючи їх як глобальні параметри.

GlobalShaderParameterType global_shader_parameter_get_type(name: StringName) const 🔗

Повертає тип, пов'язаний з глобальною уніформою шейдера, визначеною параметром name.

Примітка: Метод global_shader_parameter_get() має значне зниження продуктивності, оскільки потік рендерингу повинен синхронізуватися з потоком, що викликає, що є повільним. Не використовуйте цей метод під час гри, щоб уникнути заїкання. Якщо вам потрібно зчитувати значення зі скрипта після їх встановлення, подумайте про створення автозавантаження, де ви зберігатимете значення, які потрібно запитувати, одночасно з їх встановленням як глобальних параметрів.

void global_shader_parameter_remove(name: StringName) 🔗

Видаліть глобальну форму тіні, зазначену name.

void global_shader_parameter_set(name: StringName, value: Variant) 🔗

Встановлює глобальну уніформу шейдера name на value.

void global_shader_parameter_set_override(name: StringName, value: Variant) 🔗

Замінює глобальний уніформний параметр шейдера name на value. Еквівалент вузла ShaderGlobalsOverride.

bool has_changed() const 🔗

Повертає true, якщо до даних RenderingServer було внесено зміни. У такому разі зазвичай викликається force_draw().

bool has_feature(feature: Features) const 🔗

Застаріло: This method has not been used since Godot 3.0.

Цей метод нічого і завжди повертає false.

bool has_os_feature(feature: String) const 🔗

Повертає true, якщо ОС підтримує певну функцію feature. Можливими функціями можуть бути s3tc, etc та etc2.

void instance_attach_object_instance_id(instance: RID, id: int) 🔗

Приєднує унікальний ідентифікатор об'єкта до екземпляра. Ідентифікатор об'єкта має бути приєднаний до екземпляра для правильного відсіювання за допомогою методів instances_cull_aabb(), instances_cull_convex() та instances_cull_ray().

void instance_attach_skeleton(instance: RID, skeleton: RID) 🔗

Прикріплює скелет до екземпляра. Видаліть попередній скелет з екземпляра.

RID instance_create() 🔗

Створює візуальний екземпляр і додає його на RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх instance_* RenderingServer функції.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Прикладом є спосіб розміщення об'єкта 3D у сценарії. Об'єкти, такі як частинки, сітки, відбиття зон і декалі повинні бути пов'язані з екземпляром, щоб бути видимими в сценарії за допомогою instance_set_base().

Примітка: Об'ємний вузол VisualInstance3D.

RID instance_create2(base: RID, scenario: RID) 🔗

Створює візуальний екземпляр, додає його до RenderingServer та встановлює як базові, так і сценарні значення. Доступ до нього можна отримати за допомогою повернутого RID. Цей RID використовуватиметься у всіх функціях RenderingServer instance_*.

Після завершення створення RID вам потрібно звільнити його за допомогою методу free_rid() RenderingServer. Це скорочення для використання instance_create() та ручного встановлення базових значень та сценарію.

Variant instance_geometry_get_shader_parameter(instance: RID, parameter: StringName) const 🔗

Повертає значення уніформи перистансного шейра з вказаного екземпляра геометрії 3D. Equivalent to GeometryInstance3D.get_instance_shader_parameter().

Примітка: Ім'я параметра Per-instance відтінку є чутливим.

Variant instance_geometry_get_shader_parameter_default_value(instance: RID, parameter: StringName) const 🔗

Повертає значення за замовчуванням уніформи затримки від вказаного екземпляра геометрії 3D. Equivalent to GeometryInstance3D.get_instance_shader_parameter().

Array[Dictionary] instance_geometry_get_shader_parameter_list(instance: RID) const 🔗

Повертає словник однорідних імен шейдерів для кожного екземпляра уніформи шейдера для кожного екземпляра з указаного екземпляра 3D-геометрії. Повернений словник має формат PropertyInfo з ключами назва, назва_класу, тип, підказка, `` hint_string`` і використання. Еквівалент GeometryInstance3D.get_instance_shader_parameter().

void instance_geometry_set_cast_shadows_setting(instance: RID, shadow_casting_setting: ShadowCastingSetting) 🔗

Встановлює параметр відкидання тіні. Еквівалентно GeometryInstance3D.cast_shadow.

void instance_geometry_set_flag(instance: RID, flag: InstanceFlags, enabled: bool) 🔗

Встановлює flag для даного instance до enabled.

void instance_geometry_set_lightmap(instance: RID, lightmap: RID, lightmap_uv_scale: Rect2, lightmap_slice: int) 🔗

Налаштовує екземпляр Lightmap GI для використання за вказаною геометрією 3D. Легка карта УФ-масштаб для вказаного екземпляра (еквівалента до GeometryInstance3D.gi_lightmap_scale) та скибочку на вкладці Lightmap також повинні бути вказані.

void instance_geometry_set_lod_bias(instance: RID, lod_bias: float) 🔗

Налаштовує рівень детабелів, які можна використовувати при рендерингу вказаної геометрії 3D. Більшість значень, що призводить до більш високої деталі з подальшої роботи. Еквівалентно GeometryInstance3D.lod_bias.

void instance_geometry_set_material_overlay(instance: RID, material: RID) 🔗

Встановлює матеріал, який буде надано для всіх поверхонь на верхній частині активних матеріалів для сітки, пов'язаних з цим екземпляром. Еквівалентно GeometryInstance3D.material_overlay.

void instance_geometry_set_material_override(instance: RID, material: RID) 🔗

Встановлює матеріал, який перенаречений на всі поверхні на сітці, пов'язаний з цим екземпляром. Еквівалентно GeometryInstance3D.material_override.

void instance_geometry_set_shader_parameter(instance: RID, parameter: StringName, value: Variant) 🔗

Встановлює рівномірність шейдера для кожного екземпляра на вказаному екземплярі 3D-геометрії. Еквівалентно GeometryInstance3D.set_instance_shader_parameter().

void instance_geometry_set_transparency(instance: RID, transparency: float) 🔗

Встановлює прозорість для заданого екземпляра геометрії. Еквівалентно GeometryInstance3D.transparency.

Прозорість зі значенням 0.0 є повністю непрозорою, тоді як 1.0 є повністю прозорою. Значення, більші за 0.0 (виключно), змусять матеріали геометрії проходити через конвеєр прозорості, що повільніше рендериться та може призвести до проблем з рендерингом через неправильне сортування прозорості. Однак, на відміну від використання прозорого матеріалу, встановлення значення transparency більше, ніж 0.0 (виключно), не вимкне рендеринг тіней.

У просторових шейдерах 1.0 - transparency встановлено як значення за замовчуванням для вбудованого ALPHA.

Примітка: Параметр prozornost обмежено значеннями між 0.0 та 1.0, тому цю властивість не можна використовувати для того, щоб зробити прозорі матеріали більш непрозорими, ніж вони є спочатку.

void instance_geometry_set_visibility_range(instance: RID, min: float, max: float, min_margin: float, max_margin: float, fade_mode: VisibilityRangeFadeMode) 🔗

Налаштовує значення діапазону видимості для вказаної геометрії. Еквівалентно GeometryInstance3D.visibility_range_begin та суміжні властивості.

void instance_set_base(instance: RID, base: RID) 🔗

Встановлює основу екземпляра. Основа може бути будь-яким з об'єктів 3D, які створюються в RenderingServer, які можна відображати. Наприклад, будь-який з легких типів, сітки, багатомеш, системи частинок, відображення зон, декаль, світлова карта, voxel GI і видимі ноти є всі види, які можуть бути встановлені в якості основи екземпляра для відображення в сценарії.

void instance_set_blend_shape_weight(instance: RID, shape: int, weight: float) 🔗

Налаштовує вагу для даної форми блендера, пов'язаної з цим екземпляром.

void instance_set_custom_aabb(instance: RID, aabb: AABB) 🔗

Встановлює власний AABB для використання під час відсікання об'єктів зі зрізаного вигляду. Еквівалентно налаштуванню GeometryInstance3D.custom_aabb.

void instance_set_extra_visibility_margin(instance: RID, margin: float) 🔗

Встановлює відступ для збільшення розміру AABB під час вилучення об'єктів зі зрізаної шкали. Це дозволяє уникнути вилучення об'єктів, які знаходяться за межами зрізаної шкали. Еквівалентно GeometryInstance3D.extra_cull_margin.

void instance_set_ignore_culling(instance: RID, enabled: bool) 🔗

Якщо true, ігнорується як відсікання усіченої кривої, так і відсікання перекриття для зазначеного екземпляра 3D-геометрії. Це не те саме, що GeometryInstance3D.ignore_occlusion_culling, який ігнорує лише відсікання перекриття та залишає відсікання усіченої кривої недоторканим.

void instance_set_layer_mask(instance: RID, mask: int) 🔗

Встановлює рендерні шари, які цей екземпляр буде намальовано. Еквівалент до VisualInstance3D.layers.

void instance_set_pivot_data(instance: RID, sorting_offset: float, use_aabb_center: bool) 🔗

Налаштовує відсортування і вимикачі між за допомогою закривної коробки або походженням екземпляра для сортування глибини.

void instance_set_scenario(instance: RID, scenario: RID) 🔗

Налаштовує скрипт, що екземпляр знаходиться в. Скрипт – 3D світ, який буде відображатися в об’єктах.

void instance_set_surface_override_material(instance: RID, surface: int, material: RID) 🔗

Налаштовує надрізний матеріал певної поверхні. Equivalent to MeshInstance3D.set_surface_override_material().

void instance_set_transform(instance: RID, transform: Transform3D) 🔗

Встановлює перетворення світового простору екземпляра. Еквівалентно Node3D.global_transform.

void instance_set_visibility_parent(instance: RID, parent: RID) 🔗

Встановлює батьківський об'єкт видимості для заданого екземпляра. Еквівалентно Node3D.visibility_parent.

void instance_set_visible(instance: RID, visible: bool) 🔗

Встановлює, чи відображатиметься екземпляр чи ні. Еквівалентно Node3D.visible.

void instance_teleport(instance: RID) 🔗

Скидає вектори руху та інші інтерпольовані значення. Використовуйте це після телепортації сітки з однієї позиції в іншу, щоб уникнути артефактів ghosting.

PackedInt64Array instances_cull_aabb(aabb: AABB, scenario: RID = RID()) const 🔗

Повертає масив ідентифікаторів об'єкта, що перетинаються з наданою AABB. Тільки 3D-вузли, які успадкують від VisualInstance3D, такі як MeshInstance3D або DirectionalLight3D. Використовуйте @GlobalScope.instance_from_id() для отримання фактичних вузлів. Скрипт RID повинен бути надана, яка доступна в World3D, ви хочете переробити. Це змушує оновлення для всіх ресурсів, що чергуються до оновлення.

Попередження: Ця функція призначена для використання редактора. Для випадків використання ігор, віддають перевагу фізичним зіткненню.

PackedInt64Array instances_cull_convex(convex: Array[Plane], scenario: RID = RID()) const 🔗

Повертає масив ідентифікаторів об'єкта, що перетинаються з заданою формою опуклості. Тільки 3D-вузли, які успадкують від VisualInstance3D, такі як MeshInstance3D або DirectionalLight3D. Використовуйте @GlobalScope.instance_from_id() для отримання фактичних вузлів. Скрипт RID повинен бути надана, яка доступна в World3D, ви хочете переробити. Це змушує оновлення для всіх ресурсів, що чергуються до оновлення.

Попередження: Ця функція призначена для використання редактора. Для випадків використання ігор, віддають перевагу фізичним зіткненню.

PackedInt64Array instances_cull_ray(from: Vector3, to: Vector3, scenario: RID = RID()) const 🔗

Повертає масив ідентифікаторів об'єкта, що перетинаються з наданою променем 3D. Тільки 3D-вузли, які успадкують від VisualInstance3D, такі як MeshInstance3D або DirectionalLight3D. Використовуйте @GlobalScope.instance_from_id() для отримання фактичних вузлів. Скрипт RID повинен бути надана, яка доступна в World3D, ви хочете переробити. Це змушує оновлення для всіх ресурсів, що чергуються до оновлення.

Попередження: Ця функція призначена для використання редактора. Для випадків використання ігор, віддають перевагу фізичним зіткненню.

bool is_on_render_thread() 🔗

Повертаємо true, якщо наш код наразі виконується на рендерингу нитки.

void light_directional_set_blend_splits(light: RID, enable: bool) 🔗

Якщо true, цей спрямований світло буде поєднуватися між розділами shadow map, що призводить до плавного переходу між ними. Еквівалентно DirectionalLight3D.direct_shadow_blend_splits.

void light_directional_set_shadow_mode(light: RID, mode: LightDirectionalShadowMode) 🔗

Встановлює режим тіні для цього спрямованого світла. Еквівалентно DirectionalLight3D.directional_shadow_mode.

void light_directional_set_sky_mode(light: RID, mode: LightDirectionalSkyMode) 🔗

Якщо true, це світло не буде використовуватися для будь-якого, крім небесних тіней. Використовуйте це для вогнів, які впливають на ваше небо відтінок, які ви можете приховати від впливу на решту сцени. Наприклад, ви можете ввімкнути це, коли сонце в небі шейдер потрапляє нижче горизонту.

void light_omni_set_shadow_mode(light: RID, mode: LightOmniShadowMode) 🔗

Встановлює, чи використовувати подвійну параболоїдну або кубічну карту для shadow map. Подвійний параболоїд швидше, але може постраждати від артефактів. Еквівалентно OmniLight3D.omni_shadow_mode.

void light_projectors_set_filter(filter: LightProjectorFilter) 🔗

Встановлює режим фактурного фільтра для використання при рендерингу світлових проекторів. Цей параметр є глобальним і не може бути встановлений на основі просвіту.

void light_set_bake_mode(light: RID, bake_mode: LightBakeMode) 🔗

Встановлює режим випікання, який використовуватиметься для вказаного 3D-світла. Еквівалентно Light3D.light_bake_mode.

void light_set_color(light: RID, color: Color) 🔗

Встановлює колір світла. Еквівалентно Light3D.light_color.

void light_set_cull_mask(light: RID, mask: int) 🔗

Встановлює маску відсікання для цього 3D-світла. Світло впливає лише на об'єкти у вибраних шарах. Еквівалентно Light3D.light_cull_mask.

void light_set_distance_fade(decal: RID, enabled: bool, begin: float, shadow: float, length: float) 🔗

Встановлює відстань згасання для цього 3D-світла. Це діє як форма рівня деталізації (LOD) і може бути використано для покращення продуктивності. Еквівалентно Light3D.distance_fade_enabled, Light3D.distance_fade_begin, Light3D.distance_fade_shadow, і Light3D.distance_fade_length.

void light_set_max_sdfgi_cascade(light: RID, cascade: int) 🔗

Налаштовує максимальну каскад SDFGI, в якій наведено непряме освітлення 3D. Найвищі значення дозволяють світло надавати в SDFGI додатково від камери.

void light_set_negative(light: RID, enable: bool) 🔗

Якщо true, 3D-світло відніматиме світло замість додавання. Еквівалентно Light3D.light_negative.

void light_set_param(light: RID, param: LightParam, value: float) 🔗

Встановлює вказаний параметр 3D-світла. Еквівалентно Light3D.set_param().

void light_set_projector(light: RID, texture: RID) 🔗

Встановлює текстуру проектора, яка використовуватиметься для вказаного 3D-світла. Еквівалентно Light3D.light_projector.

void light_set_reverse_cull_face_mode(light: RID, enabled: bool) 🔗

Якщо true, змінює відсікання задньої поверхні сітки на зворотне. Це може бути корисним, коли у вас є плоска сітка, за якою є світло. Якщо вам потрібно відкинути тінь з обох боків сітки, налаштуйте для сітки використання двосторонніх тіней за допомогою методу instance_geometry_set_cast_shadows_setting(). Еквівалентно Light3D.shadow_reverse_cull_face.

void light_set_shadow(light: RID, enabled: bool) 🔗

Якщо true, світло відкидатиме тіні. Еквівалентно Light3D.shadow_enabled.

void light_set_shadow_caster_mask(light: RID, mask: int) 🔗

Встановлює маску відкидання тіней для цього 3D-світла. Тіні будуть відкидатися лише за допомогою об'єктів у вибраних шарах. Еквівалентно Light3D.shadow_caster_mask.

RID lightmap_create() 🔗

Створення нової світлової карти глобального освітлення екземпляра і додає її до RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх lightmap_* Функції RenderingServer.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: Важкий вузол LightmapGI.

PackedInt32Array lightmap_get_probe_capture_bsp_tree(lightmap: RID) const 🔗

There is currently no description for this method. Please help us by contributing one!

PackedVector3Array lightmap_get_probe_capture_points(lightmap: RID) const 🔗

There is currently no description for this method. Please help us by contributing one!

PackedColorArray lightmap_get_probe_capture_sh(lightmap: RID) const 🔗

There is currently no description for this method. Please help us by contributing one!

PackedInt32Array lightmap_get_probe_capture_tetrahedra(lightmap: RID) const 🔗

There is currently no description for this method. Please help us by contributing one!

void lightmap_set_baked_exposure_normalization(lightmap: RID, baked_exposure: float) 🔗

Використовується для інформування рендерера, яке значення нормалізації експозиції використовувався при випіканні мапи. Ця величина буде використана і модулюється в часі запуску, щоб переконатися, що Lightmap підтримує послідовний рівень впливу, навіть якщо нормалізація висоти сцени змінюється в часі. Для отримання додаткової інформації див. camera_attributes_set_exposure().

void lightmap_set_probe_bounds(lightmap: RID, bounds: AABB) 🔗

There is currently no description for this method. Please help us by contributing one!

void lightmap_set_probe_capture_data(lightmap: RID, points: PackedVector3Array, point_sh: PackedColorArray, tetrahedra: PackedInt32Array, bsp_tree: PackedInt32Array) 🔗

There is currently no description for this method. Please help us by contributing one!

void lightmap_set_probe_capture_update_speed(speed: float) 🔗

There is currently no description for this method. Please help us by contributing one!

void lightmap_set_probe_interior(lightmap: RID, interior: bool) 🔗

There is currently no description for this method. Please help us by contributing one!

void lightmap_set_textures(lightmap: RID, light: RID, uses_sh: bool) 🔗

Встановіть текстури на даній lightmap GI екземпляр до фактурного масиву, зазначеного до light RID. true, потім use_sh повинен бути true.

void lightmaps_set_bicubic_filter(enable: bool) 🔗

Перемикає, чи слід використовувати бікубічний фільтр під час вибірки карт освітлення. Це згладжує їх зовнішній вигляд за меншої продуктивності.

RID make_sphere_mesh(latitudes: int, longitudes: int, radius: float) 🔗

Повертає сітку сфери із заданою кількістю горизонтальних поділів, вертикальних поділів та радіусом. Див. також get_test_cube().

RID material_create() 🔗

Створює порожній матеріал і додає його рендерингу. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх material_* Функції RenderingServer.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: При еквіваленті ресурсу Material.

Variant material_get_param(material: RID, parameter: StringName) const 🔗

Повертає значення параметра певного матеріалу.

void material_set_next_pass(material: RID, next_material: RID) 🔗

Налаштовує наступний матеріал об'єкта.

void material_set_param(material: RID, parameter: StringName, value: Variant) 🔗

Встановлює параметр матеріалу.

void material_set_render_priority(material: RID, priority: int) 🔗

Налаштовує пріоритетність матеріалу.

void material_set_shader(shader_material: RID, shader: RID) 🔗

Налаштовує шейдер тіні.

void mesh_add_surface(mesh: RID, surface: Dictionary) 🔗

There is currently no description for this method. Please help us by contributing one!

void mesh_add_surface_from_arrays(mesh: RID, primitive: PrimitiveType, arrays: Array, blend_shapes: Array = [], lods: Dictionary = {}, compress_format: BitField[ArrayFormat] = 0) 🔗

There is currently no description for this method. Please help us by contributing one!

void mesh_clear(mesh: RID) 🔗

Видаліть всі поверхні з сітки.

RID mesh_create() 🔗

Створює нову сітку та додає її до RenderingServer. До неї можна отримати доступ за допомогою повернутого RID. Цей RID буде використовуватися у всіх функціях RenderingServer mesh_*.

Після завершення роботи з RID вам потрібно звільнити RID за допомогою методу RenderingServer free_rid().

Щоб розмістити її в сцені, приєднайте цю сітку до екземпляра за допомогою методу instance_set_base(), використовуючи повернутий RID.

Примітка: Еквівалентним ресурсом є Mesh.

RID mesh_create_from_surfaces(surfaces: Array[Dictionary], blend_shape_count: int = 0) 🔗

There is currently no description for this method. Please help us by contributing one!

int mesh_get_blend_shape_count(mesh: RID) const 🔗

Повертаємо кількість форми сітки.

BlendShapeMode mesh_get_blend_shape_mode(mesh: RID) const 🔗

Повертаємо режим форми сітки.

AABB mesh_get_custom_aabb(mesh: RID) const 🔗

Повертає на користувацьку абашку сітки.

Dictionary mesh_get_surface(mesh: RID, surface: int) 🔗

There is currently no description for this method. Please help us by contributing one!

int mesh_get_surface_count(mesh: RID) const 🔗

Повертаємо кількість поверхонь сітки.

void mesh_set_blend_shape_mode(mesh: RID, mode: BlendShapeMode) 🔗

Налаштовує режим форми сітки.

void mesh_set_custom_aabb(mesh: RID, aabb: AABB) 🔗

Налаштовує на замовлення сітки.

void mesh_set_shadow_mesh(mesh: RID, shadow_mesh: RID) 🔗

There is currently no description for this method. Please help us by contributing one!

Array mesh_surface_get_arrays(mesh: RID, surface: int) const 🔗

Повертає масиви буферів поверхні сітки.

Array[Array] mesh_surface_get_blend_shape_arrays(mesh: RID, surface: int) const 🔗

Повертає масиви поверхні сітки для форм змішування.

int mesh_surface_get_format_attribute_stride(format: BitField[ArrayFormat], vertex_count: int) const 🔗

Повертає термін дії буфера атрибута на сіточку з наданою format.

int mesh_surface_get_format_index_stride(format: BitField[ArrayFormat], vertex_count: int) const 🔗

Повертає крок індексного буфера для сітки з заданим format.

int mesh_surface_get_format_normal_tangent_stride(format: BitField[ArrayFormat], vertex_count: int) const 🔗

Повертає пасиду комбінованих нормалей і тангенсів для сітки з даними format. Зверніть увагу на те, що в той час як нормали і тангенси знаходяться в буфері вершини з вершинами, вони тільки взаємопов'язані один з одним і тому мають різну позицію, ніж позиції вершини.

int mesh_surface_get_format_offset(format: BitField[ArrayFormat], vertex_count: int, array_index: int) const 🔗

Повертає зміщення даної атрибути array_index у старті відповідного буфера.

int mesh_surface_get_format_skin_stride(format: BitField[ArrayFormat], vertex_count: int) const 🔗

Повертає крок буфера шкіри для сітки з заданим format.

int mesh_surface_get_format_vertex_stride(format: BitField[ArrayFormat], vertex_count: int) const 🔗

Повертає крок позицій вершин для сітки із заданим форматом format. Важливо зазначити, що позиції вершин зберігаються послідовно та не чергуються з іншими атрибутами у буфері вершин (нормалями та дотичними).

RID mesh_surface_get_material(mesh: RID, surface: int) const 🔗

Повертає матеріал поверхні сітки.

void mesh_surface_remove(mesh: RID, surface: int) 🔗

Видаляє поверхню з заданим індексом із сітки, зміщуючи поверхні з вищим індексом на одиницю вниз.

void mesh_surface_set_material(mesh: RID, surface: int, material: RID) 🔗

Встановлює матеріал поверхні сітки.

void mesh_surface_update_attribute_region(mesh: RID, surface: int, offset: int, data: PackedByteArray) 🔗

There is currently no description for this method. Please help us by contributing one!

void mesh_surface_update_index_region(mesh: RID, surface: int, offset: int, data: PackedByteArray) 🔗

Оновлює індексний буфер поверхні сітки заданим значенням data. Очікувані дані – це 16- або 32-бітні беззнакові цілі числа, які можна визначити за допомогою mesh_surface_get_format_index_stride().

void mesh_surface_update_skin_region(mesh: RID, surface: int, offset: int, data: PackedByteArray) 🔗

There is currently no description for this method. Please help us by contributing one!

void mesh_surface_update_vertex_region(mesh: RID, surface: int, offset: int, data: PackedByteArray) 🔗

There is currently no description for this method. Please help us by contributing one!

void multimesh_allocate_data(multimesh: RID, instances: int, transform_format: MultimeshTransformFormat, color_format: bool = false, custom_data_format: bool = false, use_indirect: bool = false) 🔗

There is currently no description for this method. Please help us by contributing one!

RID multimesh_create() 🔗

Створює нову мультисітку на RenderingServer та повертає дескриптор RID. Цей RID буде використовуватися у всіх функціях multimesh_* RenderingServer.

Після завершення роботи з RID вам потрібно звільнити RID за допомогою методу free_rid() RenderingServer.

Щоб розмістити її в сцені, приєднайте цю мультисітку до екземпляра за допомогою методу instance_set_base(), використовуючи повернутий RID.

Примітка: Еквівалентним ресурсом є MultiMesh.

AABB multimesh_get_aabb(multimesh: RID) const 🔗

Обчислення і повернення вісь вирівнюється коробочка, яка закриває всі екземпляри в мультимеш.

PackedFloat32Array multimesh_get_buffer(multimesh: RID) const 🔗

Повертає дані MultiMesh (такі як перетворення екземплярів, кольори тощо). Див. multimesh_set_buffer() для отримання детальної інформації про повернуті дані.

Примітка: Якщо буфер знаходиться у внутрішньому кеші движка, його потрібно буде отримати з пам'яті графічного процесора та, можливо, розпакувати. Це означає, що multimesh_get_buffer() потенційно є повільною операцією, і її слід уникати, коли це можливо.

RID multimesh_get_buffer_rd_rid(multimesh: RID) const 🔗

Повертає дескриптор RenderingDevice RID MultiMesh, який можна використовувати як будь-який інший буфер на пристрої рендерингу.

RID multimesh_get_command_buffer_rd_rid(multimesh: RID) const 🔗

Повертає дескриптор RenderingDevice RID буфера команд MultiMesh. Цей RID є дійсним, лише якщо use_indirect має значення true під час розподілу даних через multimesh_allocate_data(). Його можна використовувати для безпосередньої зміни кількості екземплярів через буфер.

Структура даних залежить як від того, скільки поверхонь містить сітка, так і від того, проіндексована вона чи ні, буфер містить 5 цілих чисел, останнє з яких не використовується, якщо сітка не проіндексована.

Кожне зі значень у буфері відповідає цим параметрам:

Indexed:
- indexCount;
- instanceCount;
- firstIndex;
- vertexOffset;
- firstInstance;
Non Indexed:
- vertexCount;
- instanceCount;
- firstVertex;
- firstInstance;
- unused;

AABB multimesh_get_custom_aabb(multimesh: RID) const 🔗

Повертає користувацький AABB, визначений для цього багатомецького ресурсу.

int multimesh_get_instance_count(multimesh: RID) const 🔗

Повертає кількість екземплярів, виділених для цього м'яса.

RID multimesh_get_mesh(multimesh: RID) const 🔗

Повертаємо RID сітки, яка буде використовуватися в малюнку цього м'яса.

int multimesh_get_visible_instances(multimesh: RID) const 🔗

Повертає кількість видимих екземплярів для цього мультимеш.

Color multimesh_instance_get_color(multimesh: RID, index: int) const 🔗

Повернення кольору, за допомогою якого буде модулювати зазначений екземпляр.

Color multimesh_instance_get_custom_data(multimesh: RID, index: int) const 🔗

Повертає користувацькі дані, пов'язані з зазначеним екземпляром.

Transform3D multimesh_instance_get_transform(multimesh: RID, index: int) const 🔗

Повертає Transform3D зазначеного екземпляра.

Transform2D multimesh_instance_get_transform_2d(multimesh: RID, index: int) const 🔗

Повернення Transform2D вказаного екземпляра. Для використання при багатомешці встановлюється використання 2D трансформаторів.

void multimesh_instance_reset_physics_interpolation(multimesh: RID, index: int) 🔗

Запобігає фізичній інтерполяції для вказаного екземпляра протягом поточного фізичного тику.

Це корисно під час переміщення екземпляра в нове місце, щоб забезпечити миттєву зміну, а не інтерполяцію з попереднього розташування.

void multimesh_instance_set_color(multimesh: RID, index: int, color: Color) 🔗

Встановлює колір, за яким буде модулюватися цей екземпляр. Еквівалентно MultiMesh.set_instance_color().

void multimesh_instance_set_custom_data(multimesh: RID, index: int, custom_data: Color) 🔗

Встановлює користувацькі дані для цього екземпляра. Користувальницькі дані продаються як Color, але інтерпретуються як vec4 в тіні. Equivalent to MultiMesh.set_instance_custom_data().

void multimesh_instance_set_transform(multimesh: RID, index: int, transform: Transform3D) 🔗

Налаштовує Transform3D для цього екземпляра. Еквівалентно MultiMesh.set_instance_transform().

void multimesh_instance_set_transform_2d(multimesh: RID, index: int, transform: Transform2D) 🔗

Налаштовує Transform2D для цього екземпляра. Для використання при багатомешці використовується в 2D. Еквівалентно MultiMesh.set_instance_transform_2d().

void multimesh_set_buffer(multimesh: RID, buffer: PackedFloat32Array) 🔗

Встановіть усі дані для використання для малювання multimesh одночасно в buffer (наприклад, трансформації екземплярів і кольори). Розмір buffer має відповідати кількості екземплярів, помноженій на розмір даних кожного екземпляра (який залежить від увімкнених полів MultiMesh). В іншому випадку друкується повідомлення про помилку, і нічого не відображається. Дивіться також multimesh_get_buffer().

Розмір даних для екземпляра та очікуваний порядок даних:

2D:
  - Позиція: 8 floats (8 floats для Transform2D)
  - Позиція + колір вершини: 12 поплавків (8 поплавків для Transform2D, 4 поплавки для кольору)
  - Позиція + користувацькі дані: 12 плаваючих елементів (8 плаваючих місць для Transform2D, 4 плаваючих користувацьких даних)
  - Позиція + Колір вершини + Користувальницькі дані: 16 плаваючих елементів (8 плаваючих елементів для Transform2D, 4 плаваючих рядка для кольору, 4 плаваючих рядка користувацьких даних)
3D:
  - Позиція: 12 поплавків (12 поплавків для Transform3D)
  - Позиція + колір вершини: 16 поплавків (12 поплавків для Transform3D, 4 поплавки для кольору)
  - Позиція + користувальницькі дані: 16 плаваючих елементів (12 плаваючих місць для Transform3D, 4 плаваючих числа користувацьких даних)
  - Позиція + Колір вершини + Користувальницькі дані: 20 поплавків (12 поплавків для Transform3D, 4 поплавки для кольору, 4 поплавки користувацьких даних)

Перетворення екземплярів виконуються в порядку старшого рядка. зокрема:

Для Transform2D плаваючий порядок такий: (x.x, y.x, padding_float, origin.x, x.y, y.y, padding_float, origin.y).
Для Transform3D плаваючий порядок такий: (basis.x.x, basis.y.x, basis.z.x, origin.x, basis.x.y, basis.y.y, basis.z.y, origin.y, basis.x.z, basis.y.z, basis.z.z, origin.z).

void multimesh_set_buffer_interpolated(multimesh: RID, buffer: PackedFloat32Array, buffer_previous: PackedFloat32Array) 🔗

Альтернативна версія multimesh_set_buffer() для використання з фізичною інтерполяцією.

Бере як масив поточних даних, так і масив даних для попереднього фізичного тику.

void multimesh_set_custom_aabb(multimesh: RID, aabb: AABB) 🔗

Налаштування користувальницького AABB для цього багатомецького ресурсу.

void multimesh_set_mesh(multimesh: RID, mesh: RID) 🔗

Встановлює сітку, яку буде малювати мультисітка. Еквівалентно MultiMesh.mesh.

void multimesh_set_physics_interpolated(multimesh: RID, interpolated: bool) 🔗

Вмикає та вимикає фізичну інтерполяцію для цього ресурсу MultiMesh.

void multimesh_set_physics_interpolation_quality(multimesh: RID, quality: MultimeshPhysicsInterpolationQuality) 🔗

Встановлює якість інтерполяції фізики для MultiMesh.

Значення MULTIMESH_INTERP_QUALITY_FAST дає швидку, але низькоякісну інтерполяцію, значення MULTIMESH_INTERP_QUALITY_HIGH дає повільнішу, але якіснішу інтерполяцію.

void multimesh_set_visible_instances(multimesh: RID, visible: int) 🔗

Встановлює кількість видимих екземплярів у заданий момент часу. Якщо -1, відображаються всі виділені екземпляри. Еквівалентно MultiMesh.visible_instance_count.

RID occluder_create() 🔗

Створює екземпляр оклюцера і додає його до RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх occluder_* Функції RenderingServer.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: еквівалентний ресурс Occluder3D (не плутати з OccluderInstance3D вершина).

void occluder_set_mesh(occluder: RID, vertices: PackedVector3Array, indices: PackedInt32Array) 🔗

Налаштовує дані сітки для даного оклюцера RID, яка контролює форму кульки оклюзії, яка буде виконана.

RID omni_light_create() 🔗

Створює новий омні світло і додає його до RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID можна використовувати в більшості light_* RenderingServer функції.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Щоб розміститися в сцені, прикріпіть цей омний світло до екземпляра за допомогою instance_set_base() за допомогою повернутого RID.

Примітка: Важкий вузол OmniLight3D.

RID particles_collision_create() 🔗

Створює новий зіткнення частинок 3D GPU або приваблює його до RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID може використовуватися в більшості `` particles_collision_*`` RenderingServer функції.

Примітка: Вирівнюючі вузли GPUParticlesCollision3D і GPUParticlesAttractor3D.

void particles_collision_height_field_update(particles_collision: RID) 🔗

Запитує оновлення для 3D GPU з висоти зіткнення. Це може бути автоматично викликаний 3D GPU Висота зіткнень залежно від його GPUPaarticleCollisionHeightField3D.update_mode.

void particles_collision_set_attractor_attenuation(particles_collision: RID, curve: float) 🔗

Встановлює затухання curve для 3D-аттрактора частинок GPU, заданого RID particles_collision. Використовується лише для атракторів, а не для колайдерів. Еквівалентно GPUParticlesAttractor3D.attenuation.

void particles_collision_set_attractor_directionality(particles_collision: RID, amount: float) 🔗

Встановлює спрямованість amount для 3D-атрактора частинок GPU, визначеного RID particles_collision. Використовується лише для атракторів, а не для колайдерів. Еквівалентно GPUParticlesAttractor3D.directionality.

void particles_collision_set_attractor_strength(particles_collision: RID, strength: float) 🔗

Встановлює strength для атрактора 3D-частинок GPU, заданого RID particles_collision. Використовується лише для атракторів, а не для колайдерів. Еквівалентно GPUParticlesAttractor3D.strength.

void particles_collision_set_box_extents(particles_collision: RID, extents: Vector3) 🔗

Встановлює значення extents для зіткнення 3D-частинок GPU за допомогою RID particles_collision. Еквівалентно GPUParticlesCollisionBox3D.size, GPUParticlesCollisionSDF3D.size, GPUParticlesCollisionHeightField3D.size, GPUParticlesAttractorBox3D.size або GPUParticlesAttractorVectorField3D.size залежно від типу particles_collision.

void particles_collision_set_collision_type(particles_collision: RID, type: ParticlesCollisionType) 🔗

Встановлює форму зіткнення або атрактора type для зіткнення або атрактора 3D-частинок GPU, визначеного RID particles_collision.

void particles_collision_set_cull_mask(particles_collision: RID, mask: int) 🔗

Встановлює маску вибракування mask для зіткнення або атрактора 3D-частинок GPU, визначеного RID particles_collision. Еквівалентно GPUParticlesCollision3D.cull_mask або GPUParticlesAttractor3D.cull_mask залежно від типу particles_collision.

void particles_collision_set_field_texture(particles_collision: RID, texture: RID) 🔗

Встановлює поле відстані зі знаком texture для зіткнення 3D-частинок GPU, визначеного RID particles_collision. Еквівалентно GPUParticlesCollisionSDF3D.texture або GPUParticlesAttractorVectorField3D.texture залежно від типу particles_collision.

void particles_collision_set_height_field_mask(particles_collision: RID, mask: int) 🔗

Встановлює поле висоти mask для колізії поля висоти 3D-частинок GPU, визначеної RID particles_collision. Еквівалентно GPUParticlesCollisionHeightField3D.heightfield_mask.

void particles_collision_set_height_field_resolution(particles_collision: RID, resolution: ParticlesCollisionHeightfieldResolution) 🔗

Встановлює карту висот resolution для колізії висотних полів 3D-частинок GPU, визначеної RID particles_collision. Еквівалентно GPUParticlesCollisionHeightField3D.resolution.

void particles_collision_set_sphere_radius(particles_collision: RID, radius: float) 🔗

Налаштовує radius для зіткнення частин 3D GPU або приваблювача, вказаний particles_collision РАЙД. Equivalent to GPUPaarticleCollisionSphere3D.radius або пам'яний графічний процесорSphere3D.radius залежно від типу particles_collision.

RID particles_create() 🔗

Створює систему частинок GPU і додає її до RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх частини_* Функції RenderingServer.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Щоб розмістити на сцені, прикріпіть ці частинки до екземпляра за допомогою free_rid() за допомогою повернутого RID.

Примітка: Вирівнюючі вузли GPUParticles2D і GPUParticles3D.

Примітка: Всі частинки_* методи застосовуються тільки до частинок GPU, а не частинок процесора. CPUParticles2D і CPUParticles3D не мають еквівалентних функцій RenderingServer, оскільки це використання MultiMeshInstance2D і MultiMeshInstance3D під капюшоном (див. multimesh_* методи).

void particles_emit(particles: RID, transform: Transform3D, velocity: Vector3, color: Color, custom: Color, emit_flags: int) 🔗

Ручно випромінює частинки з екземпляра парам.

AABB particles_get_current_aabb(particles: RID) 🔗

Обчислює та повертає обмежувальну рамку, вирівняну по осях, яка містить усі частинки. Еквівалентно GPUParticles3D.capture_aabb().

bool particles_get_emitting(particles: RID) 🔗

Повертає true, якщо частинки в даний час встановлюються для випромінювання.

bool particles_is_inactive(particles: RID) 🔗

Повертає true, якщо частинки не випромінюються і частинки встановлюються до неактивності.

void particles_request_process(particles: RID) 🔗

Додати систему частинок до списку систем частинок, які потрібно оновити. Оновлення відбудеться на наступному кадрі або на наступному виклику функції instances_cull_aabb(), instances_cull_convex(), або instances_cull_ray().

void particles_request_process_time(particles: RID, time: float) 🔗

Запитує частки на обробку протягом додаткового часу обробки протягом одного кадру.

void particles_restart(particles: RID) 🔗

Скинути налаштування частинок під час наступного оновлення. Еквівалентно GPUParticles3D.restart().

void particles_set_amount(particles: RID, amount: int) 🔗

Встановлює кількість частинок, які потрібно відобразити, та виділяє для них пам'ять. Еквівалентно GPUParticles3D.amount.

void particles_set_amount_ratio(particles: RID, ratio: float) 🔗

Встановлює співвідношення кількості частинок, що викидаються. Еквівалентно GPUParticles3D.amount_ratio.

void particles_set_collision_base_size(particles: RID, size: float) 🔗

There is currently no description for this method. Please help us by contributing one!

void particles_set_custom_aabb(particles: RID, aabb: AABB) 🔗

Встановлює власну обмежувальну рамку, вирівняну по осях, для системи частинок. Еквівалентно GPUParticles3D.visibility_aabb.

void particles_set_draw_order(particles: RID, order: ParticlesDrawOrder) 🔗

Встановлює порядок малювання частинок. Еквівалентно GPUParticles3D.draw_order.

void particles_set_draw_pass_mesh(particles: RID, pass: int, mesh: RID) 🔗

Встановлює сітку, яка буде використовуватися для заданого проходу малювання. Еквівалентно GPUParticles3D.draw_pass_1, GPUParticles3D.draw_pass_2, GPUParticles3D.draw_pass_3, і GPUParticles3D.draw_pass_4.

void particles_set_draw_passes(particles: RID, count: int) 🔗

Встановлює кількість проходів малювання, які потрібно використовувати. Еквівалентно GPUParticles3D.draw_passes.

void particles_set_emission_transform(particles: RID, transform: Transform3D) 🔗

Налаштовує Transform3D, які будуть використовуватися частинками, коли вони вперше випромінюють.

void particles_set_emitter_velocity(particles: RID, velocity: Vector3) 🔗

Встановлює швидкість вузла частинки, яка буде використовуватися ParticleProcessMaterial.inherit_velocity_ratio.

void particles_set_emitting(particles: RID, emitting: bool) 🔗

Якщо true, частинки випромінюватимуться з часом. Встановлення значення false не скидає частинки, а лише припиняє їх випромінювання. Еквівалент GPUParticles3D.emitting.

void particles_set_explosiveness_ratio(particles: RID, ratio: float) 🔗

Встановлює коефіцієнт вибуховості. Еквівалентно GPUParticles3D.explosiveness.

void particles_set_fixed_fps(particles: RID, fps: int) 🔗

Встановлює частоту кадрів, на якій буде фіксовано рендеринг системи частинок. Еквівалентно GPUParticles3D.fixed_fps.

void particles_set_fractional_delta(particles: RID, enable: bool) 🔗

Якщо true, використовується дробова дельта, яка згладжує рух частинок. Еквівалентно GPUParticles3D.fract_delta.

void particles_set_interp_to_end(particles: RID, factor: float) 🔗

Налаштовує значення, яка інформує ParticleProcessMaterial, щоб подрібнити всі частинки до кінця їх життя.

void particles_set_interpolate(particles: RID, enable: bool) 🔗

There is currently no description for this method. Please help us by contributing one!

void particles_set_lifetime(particles: RID, lifetime: float) 🔗

Встановлює час життя кожної частинки в системі. Еквівалентно GPUParticles3D.lifetime.

void particles_set_mode(particles: RID, mode: ParticlesMode) 🔗

Налаштовує, чи мають бути надані частинки GPU парам RID у 2D або 3D відповідно до mode.

void particles_set_one_shot(particles: RID, one_shot: bool) 🔗

Якщо true, частинки випромінюються один раз, а потім зупиняться. Еквівалентно GPUParticles3D.one_shot.

void particles_set_pre_process_time(particles: RID, time: float) 🔗

Встановлює час попередньої обробки анімації частинок. Це дозволяє відкласти запуск анімації до моменту, коли частинки почнуть випромінюватися. Еквівалентно GPUParticles3D.preprocess.

void particles_set_process_material(particles: RID, material: RID) 🔗

Встановлює матеріал для обробки частинок.

Примітка: Це не матеріал, який використовується для малювання матеріалів. Еквівалентно GPUParticles3D.process_material.

void particles_set_randomness_ratio(particles: RID, ratio: float) 🔗

Встановлює коефіцієнт випадковості випромінювання. Це рандомізує випромінювання частинок у межах їхньої фази. Еквівалентно GPUParticles3D.randomness.

void particles_set_speed_scale(particles: RID, scale: float) 🔗

Встановлює шкалу швидкості системи частинок. Еквівалентно GPUParticles3D.speed_scale.

void particles_set_subemitter(particles: RID, subemitter_particles: RID) 🔗

There is currently no description for this method. Please help us by contributing one!

void particles_set_trail_bind_poses(particles: RID, bind_poses: Array[Transform3D]) 🔗

There is currently no description for this method. Please help us by contributing one!

void particles_set_trails(particles: RID, enable: bool, length_sec: float) 🔗

Якщо enable має значення true, вмикає сліди для particles із заданим значенням length_sec у секундах. Еквівалентно GPUParticles3D.trail_enabled та GPUParticles3D.trail_lifetime.

void particles_set_transform_align(particles: RID, align: ParticlesTransformAlign) 🔗

There is currently no description for this method. Please help us by contributing one!

void particles_set_use_local_coordinates(particles: RID, enable: bool) 🔗

Якщо true, частинки використовують локальні координати. Якщо false, вони використовують глобальні координати. Еквівалентно GPUParticles3D.local_coords.

void positional_soft_shadow_filter_set_quality(quality: ShadowQuality) 🔗

Встановлює якість фільтра для тіней від омні- та точкового світла у 3D. Див. також ProjectSettings.rendering/lights_and_shadows/positional_shadow/soft_shadow_filter_quality. Цей параметр є глобальним і не може бути встановлений для кожного окремого вікна перегляду.

RID reflection_probe_create() 🔗

Створює відбиття і додає її до RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх reflection_probe_* RenderingServer функції.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Щоб розмістити на сцені, прикріпіть цей відбиття до екземпляра за допомогою instance_set_base() за допомогою повернутого RID.

Примітка: Важкий вузол ReflectionProbe.

void reflection_probe_set_ambient_color(probe: RID, color: Color) 🔗

Встановлює власний колір навколишнього освітлення для зонда відбиття. Еквівалентно ReflectionProbe.ambient_color.

void reflection_probe_set_ambient_energy(probe: RID, energy: float) 🔗

Встановлює власну енергію навколишнього світла для зонда відбиття. Еквівалентно ReflectionProbe.ambient_color_energy.

void reflection_probe_set_ambient_mode(probe: RID, mode: ReflectionProbeAmbientMode) 🔗

Встановлює режим навколишнього освітлення для зонда відбиття. Еквівалентно ReflectionProbe.ambient_mode.

void reflection_probe_set_as_interior(probe: RID, enable: bool) 🔗

Якщо true, відбиття ігноруватимуть вплив неба. Еквівалентно ReflectionProbe.interior.

void reflection_probe_set_blend_distance(probe: RID, blend_distance: float) 🔗

Встановлює відстань у метрах, на якій зонд зливається зі сценою.

void reflection_probe_set_cull_mask(probe: RID, layers: int) 🔗

Встановлює маску відбиття рендерингу для цього зонда відбиття. Цим зондом будуть відбиті лише екземпляри з відповідним шаром. Еквівалентно ReflectionProbe.cull_mask.

void reflection_probe_set_enable_box_projection(probe: RID, enable: bool) 🔗

Якщо true, використовується блочна проекція. Це може зробити відображення більш правильними в певних ситуаціях. Еквівалентно ReflectionProbe.box_projection.

void reflection_probe_set_enable_shadows(probe: RID, enable: bool) 🔗

Якщо true, обчислює тіні в зонді відбиття. Це значно уповільнює обчислення відбиття. Еквівалентно ReflectionProbe.enable_shadows.

void reflection_probe_set_intensity(probe: RID, intensity: float) 🔗

Встановлює інтенсивність зонда відбиття. Інтенсивність модулює силу відбиття. Еквівалентно ReflectionProbe.intensity.

void reflection_probe_set_max_distance(probe: RID, distance: float) 🔗

Встановлює максимальну відстань від зонда, на якій може знаходитися об'єкт, перш ніж його буде вилучено. Еквівалентно ReflectionProbe.max_distance.

void reflection_probe_set_mesh_lod_threshold(probe: RID, pixels: float) 🔗

Встановлює рівень деталізації сітки, який буде використовуватися під час рендерингу зонда відбиття. Вищі значення використовуватимуть менш деталізовані версії сіток, що мають згенеровані варіації LOD. що може покращити продуктивність. Еквівалентно ReflectionProbe.mesh_lod_threshold.

void reflection_probe_set_origin_offset(probe: RID, offset: Vector3) 🔗

Встановлює зміщення початку координат, яке буде використовуватися, коли цей зонд відбиття знаходиться в режимі проектування коробки. Еквівалентно ReflectionProbe.origin_offset.

void reflection_probe_set_reflection_mask(probe: RID, layers: int) 🔗

Встановлює маску відбиття рендерингу для цього зонда відбиття. Відбиття з цього зонда будуть застосовані лише до екземплярів із відповідним шаром. Еквівалентно ReflectionProbe.reflection_mask.

void reflection_probe_set_resolution(probe: RID, resolution: int) 🔗

Налаштовує дозвіл на використання при рендерингу вказаного відбиття. resolution вказана для кожного кубічного обличчя: наприклад, уточнення 512 буде виділяти 6 осіб 512×512 кожного (плюсні карти для рівнів грубості).

void reflection_probe_set_size(probe: RID, size: Vector3) 🔗

Встановлює розмір області, яку буде захоплювати зонд відбиття. Еквівалентно ReflectionProbe.size.

void reflection_probe_set_update_mode(probe: RID, mode: ReflectionProbeUpdateMode) 🔗

Встановлює частоту оновлення зонда відбиття. Може оновлюватися один раз або кожного кадру.

void request_frame_drawn_callback(callable: Callable) 🔗

Заплановано зворотний дзвінок на задану замкнену раму.

RID scenario_create() 🔗

Створює скрипт і додає його до RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх scenario_* Функції RenderingServer.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Сценарій 3D світу, що існують всі візуальні екземпляри.

void scenario_set_camera_attributes(scenario: RID, effects: RID) 🔗

Налаштовує атрибути камери (effects), які будуть використовуватися з цим сценарієм. Дивись також CameraAttributes.

void scenario_set_compositor(scenario: RID, compositor: RID) 🔗

Налаштовує композитор (compositor), який буде використовуватися з цим сценарієм. Дивитися також Compositor.

void scenario_set_environment(scenario: RID, environment: RID) 🔗

Налаштовує навколишнє середовище, яке буде використовуватися за допомогою цього сценарію. Дивись також Environment.

void scenario_set_fallback_environment(scenario: RID, environment: RID) 🔗

Налаштовує навколишнє середовище, щоб використовувати цей скрипт. У разі відсутності навколишнього середовища використовується навколишнє середовище. Внутрішня, це використовується редактором, щоб забезпечити середовище за замовчуванням.

void screen_space_roughness_limiter_set_active(enable: bool, amount: float, limit: float) 🔗

Встановлює параметри обмежувача шорсткості екранного простору, такі як його ввімкнення та його порогові значення. Еквівалентно ProjectSettings.rendering/anti_aliasing/screen_space_roughness_limiter/enabled, ProjectSettings.rendering/anti_aliasing/screen_space_roughness_limiter/amount і ProjectSettings.rendering/anti_aliasing/screen_space_roughness_limiter/limit.

void set_boot_image(image: Image, color: Color, scale: bool, use_filter: bool = true) 🔗

Встановлює завантажувальний образ. Колір визначає колір фону. true, зображення буде масштабовано, щоб відповідати розміру екрану. Якщо use_filter є true, зображення буде масштабовано з лінійним інтерполяціям. Якщо use_filter є false, зображення буде масштабовано з міжполиттям найближчого сусіда.

void set_debug_generate_wireframes(generate: bool) 🔗

Якщо параметр generate має значення true, генерує каркаси налагодження для всіх сіток, які завантажуються під час використання засобу відтворення сумісності. За замовчуванням механізм не створює каркаси налагодження під час виконання, оскільки вони сповільнюють завантаження ресурсів і займають VRAM.

Примітка: Ви повинні викликати цей метод перед завантаженням будь-яких сіток під час використання рендерера сумісності, інакше каркаси не використовуватимуться.

void set_default_clear_color(color: Color) 🔗

Налаштовує чіткий колір за замовчуванням, який використовується при визначеному чіткому кольорі. Дивись також get_default_clear_color().

RID shader_create() 🔗

Створює порожній шейкер і додає його на RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх shader_* RenderingServer функції.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: При еквіваленті ресурсу Shader.

String shader_get_code(shader: RID) const 🔗

Повертає вихідний код шейра як рядок.

RID shader_get_default_texture_parameter(shader: RID, name: StringName, index: int = 0) const 🔗

Повертає текстуру за замовчуванням від шейдера, знайденого ім'ям.

Примітка: Якщо масив зразка використовується index для доступу до зазначеної текстури.

Variant shader_get_parameter_default(shader: RID, name: StringName) const 🔗

Повертає значення за замовчуванням для вказаної форми штора. Це, як правило, значення, написане в коді джерела тіні.

void shader_set_code(shader: RID, code: String) 🔗

Встановлює вихідний код шейдера (який викликає повторення після зміни).

void shader_set_default_texture_parameter(shader: RID, name: StringName, texture: RID, index: int = 0) 🔗

Встановлює текстуру за замовчуванням шейдера. Перезаписи текстури, наданої назвою.

Примітка: Якщо масив зразка використовується index для доступу до зазначеної текстури.

void shader_set_path_hint(shader: RID, path: String) 🔗

Налаштовує шлях натяка на вказаний шейдер. Це повинно в цілому відповідати ресурсу пам'ятати ресурс.

void skeleton_allocate_data(skeleton: RID, bones: int, is_2d_skeleton: bool = false) 🔗

There is currently no description for this method. Please help us by contributing one!

Transform3D skeleton_bone_get_transform(skeleton: RID, bone: int) const 🔗

Повертає набір Transform3D для конкретної кістки цього скелета.

Transform2D skeleton_bone_get_transform_2d(skeleton: RID, bone: int) const 🔗

Повертає набір Transform2D для конкретної кістки цього скелета.

void skeleton_bone_set_transform(skeleton: RID, bone: int, transform: Transform3D) 🔗

Налаштовує Transform3D для конкретної кістки цього скелета.

void skeleton_bone_set_transform_2d(skeleton: RID, bone: int, transform: Transform2D) 🔗

Набори Transform2D для конкретної кістки цього скелета.

RID skeleton_create() 🔗

Створює скелет і додає його на RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх skeleton_* Функції RenderingServer.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

int skeleton_get_bone_count(skeleton: RID) const 🔗

Повертає кількість кісток, виділених для цього скелета.

void skeleton_set_base_transform_2d(skeleton: RID, base_transform: Transform2D) 🔗

There is currently no description for this method. Please help us by contributing one!

Image sky_bake_panorama(sky: RID, energy: float, bake_irradiance: bool, size: Vector2i) 🔗

Генерує та повертає Image, що містить карту яскравості (radiance map) для вказаного RID sky. Це підтримує вбудований матеріал неба та власні шейдери неба. Якщо bake_irradiance має значення true, карта яскравості (irradiance map) зберігається замість карти яскравості. Карта яскравості використовується для візуалізації відбитого світла, тоді як карта яскравості використовується для візуалізації навколишнього світла. Див. також environment_bake_panorama().

Примітка: Зображення зберігається в лінійному колірному просторі без будь-якого тонального відображення, що означає, що воно виглядатиме занадто темним, якщо переглядати його безпосередньо в редакторі зображень. Значення energy вище 1.0 можна використовувати для освітлення результуючого зображення.

Примітка: size має бути зі співвідношенням сторін 2:1, щоб згенерована панорама мала квадратні пікселі. Для карт опромінення немає сенсу використовувати висоту, більшу за Sky.radiance_size, оскільки це не збільшить деталізацію. Карти опромінення містять лише низькочастотні дані, тому зазвичай немає сенсу перевищувати розмір 128×64 пікселів під час збереження карти опромінення.

RID sky_create() 🔗

Створює пусте небо і додає його до RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх sky_* RenderingServer функції.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

void sky_set_material(sky: RID, material: RID) 🔗

Налаштовує матеріал, що небо використовує для відображення фону, пам'яті та відображення.

void sky_set_mode(sky: RID, mode: SkyMode) 🔗

Встановлює процес mode неба, визначеного RID sky. Еквівалентно Sky.process_mode.

void sky_set_radiance_size(sky: RID, radiance_size: int) 🔗

Встановлює radiance_size неба, заданого параметром sky RID (у пікселях). Еквівалентно Sky.radiance_size.

RID spot_light_create() 🔗

Створює точкове світло і додає його на RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID можна використовувати в більшості light_* RenderingServer функції.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Щоб розміститися в сцені, прикріпіть цю пляму світло до екземпляра за допомогою instance_set_base() за допомогою повернутого RID.

void sub_surface_scattering_set_quality(quality: SubSurfaceScatteringQuality) 🔗

Встановлює ProjectSettings.rendering/environment/subsurface_scattering/subsurface_scattering_quality для використання під час рендерингу матеріалів з увімкненим підповерхневим розсіюванням.

void sub_surface_scattering_set_scale(scale: float, depth_scale: float) 🔗

Встановлює ProjectSettings.rendering/environment/subsurface_scattering/subsurface_scattering_scale і ProjectSettings.rendering/environment/subsurface_scattering/subsurface_scattering_depth_scale використовувати під час рендерингу матеріалів з увімкненим підповерхневим розсіюванням.

RID texture_2d_create(image: Image) 🔗

Створює 2-вимірну фактуру і додає її на RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх texture_2d_* Функції RenderingServer.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: еквівалентний ресурс Texture2D.

Примітка: Не плутати з ресурсом RenderingDevice.texture_create(), який створює власний фактурний тип графічної API, на відміну від Godot-specific Texture2D.

Image texture_2d_get(texture: RID) const 🔗

Повертає екземпляр Image із заданого texture RID.

Приклад: Отримайте тестову текстуру з get_test_texture() і застосуйте її до вузла Sprite2D:

var texture_rid = RenderingServer.get_test_texture()
var texture = ImageTexture.create_from_image(RenderingServer.texture_2d_get(texture_rid))
$Sprite2D.texture = texture

Image texture_2d_layer_get(texture: RID, layer: int) const 🔗

Повертає екземпляр Image з заданих параметрів texture RID та layer.

RID texture_2d_layered_create(layers: Array[Image], layered_type: TextureLayeredType) 🔗

Створює 2-вимірну текстуру шару і додає її до RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх texture_2d_layered_* RenderingServer функції.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: При еквіваленті ресурсу TextureLayered.

RID texture_2d_layered_placeholder_create(layered_type: TextureLayeredType) 🔗

Створює власника місця для 2-вимірної текстури шарів і додає її до RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися у всіх texture_2d_layered_* RenderingServer функції, хоча це нічого не використовується. Дивись також texture_2d_placeholder_create().

Примітка: При еквіваленті ресурсу РозробникTextureLayered.

RID texture_2d_placeholder_create() 🔗

Створює заповнювач для двовимірної багатошарової текстури та додає його до RenderingServer. До нього можна отримати доступ за допомогою RID, який повертається. Цей RID використовуватиметься в усіх texture_2d_layered_* функціях RenderingServer, хоча під час використання він нічого не робить. Дивіться також texture_2d_layered_placeholder_create().

Після завершення роботи з вашим RID ви захочете звільнити RID за допомогою методу RenderingServer free_rid().

Примітка: еквівалентним ресурсом є PlaceholderTexture2D.

void texture_2d_update(texture: RID, image: Image, layer: int) 🔗

Оновлює текстуру, задану параметром texture RID, даними з параметра image. Також необхідно вказати параметр layer, який має бути 0 під час оновлення одношарової текстури (Texture2D).

Примітка: Параметр image повинен мати таку ж ширину, висоту та формат, як і поточні дані параметра texture. В іншому випадку буде надруковано помилку, і оригінальна текстура не буде змінена. Якщо вам потрібно використовувати іншу ширину, висоту або формат, використовуйте замість цього метод texture_replace().

RID texture_3d_create(format: Format, width: int, height: int, depth: int, mipmaps: bool, data: Array[Image]) 🔗

Примітка: еквівалент ресурсу Texture3D.

Array[Image] texture_3d_get(texture: RID) const 🔗

Повертає 3D текстурні дані як масив Image для вказаної текстури RID.

RID texture_3d_placeholder_create() 🔗

Створює застосунок для 3-вимірної текстури і додає її до RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися у всіх texture_3d_* RenderingServer функції, хоча це нічого не використовується.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: При еквіваленті ресурсу РозробникTexture3D.

void texture_3d_update(texture: RID, data: Array[Image]) 🔗

Оновлює текстуру, визначену даними texture RID, даними з data. Усі шари текстури мають бути замінені одночасно.

Примітка: texture повинен мати таку ж ширину, висоту, глибину та формат, як і поточні дані текстури. В іншому випадку буде надруковано помилку, і оригінальна текстура не буде змінена. Якщо вам потрібно використовувати іншу ширину, висоту, глибину або формат, використовуйте замість цього texture_replace().

RID texture_create_from_native_handle(type: TextureType, format: Format, native_handle: int, width: int, height: int, depth: int, layers: int = 1, layered_type: TextureLayeredType = 0) 🔗

Створює текстуру на основі рідного дескриптора, створеного поза рендерером Godot.

Примітка: Якщо використовується лише рендерер пристрою рендерингу, рекомендується використовувати RenderingDevice.texture_create_from_extension() разом з texture_rd_create(), а не цей метод. Це надасть вам набагато більше контролю над форматом та використанням текстури.

Format texture_get_format(texture: RID) const 🔗

Повертає формат текстури.

int texture_get_native_handle(texture: RID, srgb: bool = false) const 🔗

Повертає внутрішню графічну ручку для цього об'єкта текстури. Для використання при спілкуванні з сторонніми API в основному з GDExtension.

Примітка: Ця функція повертає uint64_t, які внутрішні карти на GLuint (OpenGL) або VkImage (Vulkan).

String texture_get_path(texture: RID) const 🔗

There is currently no description for this method. Please help us by contributing one!

RID texture_get_rd_texture(texture: RID, srgb: bool = false) const 🔗

Повернення текстури RID, які можна використовувати за допомогою RenderingDevice.

RID texture_proxy_create(base: RID) 🔗

Застаріло: ProxyTexture was removed in Godot 4.

Цей метод нічого не робить і завжди повертає недійсний RID.

void texture_proxy_update(texture: RID, proxy_to: RID) 🔗

Застаріло: ProxyTexture was removed in Godot 4.

Цей метод нічого не робить.

RID texture_rd_create(rd_texture: RID, layer_type: TextureLayeredType = 0) 🔗

Створення нового об’єкту текстури на основі текстури, створеної безпосередньо на RenderingDevice. Якщо текстура містить шари, використовується для визначення типу шару.

void texture_replace(texture: RID, by_texture: RID) 🔗

Замінює дані текстури texture на текстуру, визначену RID by_texture, без зміни RID texture.

void texture_set_force_redraw_if_visible(texture: RID, enable: bool) 🔗

There is currently no description for this method. Please help us by contributing one!

void texture_set_path(texture: RID, path: String) 🔗

There is currently no description for this method. Please help us by contributing one!

void texture_set_size_override(texture: RID, width: int, height: int) 🔗

There is currently no description for this method. Please help us by contributing one!

void viewport_attach_camera(viewport: RID, camera: RID) 🔗

Налаштовує камеру перегляду.

void viewport_attach_canvas(viewport: RID, canvas: RID) 🔗

Налаштовує полотну видпорту.

void viewport_attach_to_screen(viewport: RID, rect: Rect2 = Rect2(0, 0, 0, 0), screen: int = 0) 🔗

Копіює вікно перегляду в область екрана, визначену параметром rect. Якщо viewport_set_render_direct_to_screen() має значення true, то вікно перегляду не використовує буфер кадрів і вміст вікна перегляду відображається безпосередньо на екрані. Однак зауважте, що кореневий вікно перегляду малюється останнім, тому воно буде намальовано поверх екрана. Відповідно, ви повинні встановити кореневу область перегляду на область, яка не охоплює область, до якої ви прикріпили це вікно перегляду.

Наприклад, ви можете налаштувати кореневу область перегляду так, щоб вона взагалі не відтворювалася за допомогою такого коду:

func _ready():
    RenderingServer.viewport_attach_to_screen(get_viewport().get_viewport_rid(), Rect2())
    RenderingServer.viewport_attach_to_screen($Viewport.get_viewport_rid(), Rect2(0, 0, 600, 600))

Використання цього може призвести до значної оптимізації, особливо на пристроях нижчого рівня. Однак це коштує керування вікнами перегляду вручну. Для подальшої оптимізації див. viewport_set_render_direct_to_screen().

RID viewport_create() 🔗

Створює порожній видпорт і додає його на RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх viewport_* RenderingServer функції.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: Об'ємний вузол Viewport.

float viewport_get_measured_render_time_cpu(viewport: RID) const 🔗

Повертає час процесора, витрачений на рендеринг останнього кадру в мілісекундах. Це лише включає час, витрачений на операції, пов'язані з рендерингом; функції _process скриптів та інші підсистеми движка не включені до цього зчитування. Щоб отримати повне зчитування часу процесора, витраченого на рендеринг сцени, підсумуйте час рендерингу всіх вікон перегляду, що відображаються в кожному кадрі, плюс get_frame_setup_time_cpu(). На відміну від Engine.get_frames_per_second(), цей метод точно відображатиме використання процесора, навіть якщо частота кадрів обмежена за допомогою V-Sync або Engine.max_fps. Див. також viewport_get_measured_render_time_gpu().

Примітка: Потрібно, щоб вимірювання були ввімкнені для вказаного viewport за допомогою viewport_set_measure_render_time(). В іншому випадку цей метод повертає 0.0.

float viewport_get_measured_render_time_gpu(viewport: RID) const 🔗

Повертає час графічного процесора, витрачений на рендеринг останнього кадру в мілісекундах. Щоб отримати повне значення часу, витраченого графічним процесором на рендеринг сцени, підсумовуйте час рендерингу всіх вікон перегляду, що відображаються в кожному кадрі. На відміну від методу Engine.get_frames_per_second(), цей метод точно відображає використання графічного процесора, навіть якщо частота кадрів обмежена V-Sync або Engine.max_fps. Див. також viewport_get_measured_render_time_cpu().

Примітка: Потрібно, щоб вимірювання були ввімкнені для вказаного параметра viewport за допомогою методу viewport_set_measure_render_time(). В іншому випадку цей метод повертає 0.0.

Примітка: Коли використання графічного процесора достатньо низьке протягом певного періоду часу, графічні процесори зменшують свій стан живлення (що, у свою чергу, знижує тактову частоту ядра та пам'яті). Це може призвести до збільшення часу, що повідомляється, якщо використання графічного процесора залишається достатньо низьким обмеженням частоти кадрів (порівняно з тим, що було б у стані найвищого живлення графічного процесора). Майте це на увазі під час тестування за допомогою viewport_get_measured_render_time_gpu(). Цю поведінку можна змінити в налаштуваннях графічного драйвера, але це призведе до збільшення енергоспоживання.

int viewport_get_render_info(viewport: RID, type: ViewportRenderInfoType, info: ViewportRenderInfo) 🔗

Повертає статистику про механізм рендерингу, яку можна використовувати для профілювання продуктивності. Це розділено на параметри render pass type, кожен з яких має однакові параметри info, які можна запитувати (різні параметри повертатимуть різні значення).

Див. також get_rendering_info(), який повертає глобальну інформацію по всіх вікнах перегляду.

Примітка: Інформація про рендеринг області перегляду недоступна, доки движок не відрендерить щонайменше 2 кадри. Якщо інформація про рендеринг недоступна, viewport_get_render_info() повертає 0. Щоб успішно вивести інформацію про рендеринг у _ready(), використовуйте наступне:

func _ready():
    for _i in 2:
        await get_tree().process_frame

    print(
            RenderingServer.viewport_get_render_info(get_viewport().get_viewport_rid(),
            RenderingServer.VIEWPORT_RENDER_INFO_TYPE_VISIBLE,
            RenderingServer.VIEWPORT_RENDER_INFO_DRAW_CALLS_IN_FRAME)
    )

RID viewport_get_render_target(viewport: RID) const 🔗

Повертаємо вашу увагу на те, що для перегляду портів.

RID viewport_get_texture(viewport: RID) const 🔗

Повертає останній рендеринговий рами.

ViewportUpdateMode viewport_get_update_mode(viewport: RID) const 🔗

Повертає режим оновлення області перегляду.

Попередження: Виклик цього з будь-якого потоку, окрім потоку рендерингу, негативно вплине на продуктивність.

void viewport_remove_canvas(viewport: RID, canvas: RID) 🔗

Знімає вид з полотна.

void viewport_set_active(viewport: RID, active: bool) 🔗

Якщо true, налаштовує активацію порту, ще налаштовує його неактивно.

void viewport_set_anisotropic_filtering_level(viewport: RID, anisotropic_filtering_level: ViewportAnisotropicFiltering) 🔗

Встановлює максимальну кількість зразків для взяття під час використання анізотропної фільтрації на текстурах (як ступінь двох). Більша кількість вибірок призведе до чіткіших текстур під косими кутами, але це дорожче для обчислення. Значення 0 примусово вимикає анізотропну фільтрацію, навіть для матеріалів, де вона ввімкнена.

Рівень анізотропної фільтрації також впливає на наклейки та світлові проєктори, якщо вони налаштовані на використання анізотропної фільтрації. Перегляньте ProjectSettings.rendering/textures/decals/filter і ProjectSettings.rendering/textures/light_projectors/filter.

Примітка: У 3D, щоб це налаштування мало ефект, установіть BaseMaterial3D.texture_filter на BaseMaterial3D.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC або BaseMaterial3D.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC на матеріалах.

Примітка: У 2D, щоб це налаштування мало ефект, установіть для CanvasItem.texture_filter значення CanvasItem.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC або CanvasItem.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC на Вузол CanvasItem, що відображає текстуру (або в CanvasTexture). Однак анізотропна фільтрація рідко буває корисною у 2D, тому вмикайте її для текстур у 2D, лише якщо вона має суттєву візуальну різницю.

void viewport_set_canvas_cull_mask(viewport: RID, canvas_cull_mask: int) 🔗

Встановлює маску рендерингу, пов'язану з цим Viewport. Тільки вузли CanvasItem з відповідним шаром видимості рендерингу будуть відображатися цим Viewport.

void viewport_set_canvas_stacking(viewport: RID, canvas: RID, layer: int, sublayer: int) 🔗

Встановлює порядок укладання для полотна області перегляду.

layer – це фактичний шар полотна, тоді як sublayer визначає порядок укладання полотна серед шарів того ж шару.

Примітка: layer має бути між CANVAS_LAYER_MIN та CANVAS_LAYER_MAX (включно). Будь-яке інше значення буде перенесено на наступний шар.

void viewport_set_canvas_transform(viewport: RID, canvas: RID, offset: Transform2D) 🔗

Налаштовує трансформацію полотнища.

void viewport_set_clear_mode(viewport: RID, clear_mode: ViewportClearMode) 🔗

Встановлює режим очищення області перегляду.

void viewport_set_debug_draw(viewport: RID, draw: ViewportDebugDraw) 🔗

Встановлює режим малювання налагодження для області перегляду.

void viewport_set_default_canvas_item_texture_filter(viewport: RID, filter: CanvasItemTextureFilter) 🔗

Встановлює режим фільтрації текстур за замовчуванням для вказаного RID viewport.

void viewport_set_default_canvas_item_texture_repeat(viewport: RID, repeat: CanvasItemTextureRepeat) 🔗

Встановлює режим повторення текстури за замовчуванням для вказаного RID viewport.

void viewport_set_disable_2d(viewport: RID, disable: bool) 🔗

Якщо true, полотно огляду (тобто 2D і елементи GUI) не надається.

void viewport_set_disable_3d(viewport: RID, disable: bool) 🔗

Якщо true, то не надано елементи 3D.

void viewport_set_environment_mode(viewport: RID, mode: ViewportEnvironmentMode) 🔗

Налаштовує режим навколишнього середовища, що дає можливість або відключення рендерингу 3D середовища понад 2D. При вимкненні 2D не буде впливати на навколишнє середовище. При включенні 2D буде впливати на навколишнє середовище, якщо режим навколишнього середовища ENV_BG_CANVAS. Поведінка за замовчуванням полягає в тому, щоб успадкувати налаштування з материнської плати. Якщо у верхній частині батьків також встановлений VIEWPORT_ENVIRONMENT_INHERIT, то поведінка буде такою ж, як і якщо вона була встановлена до VIEWPORT_ENVIRONMENT_ENABLED.

void viewport_set_fsr_sharpness(viewport: RID, sharpness: float) 🔗

Визначає, як різко масштабоване зображення буде при використанні режиму FSR. Щільність половинок з кожним цілим номером. Цінності йдуть від 0.0 (sharpest) до 2.0. Значення вище 2.0 не робить видимої різниці.

void viewport_set_global_canvas_transform(viewport: RID, transform: Transform2D) 🔗

Встановлює глобальну трансформуючу матрицю.

void viewport_set_measure_render_time(viewport: RID, enable: bool) 🔗

Встановлює вимірювання для заданого RID viewport (отриманого за допомогою методу Viewport.get_viewport_rid()). Після ввімкнення, метод viewport_get_measured_render_time_cpu() та viewport_get_measured_render_time_gpu() повертатимуть значення більше ніж 0.0 при запиті з заданим viewport.

void viewport_set_msaa_2d(viewport: RID, msaa: ViewportMSAA) 🔗

Встановлює режим багатосемплерного згладжування для 2D/Canvas на вказаному RID viewport. Еквівалентно ProjectSettings.rendering/anti_aliasing/quality/msaa_2d або Viewport.msaa_2d.

void viewport_set_msaa_3d(viewport: RID, msaa: ViewportMSAA) 🔗

Встановлює режим багатосемплерного згладжування для 3D на вказаному RID viewport. Еквівалентно ProjectSettings.rendering/anti_aliasing/quality/msaa_3d або Viewport.msaa_3d.

void viewport_set_occlusion_culling_build_quality(quality: ViewportOcclusionCullingBuildQuality) 🔗

Встановлює ProjectSettings.rendering/occlusion_culling/bvh_build_quality для використання для відсіювання перекриття. Цей параметр є глобальним і не може бути встановлений для кожного окремого вікна перегляду.

void viewport_set_occlusion_rays_per_thread(rays_per_thread: int) 🔗

Встановлює ProjectSettings.rendering/occlusion_culling/occlusion_rays_per_thread для використання для відсіювання перекриття. Цей параметр є глобальним і не може бути встановлений для кожного окремого вікна перегляду.

void viewport_set_parent_viewport(viewport: RID, parent_viewport: RID) 🔗

Встановлює батьківський об'єкт області перегляду рівним області перегляду, визначеній RID parent_viewport.

void viewport_set_positional_shadow_atlas_quadrant_subdivision(viewport: RID, quadrant: int, subdivision: int) 🔗

Встановлює кількість підрозділів, які слід використовувати у вказаному атласі тіней quadrant для всеохоплюючих та точкових тіней. Див. також Viewport.set_positional_shadow_atlas_quadrant_subdiv().

void viewport_set_positional_shadow_atlas_size(viewport: RID, size: int, use_16_bits: bool = false) 🔗

Встановіть size зображень Shadow atlas (використовуються для омні та точкових світильників) на екрані, зазначеному viewport RID. Вартість зараховується до найближчої потужності 2. Якщо use_16_bits є true, скористайтеся 16 бітами для shadow map. Включаючи ці результати в тіні, що мають меншу точність і може призвести до тіньових прищів, але може призвести до поліпшення продуктивності на деяких пристроях.

Примітка: Якщо це встановлено до 0, на всіх не буде видно положення тіней. Це може значно поліпшити продуктивність на низьких рівнях систем, зменшуючи навантаження процесора та GPU (як менше, кількість дзвінків потрібно для малювання сцени без тіней).

void viewport_set_render_direct_to_screen(viewport: RID, enabled: bool) 🔗

Якщо true, надайте вміст перегляду безпосередньо на екран. Це дозволяє оптимізувати низький рівень, де можна пропустити креслення порта до кореневого порту. У той час як ця оптимізація може призвести до значного збільшення швидкості (особливо на старих пристроях), вона настає при собівартості. Коли це ввімкнено, ви не можете читати з огляду або з екрана_текстури. Ви також втратите переваги певних параметрів вікна, таких як різні режими розтяжок. Ще одним наслідком є те, що в 2D рендеринг відбувається в віконних координатах, тому якщо у вас є оглядовий порт, який подвійний розмір вікна, і ви встановите це, то тільки порція, яка вписується в вікно, буде намальована, немає автоматичного масштабування можливо, навіть якщо ваша ігрова сцена значно перевищує розмір вікна.

void viewport_set_scaling_3d_mode(viewport: RID, scaling_3d_mode: ViewportScaling3DMode) 🔗

Налаштування режиму масштабування 3D. Білайнарне масштабування надає на різній роздільній здатності до або підошви або надшвидких джерел. FidelityFX Super Resolution 1.0, скорочений до FSR, - це технологія, яка виробляє високоякісні зображення при швидкому обрамленні, використовуючи алгоритм просторово впізнаваного алгоритму. FSR трохи дорожче, ніж білінійний, але він виробляє значно вищу якість зображення. ФСР необхідно використовувати де можливо.

void viewport_set_scaling_3d_scale(viewport: RID, scale: float) 🔗

Ваги 3D рендерного буферу на основі розміру Перегляду використовує фільтр зображень, зазначений в ViewportScaling3DMode, щоб масштабувати вихідне зображення на повнорозмірний вигляд. Значення, що нижче 1.0 може бути використана для прискорення 3D рендерингу за ціною якості (підсмоктування). Ціни більше, ніж 1.0 є дійсними тільки для білінійного режиму і можуть бути використані для покращення якості 3D при високій експлуатаційній вартості (supersampling). Дивись також ViewportMSAA для багатокамерного антиалюзування, який значно дешевше, але тільки розгладжує краю полігонів.

При використанні FSR-загальнення, AMD рекомендує розширювати такі значення як параметри заміщення для користувачів "Ультра Якість: 0,77", "Кількість: 0,67", "Оберіг: 0.59", "Реформанс: 0,5" замість розширення всієї ваги.

void viewport_set_scenario(viewport: RID, scenario: RID) 🔗

Налаштовує скрипт перегляду. Сценарій містить інформацію про інформацію про навколишнє середовище, відбиття атласу тощо.

void viewport_set_screen_space_aa(viewport: RID, mode: ViewportScreenSpaceAA) 🔗

Встановлює режим згладжування екранного простору вікна перегляду. Еквівалент ProjectSettings.rendering/anti_aliasing/quality/screen_space_aa або Viewport.screen_space_aa.

void viewport_set_sdf_oversize_and_scale(viewport: RID, oversize: ViewportSDFOversize, scale: ViewportSDFScale) 🔗

Встановлює поле двовимірної знакової відстані області перегляду ProjectSettings.rendering/2d/sdf/oversize та ProjectSettings.rendering/2d/sdf/scale. Використовується під час вибірки поля знакової відстані в шейдерах CanvasItem, а також під час колізії GPUParticles2D. Це невикористовується SDFGI у 3D-рендерингу.

void viewport_set_size(viewport: RID, width: int, height: int) 🔗

Встановлює ширину та висоту портів у пікселях.

void viewport_set_snap_2d_transforms_to_pixel(viewport: RID, enabled: bool) 🔗

Якщо значення true, трансформації елементів полотна (тобто початкова позиція) прив’язуються до найближчого пікселя під час рендерингу. Це може призвести до чіткішого вигляду за рахунок менш плавного руху, особливо коли ввімкнено згладжування Camera2D. Еквівалентно ProjectSettings.rendering/2d/snap/snap_2d_transforms_to_pixel.

void viewport_set_snap_2d_vertices_to_pixel(viewport: RID, enabled: bool) 🔗

Якщо true, вершини елементів полотна (тобто точки полігону) прив'язуються до найближчого пікселя під час рендерингу. Це може призвести до чіткішого вигляду за рахунок менш плавного руху, особливо коли ввімкнено згладжування Camera2D. Еквівалентно ProjectSettings.rendering/2d/snap/snap_2d_vertices_to_pixel.

void viewport_set_texture_mipmap_bias(viewport: RID, mipmap_bias: float) 🔗

Визначає остаточну фактурну різкість шляхом читання з нижньої або вищої мітки (також називається "текстура LOD bias"). Негативні значення роблять занурені текстури, але зернозбирача при перегляді на відстані, при цьому позитивні значення роблять занурені текстури розмити (навіть при закритті). Щоб отримати гострі текстури на відстані, не вводячи занадто багато зернистості, встановіть це між -0.75 і 0.0. Увімкнення часової антиалії (ProjectSettings.rendering/anti_aliasing/quality/use_taa) може допомогти зменшити видимість зерна при використанні негативних ipmap bias.

Примітка: Коли режим масштабування 3D встановлюється до FSR 1.0, це значення використовується для регулювання автоматичного переміщення mipmap, який обчислюється внутрішньо на основі коефіцієнта ваги. Формула для цього -log2(1.0 / масштаб) + mipmap_bias.

void viewport_set_transparent_background(viewport: RID, enabled: bool) 🔗

Якщо true, переглядовий порт дає свій фон як прозорий.

void viewport_set_update_mode(viewport: RID, update_mode: ViewportUpdateMode) 🔗

Встановлює, коли має оновлюватися область перегляду.

void viewport_set_use_debanding(viewport: RID, enable: bool) 🔗

Еквівалентно Viewport.use_debanding. Див. також ProjectSettings.rendering/anti_aliasing/quality/use_debanding.

void viewport_set_use_hdr_2d(viewport: RID, enabled: bool) 🔗

Якщо true, 2D-рендеринг буде використовувати фреймбуфер формату HDR (High Dynamic Range), що відповідає бітовій глибині 3D-фреймбуфера. При використанні рендерера Forward+ або Compatibility це буде фреймбуфер RGBA16. При використанні рендерера Mobile це буде фреймбуфер RGB10_A2.

Крім того, 2D-рендеринг відбуватиметься в лінійному колірному просторі і буде перетворено в простір sRGB безпосередньо перед виведенням на екран (якщо вікно перегляду приєднано до екрану).

Практично це означає, що кінцевий результат Viewport не буде обмежений діапазоном 0-1 і може бути використаний у 3D-рендерингу без коригування колірного простору. Це дозволяє 2D-рендерингу використовувати ефекти, що вимагають високого динамічного діапазону (наприклад, 2D-світіння), а також значно покращує вигляд ефектів, що вимагають дуже детальних градієнтів. Це налаштування має той самий ефект, що і Viewport.use_hdr_2d.

void viewport_set_use_occlusion_culling(viewport: RID, enable: bool) 🔗

Якщо true, активує відсікання перекриття на вказаному вікні перегляду. Еквівалентно ProjectSettings.rendering/occlusion_culling/use_occlusion_culling.

void viewport_set_use_taa(viewport: RID, enable: bool) 🔗

Якщо true, використовувати тимчасове згладжування. Еквівалент ProjectSettings.rendering/anti_aliasing/quality/use_taa або Viewport.use_taa.

void viewport_set_use_xr(viewport: RID, use_xr: bool) 🔗

Якщо true, пошук використовує технології доповненої або віртуальної реальності. Див XRInterface.

void viewport_set_vrs_mode(viewport: RID, mode: ViewportVRSMode) 🔗

Встановлює режим затінення зі змінною швидкістю (VRS) для області перегляду. Якщо графічний процесор не підтримує VRS, ця властивість ігнорується. Еквівалентно ProjectSettings.rendering/vrs/mode.

void viewport_set_vrs_texture(viewport: RID, texture: RID) 🔗

Текстура, яка використовується, коли режим VRS встановлено на VIEWPORT_VRS_TEXTURE. Еквівалентно ProjectSettings.rendering/vrs/texture.

void viewport_set_vrs_update_mode(viewport: RID, mode: ViewportVRSUpdateMode) 🔗

Налаштовує режим оновлення для мінливої форми ставок (VRS) для перегляду порту. VRS вимагає вхідної текстури, яка буде перетворена в формат, який підтримується методом VRS. Режим оновлення визначає, як часто це відбувається. Якщо GPU не підтримує VRS або VRS, це майно ігнорується.

Якщо встановити до VIEWPORT_VRS_UPDATE_ONCE, то текстура введення копіюється один раз, а режим змінюється на :ref:` ПЕРЕГЛЯДИ_VRS_UPDATE_DISABLED<class_RenderingServer_constant_ ПЕРЕГЛЯДИ_VRS_UPDATE_DISABLED>`.

RID visibility_notifier_create() 🔗

Створює новий об’єкт сповіщення про 3D-видимість і додає його до RenderingServer. До нього можна отримати доступ за допомогою RID, який повертається. Цей RID використовуватиметься в усіх visibility_notifier_* функціях RenderingServer.

Після завершення роботи з вашим RID ви захочете звільнити RID за допомогою методу RenderingServer free_rid().

Щоб розмістити в сцені, прикріпіть цей сповіщувач до екземпляра за допомогою instance_set_base(), використовуючи повернутий RID.

Примітка: еквівалентним вузлом є VisibleOnScreenNotifier3D.

void visibility_notifier_set_aabb(notifier: RID, aabb: AABB) 🔗

There is currently no description for this method. Please help us by contributing one!

void visibility_notifier_set_callbacks(notifier: RID, enter_callable: Callable, exit_callable: Callable) 🔗

There is currently no description for this method. Please help us by contributing one!

void voxel_gi_allocate_data(voxel_gi: RID, to_cell_xform: Transform3D, aabb: AABB, octree_size: Vector3i, octree_cells: PackedByteArray, data_cells: PackedByteArray, distance_field: PackedByteArray, level_counts: PackedInt32Array) 🔗

There is currently no description for this method. Please help us by contributing one!

RID voxel_gi_create() 🔗

Створює новий об'єкт глобального освітлення на основі воксаля і додає його до RenderingServer. Ви можете отримати доступ до RID, який повертається. Цей RID буде використовуватися в усіх voxel_gi_* RenderingServer функції.

Після закінчення з вашим RID ви хочете звільнити RID за допомогою методу RenderingServer.

Примітка: Об'ємний вузол VoxelGI.

PackedByteArray voxel_gi_get_data_cells(voxel_gi: RID) const 🔗

There is currently no description for this method. Please help us by contributing one!

PackedByteArray voxel_gi_get_distance_field(voxel_gi: RID) const 🔗

There is currently no description for this method. Please help us by contributing one!

PackedInt32Array voxel_gi_get_level_counts(voxel_gi: RID) const 🔗

There is currently no description for this method. Please help us by contributing one!

PackedByteArray voxel_gi_get_octree_cells(voxel_gi: RID) const 🔗

There is currently no description for this method. Please help us by contributing one!

Vector3i voxel_gi_get_octree_size(voxel_gi: RID) const 🔗

There is currently no description for this method. Please help us by contributing one!

Transform3D voxel_gi_get_to_cell_xform(voxel_gi: RID) const 🔗

There is currently no description for this method. Please help us by contributing one!

void voxel_gi_set_baked_exposure_normalization(voxel_gi: RID, baked_exposure: float) 🔗

Використовується для інформування рендерера, яке значення нормалізації експозиції використовувався при випіканні вокселю ги. Ця величина буде використана і модулюється в часі запуску, щоб забезпечити, що воксель ги зберігає послідовний рівень впливу, навіть якщо нормалізація впливу сцени змінюється в часі. Для отримання додаткової інформації див. camera_attributes_set_exposure().

void voxel_gi_set_bias(voxel_gi: RID, bias: float) 🔗

Встановлює значення VoxelGIData.bias на вказану voxel_gi RID.

void voxel_gi_set_dynamic_range(voxel_gi: RID, range: float) 🔗

Встановлює значення VoxelGIData.dynamic_range на вказану voxel_gi RID.

void voxel_gi_set_energy(voxel_gi: RID, energy: float) 🔗

Встановлює значення VoxelGIData.energy для використання на зазначеному voxel_gi RID.

void voxel_gi_set_interior(voxel_gi: RID, enable: bool) 🔗

Встановлює значення VoxelGIData.interior для використання з RID зазначеного voxel_gi.

void voxel_gi_set_normal_bias(voxel_gi: RID, bias: float) 🔗

Встановлює значення VoxelGIData.normal_bias для використання з RID зазначеного voxel_gi.

void voxel_gi_set_propagation(voxel_gi: RID, amount: float) 🔗

Встановлює значення VoxelGIData.propagation для використання з RID зазначеного voxel_gi.

void voxel_gi_set_quality(quality: VoxelGIQuality) 🔗

Встановлює значення ProjectSettings.rendering/global_illumination/voxel_gi/quality для використання під час рендерингу. Цей параметр є глобальним і не може бути встановлений для кожного VoxelGI окремо.

void voxel_gi_set_use_two_bounces(voxel_gi: RID, enable: bool) 🔗

Встановлює значення VoxelGIData.use_two_bounces для використання з вказаним RID параметра voxel_gi.