#endif

{

#CODE : SKY

}

color *= sky_energy_multiplier;

virtual void configure(const RenderSceneBuffersConfiguration *p_config) override;

void configure_for_probe(Size2i p_size);

void set_apply_color_adjustments_in_post(bool p_apply_in_post);

void free_render_buffer_data();

virtual RID decal_allocate() override;

virtual void decal_initialize(RID p_rid) override;

virtual void decal_set_size(RID p_decal, const Vector3 &p_size) override;

virtual void decal_set_texture(RID p_decal, RS::DecalTexture p_type, RID p_texture) override;

virtual bool handles(const String &p_type) const;

virtual Ref<Texture2D> generate(const Ref<Resource> &p_from, const Size2 &p_size, Dictionary &p_metadata) const;

virtual Ref<Texture2D> generate_from_path(const String &p_path, const Size2 &p_size, Dictionary &p_metadata) const;

virtual bool generate_small_preview_automatically() const;

virtual bool can_generate_small_preview() const;

virtual Error export_pack(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, BitField<EditorExportPlatform::DebugFlags> p_flags = 0);

virtual Error export_zip(const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, BitField<EditorExportPlatform::DebugFlags> p_flags = 0);

virtual void get_platform_features(List<String> *r_features) const = 0;

virtual String get_debug_protocol() const { return "tcp://"; }

EditorExportPlatform();

protected:

virtual void gui_input(const Ref<InputEvent> &p_event) override;

public:

void set_can_move_window(bool p_enabled);

public:

void add_transition(const StringName &p_from, const StringName &p_to, Ref<AnimationNodeStateMachineTransition> p_transition);

};

#endif // ANIMATION_STATE_MACHINE_EDITOR_H

void set_dict(const Dictionary &p_dict);

Dictionary get_dict();

};

/*************************************************************************/

void set_defaults(const Dictionary &p_dict);

Dictionary get_defaults();

};

/*************************************************************************/

protected:

void _notification(int p_what);

void _edit_pressed();

void _page_changed(int p_page);

EditorPaginator *paginator = nullptr;

protected:

void _edit_pressed();

void _page_changed(int p_page);

protected:

void _notification(int p_what);

void _edit_pressed();

void _page_changed(int p_page);

virtual void _add_element() override;

void _add_font(int p_option);

public:

EditorPropertyFontNamesArray();

Vector<Face3> geometry;

bool _generate(Vector<Vector3> &points, Vector<Vector3> &normals);

void _node_selected(const NodePath &p_path);

public:

virtual Variant get_navigation_state() override;

virtual Vector<String> get_functions() override;

virtual PackedInt32Array get_breakpoints() override;

virtual void goto_line(int p_line, int p_column = 0) override;

void goto_line_selection(int p_line, int p_begin, int p_end);

virtual void set_executing_line(int p_line) override;

}

};

};

protected:

Ref<TileSet> tile_set;

TileData *_get_tile_data(TileMapCell p_cell);

static void _bind_methods();

// Input to handle painting.

virtual Control *get_toolbar() { return nullptr; };

// Used to draw the tile data property value over a tile.

};

class DummyObject : public Object {

};

virtual bool forward_canvas_gui_input(const Ref<InputEvent> &p_event) { return false; };

};

class TileMapLayerEditorTilesPlugin : public TileMapLayerSubEditorPlugin {

#include "core/variant/variant.h"

#ifndef LINE_NUMBER_TO_INDEX

#endif

#ifndef COLUMN_NUMBER_TO_INDEX

#endif

#ifndef SYMBOL_SEPERATOR

void set_owner_id(ObjectID p_owner_id) { owner_id = p_owner_id; }

ObjectID get_owner_id() const { return owner_id; }

};

#endif // NAV_BASE_H

};

protected:

void full_copy(ShapedTextDataAdvanced *p_shaped);

void invalidate(ShapedTextDataAdvanced *p_shaped, bool p_text = false);

Mutex ft_mutex;

protected:

void full_copy(ShapedTextDataFallback *p_shaped);

void invalidate(ShapedTextDataFallback *p_shaped);

}

this.name = signalName;

this.paramTypesNames = new String[this.paramTypes.length];

for (int i = 0; i < this.paramTypes.length; i++) {

this.paramTypesNames[i] = this.paramTypes[i].getName();

String cmd_args;

bool wait = false;

SSHCleanupCommand(const String &p_host, const String &p_port, const Vector<String> &p_ssh_arg, const String &p_cmd_args, bool p_wait = false) {

host = p_host;

port = p_port;

#define LONG_BITS (sizeof(long) * 8)

#define test_bit(nr, addr) (((1UL << ((nr) % LONG_BITS)) & ((addr)[(nr) / LONG_BITS])) != 0)

#ifdef UDEV_ENABLED

static const char *ignore_str = "/dev/input/js";

static inline HashMap<Key, unsigned int, HashMapHasherKeys> scancode_map_inv;

static inline HashMap<unsigned int, KeyLocation, HashMapHasherKeys> location_map;

public:

static void initialize();

public:

void window_resize(DisplayServer::WindowID p_window_id, int p_width, int p_height) {}

};

#endif // X11_ENABLED && GLES3_ENABLED

String cmd_args;

bool wait = false;

SSHCleanupCommand(const String &p_host, const String &p_port, const Vector<String> &p_ssh_arg, const String &p_cmd_args, bool p_wait = false) {

host = p_host;

port = p_port;

ctls[cid] = p_name;

}

};

#if defined(__GNUC__) && !defined(__clang__)

String cmd_args;

bool wait = false;

SSHCleanupCommand(const String &p_host, const String &p_port, const Vector<String> &p_ssh_arg, const String &p_cmd_args, bool p_wait = false) {

host = p_host;

port = p_port;

public:

void window_resize(DisplayServer::WindowID p_window_id, int p_width, int p_height);

};

#endif // WINDOWS_ENABLED && GLES3_ENABLED

TerrainConstraint(Ref<TileSet> p_tile_set, const Vector2i &p_position, int p_terrain); // For the center terrain bit

TerrainConstraint(Ref<TileSet> p_tile_set, const Vector2i &p_position, const TileSet::CellNeighbor &p_bit, int p_terrain); // For peering bits

};

#ifdef DEBUG_ENABLED

virtual Color get_color() const = 0;

virtual void slider_draw(int p_which) = 0;

virtual bool apply_theme() const { return false; }

virtual ColorPicker::PickerShapeType get_shape_override() const { return ColorPicker::SHAPE_MAX; }

ColorMode(ColorPicker *p_color_picker);

};

class ColorModeHSV : public ColorMode {

virtual void slider_draw(int p_which) override;

ColorModeHSV(ColorPicker *p_color_picker) :

};

class ColorModeRGB : public ColorMode {

virtual void slider_draw(int p_which) override;

ColorModeRGB(ColorPicker *p_color_picker) :

};

class ColorModeRAW : public ColorMode {

virtual bool apply_theme() const override;

ColorModeRAW(ColorPicker *p_color_picker) :

};

class ColorModeOKHSL : public ColorMode {

virtual ColorPicker::PickerShapeType get_shape_override() const override { return ColorPicker::SHAPE_OKHSL_CIRCLE; }

ColorModeOKHSL(ColorPicker *p_color_picker) :

};

#endif // COLOR_MODE_H

// Not exposed.

virtual void set_tile_set(const TileSet *p_tile_set);

TileSet *get_tile_set() const;

virtual void reset_state() override;

// Tiles.

Vector2 get_uv2_scale(Vector2 p_margin_scale = Vector2(1.0, 1.0)) const;

float get_lightmap_texel_size() const;

void _on_settings_changed();

Vector2 point;

bool sharp = false;

ContourPoint(const Vector2 &p_pt, bool p_sharp) {

point = p_pt;

sharp = p_sharp;

struct ContourInfo {

real_t length = 0.0;

bool ccw = true;

ContourInfo(real_t p_len, bool p_ccw) {

length = p_len;

ccw = p_ccw;

float auto_exposure_max = 64.0;

float auto_exposure_speed = 0.5;

float auto_exposure_scale = 0.4;

public:

virtual RID get_rid() const override;

/* MATERIAL API */

virtual RID material_allocate() override { return RID(); }

virtual void material_initialize(RID p_rid) override {}

virtual void material_set_render_priority(RID p_material, int priority) override {}

virtual void material_set_shader(RID p_shader_material, RID p_shader) override {}

/* Canvas Texture API */

virtual RID canvas_texture_allocate() override { return RID(); };

/* Texture API */

ERR_FAIL_NULL(t);

t->image = p_image->duplicate();

};

virtual RID texture_create_from_native_handle(RS::TextureType p_type, Image::Format p_format, uint64_t p_native_handle, int p_width, int p_height, int p_depth, int p_layers = 1, RS::TextureLayeredType p_layered_type = RS::TEXTURE_LAYERED_2D_ARRAY) override { return RID(); }

//these two APIs can be used together or in combination with the others.

virtual Ref<Image> texture_2d_get(RID p_texture) const override {

DummyTexture *t = texture_owner.get_or_null(p_texture);

virtual Vector<Ref<Image>> texture_3d_get(RID p_texture) const override { return Vector<Ref<Image>>(); };

virtual void texture_replace(RID p_texture, RID p_by_texture) override { texture_free(p_by_texture); };

virtual String texture_get_path(RID p_texture) const override { return String(); };

virtual Image::Format texture_get_format(RID p_texture) const override { return Image::FORMAT_MAX; }

virtual Size2 texture_size_with_proxy(RID p_proxy) override { return Size2(); };

virtual RID texture_get_rd_texture(RID p_texture, bool p_srgb = false) const override { return RID(); };

virtual uint64_t texture_get_native_handle(RID p_texture, bool p_srgb = false) const override { return 0; };

/* DECAL API */

virtual RID decal_allocate() override { return RID(); }

virtual void decal_initialize(RID p_rid) override {}

virtual void decal_set_size(RID p_decal, const Vector3 &p_size) override {}

virtual void decal_set_texture(RID p_decal, RS::DecalTexture p_type, RID p_texture) override {}

int last_shadow_filter = -1;

bool sync_gi_dependent_sets_validity(bool p_ensure_freed = false);

RID get_voxel_gi_buffer();

virtual void free_data() override;

};

int32_t cascade_dynamic_light_count[SDFGI::MAX_CASCADES]; //used dynamically

RID integrate_sky_uniform_set;

virtual void free_data() override;

~SDFGI();

virtual RID _render_buffers_get_normal_texture(Ref<RenderSceneBuffersRD> p_render_buffers) override;

virtual RID _render_buffers_get_velocity_texture(Ref<RenderSceneBuffersRD> p_render_buffers) override;

/* Geometry instance */

/* LIGHTING */

/* GI */

int group = 0;

CharString text;

bool default_enabled = true;

VariantDefine(int p_group, const String &p_text, bool p_default_enabled) {

group = p_group;

default_enabled = p_default_enabled;

#endif

#ifdef MATERIAL_UNIFORMS_USED

#MATERIAL_UNIFORMS

} material;

#endif

#GLOBALS

layout(location = 0) out vec4 frag_color;

#ifdef MATERIAL_UNIFORMS_USED

#MATERIAL_UNIFORMS

} material;

#endif

vec2 screen_uv_to_sdf(vec2 p_uv) {

directional_lights;

#ifdef MATERIAL_UNIFORMS_USED

#MATERIAL_UNIFORMS

} material;

#endif

layout(set = 2, binding = 0) uniform textureCube radiance;

#endif //USE_CUBEMAP_PASS

{

#CODE : SKY

}

frag_color.rgb = color;

#endif

#ifdef MATERIAL_UNIFORMS_USED

#MATERIAL_UNIFORMS

} material;

#endif

#GLOBALS

#endif

#ifdef MATERIAL_UNIFORMS_USED

#MATERIAL_UNIFORMS

} material;

#endif

float global_time;

#endif

#ifdef MATERIAL_UNIFORMS_USED

#MATERIAL_UNIFORMS

} material;

#endif

#GLOBALS

#endif

#ifdef MATERIAL_UNIFORMS_USED

#MATERIAL_UNIFORMS

} material;

#endif

#ifdef MODE_DUAL_PARABOLOID

#endif

#ifdef MATERIAL_UNIFORMS_USED

#MATERIAL_UNIFORMS

} material;

#endif

#GLOBALS

/* SET 3: MATERIAL */

#ifdef MATERIAL_UNIFORMS_USED

#MATERIAL_UNIFORMS

} material;

#endif

layout(push_constant, std430) uniform Params {

RID get_debug_texture();

const Size2i &get_occlusion_buffer_size() const { return occlusion_buffer_size; }

};

static RendererSceneOcclusionCull *get_singleton() { return singleton; }

#include "core/object/object.h"

#include "core/variant/type_info.h"

class RenderingDeviceCommons : public Object {

////////////////////////////////////////////

class RendererMaterialStorage {

public:

/* GLOBAL SHADER UNIFORM API */

virtual void global_shader_parameter_add(const StringName &p_name, RS::GlobalShaderParameterType p_type, const Variant &p_value) = 0;

void set_use_debanding(bool p_use_debanding) { use_debanding = p_use_debanding; }

RenderSceneBuffersConfiguration() {}

};

class RenderSceneBuffers : public RefCounted {

static void _bind_methods();

public:

virtual void configure(const RenderSceneBuffersConfiguration *p_config) = 0;

GDVIRTUAL1(_set_use_debanding, bool)

public:

virtual void configure(const RenderSceneBuffersConfiguration *p_config) override;

/* Texture API */

virtual bool can_create_resources_async() const = 0;

virtual RID texture_allocate() = 0;

virtual void texture_free(RID p_rid) = 0;

#include "core/input/input.h"

XRControllerTracker::XRControllerTracker() {

type = XRServer::TRACKER_CONTROLLER;

virtual RID get_color_texture(); /* obtain color output texture (if applicable) */

virtual RID get_depth_texture(); /* obtain depth output texture (if applicable, used for reprojection) */

virtual RID get_velocity_texture(); /* obtain velocity output texture (if applicable, used for spacewarp) */

virtual bool pre_draw_viewport(RID p_render_target) { return true; }; /* inform XR interface we are about to start our viewport draw process */

virtual Vector<BlitToScreen> post_draw_viewport(RID p_render_target, const Rect2 &p_screen_rect) = 0; /* inform XR interface we finished our viewport draw process */

/** passthrough **/