_err_print_error(p_function, p_file, p_line, p_description, false, ERR_HANDLER_SCRIPT);

}

}

// Variant functions

static void gdnative_variant_call(GDNativeVariantPtr p_self, const GDNativeStringNamePtr p_method, const GDNativeVariantPtr *p_args, const GDNativeInt p_argcount, GDNativeVariantPtr r_return, GDNativeCallError *r_error) {

Variant *self = (Variant *)p_self;

const Variant **args = (const Variant **)p_args;

Variant ret;

Callable::CallError error;

memnew_placement(r_return, Variant(ret));

if (r_error) {

static void gdnative_variant_call_static(GDNativeVariantType p_type, const GDNativeStringNamePtr p_method, const GDNativeVariantPtr *p_args, const GDNativeInt p_argcount, GDNativeVariantPtr r_return, GDNativeCallError *r_error) {

Variant::Type type = (Variant::Type)p_type;

const Variant **args = (const Variant **)p_args;

Variant ret;

Callable::CallError error;

memnew_placement(r_return, Variant(ret));

if (r_error) {

static GDNativePtrOperatorEvaluator gdnative_variant_get_ptr_operator_evaluator(GDNativeVariantOperator p_operator, GDNativeVariantType p_type_a, GDNativeVariantType p_type_b) {

return (GDNativePtrOperatorEvaluator)Variant::get_ptr_operator_evaluator(Variant::Operator(p_operator), Variant::Type(p_type_a), Variant::Type(p_type_b));

}

uint32_t hash = Variant::get_builtin_method_hash(Variant::Type(p_type), method);

if (hash != p_hash) {

return nullptr;

}

r_error->expected = error.expected;

}

}

}

}

static GDNativePtrIndexedSetter gdnative_variant_get_ptr_indexed_setter(GDNativeVariantType p_type) {

return (GDNativePtrIndexedSetter)Variant::get_member_ptr_indexed_setter(Variant::Type(p_type));

static GDNativePtrKeyedChecker gdnative_variant_get_ptr_keyed_checker(GDNativeVariantType p_type) {

return (GDNativePtrKeyedChecker)Variant::get_member_ptr_keyed_checker(Variant::Type(p_type));

}

}

uint32_t hash = Variant::get_utility_function_hash(function);

if (hash != p_hash) {

return nullptr;

}

return (GDNativePtrUtilityFunction)Variant::get_ptr_utility_function(function);

memdelete((Object *)p_o);

}

}

static void *gdnative_object_get_instance_binding(GDNativeObjectPtr p_object, void *p_token, const GDNativeInstanceBindingCallbacks *p_callbacks) {

o->set_instance_binding(p_token, p_binding, p_callbacks);

}

Object *o = (Object *)p_object;

}

static GDNativeObjectPtr gdnative_object_get_instance_from_id(GDObjectInstanceID p_instance_id) {

return reinterpret_cast<GDNativeScriptInstancePtr>(script_instance_extension);

}

ERR_FAIL_COND_V(!mb, nullptr);

if (mb->get_hash() != p_hash) {

return nullptr;

}

return (GDNativeMethodBindPtr)mb;

}

}

return class_info ? class_info->class_ptr : nullptr;

}

typedef struct {

GDNativeVariantType type;

uint32_t hint; // Bitfield of `PropertyHint` (defined in `extension_api.json`)

uint32_t usage; // Bitfield of `PropertyUsageFlags` (defined in `extension_api.json`)

} GDNativePropertyInfo;

typedef struct {

GDNativePropertyInfo return_value;

uint32_t flags; // Bitfield of `GDNativeExtensionClassMethodFlags`

int32_t id;

uint32_t argument_count;

uint32_t default_argument_count;

} GDNativeMethodInfo;

typedef GDNativeBool (*GDNativeExtensionClassPropertyCanRevert)(GDExtensionClassInstancePtr p_instance, const GDNativeStringNamePtr p_name);

typedef GDNativeBool (*GDNativeExtensionClassPropertyGetRevert)(GDExtensionClassInstancePtr p_instance, const GDNativeStringNamePtr p_name, GDNativeVariantPtr r_ret);

typedef void (*GDNativeExtensionClassNotification)(GDExtensionClassInstancePtr p_instance, int32_t p_what);

typedef void (*GDNativeExtensionClassReference)(GDExtensionClassInstancePtr p_instance);

typedef void (*GDNativeExtensionClassUnreference)(GDExtensionClassInstancePtr p_instance);

typedef void (*GDNativeExtensionClassCallVirtual)(GDExtensionClassInstancePtr p_instance, const GDNativeTypePtr *p_args, GDNativeTypePtr r_ret);

typedef GDNativeObjectPtr (*GDNativeExtensionClassCreateInstance)(void *p_userdata);

typedef void (*GDNativeExtensionClassFreeInstance)(void *p_userdata, GDExtensionClassInstancePtr p_instance);

typedef struct {

GDNativeBool is_virtual;

typedef void (*GDNativeExtensionClassMethodCall)(void *method_userdata, GDExtensionClassInstancePtr p_instance, const GDNativeVariantPtr *p_args, const GDNativeInt p_argument_count, GDNativeVariantPtr r_return, GDNativeCallError *r_error);

typedef void (*GDNativeExtensionClassMethodPtrCall)(void *method_userdata, GDExtensionClassInstancePtr p_instance, const GDNativeTypePtr *p_args, GDNativeTypePtr r_ret);

typedef struct {

void *method_userdata;

GDNativeExtensionClassMethodCall call_func;

GDNativeExtensionClassMethodPtrCall ptrcall_func;

uint32_t method_flags; // Bitfield of `GDNativeExtensionClassMethodFlags`

uint32_t argument_count;

GDNativeBool has_return_value;

uint32_t default_argument_count;

} GDNativeExtensionClassMethodInfo;

/* SCRIPT INSTANCE EXTENSION */

typedef GDNativeBool (*GDNativeExtensionScriptInstanceGet)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name, GDNativeVariantPtr r_ret);

typedef const GDNativePropertyInfo *(*GDNativeExtensionScriptInstanceGetPropertyList)(GDNativeExtensionScriptInstanceDataPtr p_instance, uint32_t *r_count);

typedef void (*GDNativeExtensionScriptInstanceFreePropertyList)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativePropertyInfo *p_list);

typedef GDNativeBool (*GDNativeExtensionScriptInstancePropertyCanRevert)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name);

typedef GDNativeBool (*GDNativeExtensionScriptInstancePropertyGetRevert)(GDNativeExtensionScriptInstanceDataPtr p_instance, const GDNativeStringNamePtr p_name, GDNativeVariantPtr r_ret);

typedef void (*GDNativeExtensionScriptInstanceCall)(GDNativeExtensionScriptInstanceDataPtr p_self, const GDNativeStringNamePtr p_method, const GDNativeVariantPtr *p_args, const GDNativeInt p_argument_count, GDNativeVariantPtr r_return, GDNativeCallError *r_error);

typedef void (*GDNativeExtensionScriptInstanceNotification)(GDNativeExtensionScriptInstanceDataPtr p_instance, int32_t p_what);

typedef void (*GDNativeExtensionScriptInstanceRefCountIncremented)(GDNativeExtensionScriptInstanceDataPtr p_instance);

typedef GDNativeBool (*GDNativeExtensionScriptInstanceRefCountDecremented)(GDNativeExtensionScriptInstanceDataPtr p_instance);

GDNativeExtensionScriptInstanceGet get_func;

GDNativeExtensionScriptInstanceGetPropertyList get_property_list_func;

GDNativeExtensionScriptInstanceFreePropertyList free_property_list_func;

GDNativeExtensionScriptInstancePropertyCanRevert property_can_revert_func;

GDNativeExtensionScriptInstancePropertyGetRevert property_get_revert_func;

void (*print_warning)(const char *p_description, const char *p_function, const char *p_file, int32_t p_line);

void (*print_script_error)(const char *p_description, const char *p_function, const char *p_file, int32_t p_line);

/* GODOT VARIANT */

GDNativeVariantFromTypeConstructorFunc (*get_variant_from_type_constructor)(GDNativeVariantType p_type);

GDNativeTypeFromVariantConstructorFunc (*get_variant_to_type_constructor)(GDNativeVariantType p_type);

GDNativePtrOperatorEvaluator (*variant_get_ptr_operator_evaluator)(GDNativeVariantOperator p_operator, GDNativeVariantType p_type_a, GDNativeVariantType p_type_b);

GDNativePtrConstructor (*variant_get_ptr_constructor)(GDNativeVariantType p_type, int32_t p_constructor);

GDNativePtrDestructor (*variant_get_ptr_destructor)(GDNativeVariantType p_type);

void (*variant_construct)(GDNativeVariantType p_type, GDNativeVariantPtr p_base, const GDNativeVariantPtr *p_args, int32_t p_argument_count, GDNativeCallError *r_error);

GDNativePtrIndexedSetter (*variant_get_ptr_indexed_setter)(GDNativeVariantType p_type);

GDNativePtrIndexedGetter (*variant_get_ptr_indexed_getter)(GDNativeVariantType p_type);

GDNativePtrKeyedSetter (*variant_get_ptr_keyed_setter)(GDNativeVariantType p_type);

GDNativePtrKeyedGetter (*variant_get_ptr_keyed_getter)(GDNativeVariantType p_type);

GDNativePtrKeyedChecker (*variant_get_ptr_keyed_checker)(GDNativeVariantType p_type);

/* extra utilities */

void (*object_method_bind_call)(const GDNativeMethodBindPtr p_method_bind, GDNativeObjectPtr p_instance, const GDNativeVariantPtr *p_args, GDNativeInt p_arg_count, GDNativeVariantPtr r_ret, GDNativeCallError *r_error);

void (*object_method_bind_ptrcall)(const GDNativeMethodBindPtr p_method_bind, GDNativeObjectPtr p_instance, const GDNativeTypePtr *p_args, GDNativeTypePtr r_ret);

void (*object_destroy)(GDNativeObjectPtr p_o);

void *(*object_get_instance_binding)(GDNativeObjectPtr p_o, void *p_token, const GDNativeInstanceBindingCallbacks *p_callbacks);

void (*object_set_instance_binding)(GDNativeObjectPtr p_o, void *p_token, void *p_binding, const GDNativeInstanceBindingCallbacks *p_callbacks);

GDNativeObjectPtr (*object_cast_to)(const GDNativeObjectPtr p_object, void *p_class_tag);

GDNativeObjectPtr (*object_get_instance_from_id)(GDObjectInstanceID p_instance_id);

GDNativeScriptInstancePtr (*script_instance_create)(const GDNativeExtensionScriptInstanceInfo *p_info, GDNativeExtensionScriptInstanceDataPtr p_instance_data);

/* CLASSDB */

/* CLASSDB EXTENSION */

void (*get_library_path)(const GDNativeExtensionClassLibraryPtr p_library, GDNativeStringPtr r_path);

class NativeExtensionMethodBind : public MethodBind {

GDNativeExtensionClassMethodCall call_func;

GDNativeExtensionClassMethodPtrCall ptrcall_func;

void *method_userdata;

bool vararg;

protected:

virtual Variant::Type _gen_argument_type(int p_arg) const override {

}

virtual PropertyInfo _gen_argument_type_info(int p_arg) const override {

}

public:

#ifdef DEBUG_METHODS_ENABLED

virtual GodotTypeInfo::Metadata get_argument_meta(int p_arg) const override {

}

#endif

method_userdata = p_method_info->method_userdata;

call_func = p_method_info->call_func;

ptrcall_func = p_method_info->ptrcall_func;

set_hint_flags(p_method_info->method_flags);

static GDNativeInterface gdnative_interface;

NativeExtension *self = static_cast<NativeExtension *>(p_library);

ERR_FAIL_COND_MSG(!String(class_name).is_valid_identifier(), "Attempt to register extension class '" + class_name + "', which is not a valid class identifier.");

ERR_FAIL_COND_MSG(ClassDB::class_exists(class_name), "Attempt to register extension class '" + class_name + "', which appears to be already registered.");

Extension *parent_extension = nullptr;

if (self->extension_classes.has(parent_class_name)) {

parent_extension = &self->extension_classes[parent_class_name];

ClassDB::register_extension_class(&extension->native_extension);

}

NativeExtension *self = static_cast<NativeExtension *>(p_library);

ERR_FAIL_COND_MSG(!self->extension_classes.has(class_name), "Attempt to register extension method '" + String(method_name) + "' for unexisting class '" + class_name + "'.");

//Extension *extension = &self->extension_classes[class_name];

ClassDB::bind_method_custom(class_name, method);

}

NativeExtension *self = static_cast<NativeExtension *>(p_library);

}

NativeExtension *self = static_cast<NativeExtension *>(p_library);

ERR_FAIL_COND_MSG(!self->extension_classes.has(class_name), "Attempt to register extension class property '" + property_name + "' for unexisting class '" + class_name + "'.");

//Extension *extension = &self->extension_classes[class_name];

PropertyInfo pinfo(*p_info);

}

NativeExtension *self = static_cast<NativeExtension *>(p_library);

}

NativeExtension *self = static_cast<NativeExtension *>(p_library);

}

NativeExtension *self = static_cast<NativeExtension *>(p_library);

MethodInfo s;

for (int i = 0; i < p_argument_count; i++) {

PropertyInfo arg(p_argument_info[i]);

s.arguments.push_back(arg);

ClassDB::add_signal(class_name, s);

}

NativeExtension *self = static_cast<NativeExtension *>(p_library);

ERR_FAIL_COND_MSG(!self->extension_classes.has(class_name), "Attempt to unregister unexisting extension class '" + class_name + "'.");

Extension *ext = &self->extension_classes[class_name];

ERR_FAIL_COND_MSG(ext->native_extension.children.size(), "Attempt to unregister class '" + class_name + "' while other extension classes inherit from it.");

HashMap<StringName, Extension> extension_classes;

static void _get_library_path(const GDNativeExtensionClassLibraryPtr p_library, GDNativeStringPtr r_path);

GDNativeInitialization initialization;

if (Engine::get_singleton()->has_singleton(p_class)) {

c = Engine::get_singleton()->get_singleton_object(p_class);

cleanup_c = false;

c = ClassDB::instantiate(p_class);

cleanup_c = true;

}

} \\

}\\

if (unlikely(_get_extension() && !_gdvirtual_##m_name##_initialized)) {\\

_gdvirtual_##m_name##_initialized = true;\\

}\\

if (_gdvirtual_##m_name) {\\

return _script_instance->has_method(_gdvirtual_##m_name##_sn);\\

}\\

if (unlikely(_get_extension() && !_gdvirtual_##m_name##_initialized)) {\\

_gdvirtual_##m_name##_initialized = true;\\

}\\

if (_gdvirtual_##m_name) {\\

}

if (_extension && _extension->to_string) {

String ret;

return ret;

}

return "<" + get_class() + "#" + itos(get_instance_id()) + ">";

explicit PropertyInfo(const GDNativePropertyInfo &pinfo) :

type((Variant::Type)pinfo.type),

hint((PropertyHint)pinfo.hint),

usage(pinfo.usage) {}

bool operator==(const PropertyInfo &p_info) const {

MethodInfo() {}

void _push_params(const PropertyInfo &p_param) {

arguments.push_back(p_param);

}

}

}

virtual Variant::Type get_property_type(const StringName &p_name, bool *r_is_valid = nullptr) const override {

}

}

}

virtual bool property_can_revert(const StringName &p_name) const override {

uint32_t mcount;

const GDNativeMethodInfo *minfo = native_info->get_method_list_func(instance, &mcount);

for (uint32_t i = 0; i < mcount; i++) {

}

if (native_info->free_method_list_func) {

native_info->free_method_list_func(instance, minfo);

virtual String to_string(bool *r_valid) override {

if (native_info->to_string_func) {

GDNativeBool valid;

if (r_valid) {

*r_valid = valid != 0;

}

<member name="pause" type="bool" setter="set_pause" getter="get_pause" default="false">

If [code]true[/code], the animation will pause where it currently is (i.e. at [member current_frame]). The animation will continue from where it was paused when changing this property to [code]false[/code].

</member>

<member name="speed_scale" type="float" setter="set_speed_scale" getter="get_speed_scale" default="1.0">

The animation speed is multiplied by this value. If set to a negative value, the animation is played in reverse.

</member>

<member name="region" type="Rect2" setter="set_region" getter="get_region" default="Rect2(0, 0, 0, 0)">

The region used to draw the [member atlas].

</member>

</members>

</class>

<member name="camera_is_active" type="bool" setter="set_camera_active" getter="get_camera_active" default="false">

Convenience property that gives access to the active property of the [CameraFeed].

</member>

<member name="which_feed" type="int" setter="set_which_feed" getter="get_which_feed" enum="CameraServer.FeedImage" default="0">

Which image within the [CameraFeed] we want access to, important if the camera image is split in a Y and CbCr component.

</member>

The normal map texture to use. Only has a visible effect if [Light2D]s are affecting this [CanvasTexture].

[b]Note:[/b] Godot expects the normal map to use X+, Y+, and Z+ coordinates. See [url=http://wiki.polycount.com/wiki/Normal_Map_Technical_Details#Common_Swizzle_Coordinates]this page[/url] for a comparison of normal map coordinates expected by popular engines.

</member>

<member name="specular_color" type="Color" setter="set_specular_color" getter="get_specular_color" default="Color(1, 1, 1, 1)">

The multiplier for specular reflection colors. The [Light2D]'s color is also taken into account when determining the reflection color. Only has a visible effect if [Light2D]s are affecting this [CanvasTexture].

</member>

<member name="load_path" type="String" setter="load" getter="get_load_path" default="&quot;&quot;">

The CompressedTexture's file path to a [code].ctex[/code] file.

</member>

</members>

</class>

<member name="curve" type="Curve" setter="set_curve" getter="get_curve">

The [Curve] that is rendered onto the texture.

</member>

<member name="texture_mode" type="int" setter="set_texture_mode" getter="get_texture_mode" enum="CurveTexture.TextureMode" default="0">

The format the texture should be generated with. When passing a CurveTexture as a input to a [Shader], this may need to be adjusted.

</member>

<member name="curve_z" type="Curve" setter="set_curve_z" getter="get_curve_z">

The [Curve] that is rendered onto the texture's blue channel.

</member>

<member name="width" type="int" setter="set_width" getter="get_width" default="256">

The width of the texture (in pixels). Higher values make it possible to represent high-frequency data better (such as sudden direction changes), at the cost of increased generation time and memory usage.

</member>

</constant>

<constant name="WINDOW_VIEW" value="2" enum="HandleType">

Window view:

- macOS: [code]NSView*[/code] for the window main view.

- iOS: [code]UIView*[/code] for the window main view.

</constant>

<constant name="TTS_UTTERANCE_STARTED" value="0" enum="TTSUtteranceEvent">

Utterance has begun to be spoken.

</constant>

<member name="read_only" type="bool" setter="set_read_only" getter="is_read_only" default="false">

If [code]true[/code], the slider can't be interacted with.

</member>

<member name="suffix" type="String" setter="set_suffix" getter="get_suffix" default="&quot;&quot;">

The suffix to display after the value (in a faded color). This should generally be a plural word. You may have to use an abbreviation if the suffix is too long to be displayed.

</member>

<member name="gradient" type="Gradient" setter="set_gradient" getter="get_gradient">

The [Gradient] that will be used to fill the texture.

</member>

<member name="use_hdr" type="bool" setter="set_use_hdr" getter="is_using_hdr" default="false">

If [code]true[/code], the generated texture will support high dynamic range ([constant Image.FORMAT_RGBAF] format). This allows for glow effects to work if [member Environment.glow_enabled] is [code]true[/code]. If [code]false[/code], the generated texture will use low dynamic range; overbright colors will be clamped ([constant Image.FORMAT_RGBA8] format).

</member>

<member name="repeat" type="int" setter="set_repeat" getter="get_repeat" enum="GradientTexture2D.Repeat" default="0">

The gradient repeat type, one of the [enum Repeat] values. The texture is filled starting from [member fill_from] to [member fill_to] offsets by default, but the gradient fill can be repeated to cover the entire texture.

</member>

<member name="use_hdr" type="bool" setter="set_use_hdr" getter="is_using_hdr" default="false">

If [code]true[/code], the generated texture will support high dynamic range ([constant Image.FORMAT_RGBAF] format). This allows for glow effects to work if [member Environment.glow_enabled] is [code]true[/code]. If [code]false[/code], the generated texture will use low dynamic range; overbright colors will be clamped ([constant Image.FORMAT_RGBA8] format).

</member>

</description>

</method>

</methods>

</class>

<member name="mesh" type="Mesh" setter="set_mesh" getter="get_mesh">

Sets the mesh used to draw. It must be a mesh using 2D vertices.

</member>

</members>

</class>

</method>

</methods>

<members>

The body's rotational velocity in [i]radians[/i] per second.

</member>

The body's center of mass position relative to the body's center in the global coordinate system.

</member>

The body's center of mass position in the body's local coordinate system.

</member>

The inverse of the inertia of the body.

</member>

The inverse of the mass of the body.

</member>

The body's linear velocity in pixels per second.

</member>

If [code]true[/code], this body is currently sleeping (not active).

</member>

The timestep (delta) used for the simulation.

</member>

The rate at which the body stops rotating, if there are not any other forces moving it.

</member>

The total gravity vector being currently applied to this body.

</member>

The rate at which the body stops moving, if there are not any other forces moving it.

</member>

The body's transformation matrix.

</member>

</members>

</method>

</methods>

<members>

The body's rotational velocity in [i]radians[/i] per second.

</member>

The body's center of mass position relative to the body's center in the global coordinate system.

</member>

The body's center of mass position in the body's local coordinate system.

</member>

The inverse of the inertia of the body.

</member>

The inverse of the inertia tensor of the body.

</member>

The inverse of the mass of the body.

</member>

The body's linear velocity in units per second.

</member>

</member>

If [code]true[/code], this body is currently sleeping (not active).

</member>

The timestep (delta) used for the simulation.

</member>

The rate at which the body stops rotating, if there are not any other forces moving it.

</member>

The total gravity vector being currently applied to this body.

</member>

The rate at which the body stops moving, if there are not any other forces moving it.

</member>

The body's transformation matrix.

</member>

</members>

<tutorials>

</tutorials>

<members>

<member name="size" type="Vector2" setter="set_size" getter="get_size" default="Vector2(1, 1)">

</member>

</members>

When running on the editor, this class will keep the source compressed data in memory. Otherwise, the source compressed data is lost after loading and the resource can't be re saved.

This flag allows to keep the compressed data in memory if you intend it to persist after loading.

</member>

<member name="size_override" type="Vector2" setter="set_size_override" getter="get_size_override" default="Vector2(0, 0)">

Allow overriding the texture size (for 2D only).

</member>

<member name="show_percentage" type="bool" setter="set_show_percentage" getter="is_percentage_shown" default="true">

If [code]true[/code], the fill percentage is displayed on the bar.

</member>

</members>

<constants>

<constant name="FILL_BEGIN_TO_END" value="0" enum="FillMode">

<member name="rounded" type="bool" setter="set_use_rounded_values" getter="is_using_rounded_values" default="false">

If [code]true[/code], [code]value[/code] will always be rounded to the nearest integer.

</member>

If greater than 0, [code]value[/code] will always be rounded to a multiple of [code]step[/code]. If [code]rounded[/code] is also [code]true[/code], [code]value[/code] will first be rounded to a multiple of [code]step[/code] then rounded to the nearest integer.

</member>

<member name="value" type="float" setter="set_value" getter="get_value" default="0.0">

<member name="custom_step" type="float" setter="set_custom_step" getter="get_custom_step" default="-1.0">

Overrides the step used when clicking increment and decrement buttons or when using arrow keys when the [ScrollBar] is focused.

</member>

<member name="step" type="float" setter="set_step" getter="get_step" overrides="Range" default="0.0" />

</members>

<signals>

<member name="scrollable" type="bool" setter="set_scrollable" getter="is_scrollable" default="true">

If [code]true[/code], the value can be changed using the mouse wheel.

</member>

<member name="tick_count" type="int" setter="set_ticks" getter="get_ticks" default="0">

Number of ticks displayed on the slider, including border ticks. Ticks are uniformly-distributed value markers.

</member>

<member name="select_all_on_focus" type="bool" setter="set_select_all_on_focus" getter="is_select_all_on_focus" default="false">

If [code]true[/code], the [SpinBox] will select the whole text when the [LineEdit] gains focus. Clicking the up and down arrows won't trigger this behavior.

</member>

<member name="suffix" type="String" setter="set_suffix" getter="get_suffix" default="&quot;&quot;">

Adds the specified [code]suffix[/code] string after the numerical value of the [SpinBox].

</member>

<member name="radial_initial_angle" type="float" setter="set_radial_initial_angle" getter="get_radial_initial_angle" default="0.0">

Starting angle for the fill of [member texture_progress] if [member fill_mode] is [constant FILL_CLOCKWISE] or [constant FILL_COUNTER_CLOCKWISE]. When the node's [code]value[/code] is equal to its [code]min_value[/code], the texture doesn't show up at all. When the [code]value[/code] increases, the texture fills and tends towards [member radial_fill_degrees].

</member>

<member name="stretch_margin_bottom" type="int" setter="set_stretch_margin" getter="get_stretch_margin" default="0">

The height of the 9-patch's bottom row. A margin of 16 means the 9-slice's bottom corners and side will have a height of 16 pixels. You can set all 4 margin values individually to create panels with non-uniform borders.

</member>

<link title="3D Viewport Scaling Demo">https://godotengine.org/asset-library/asset/586</link>

</tutorials>

<members>

<member name="viewport_path" type="NodePath" setter="set_viewport_path_in_scene" getter="get_viewport_path_in_scene" default="NodePath(&quot;&quot;)">

The path to the [Viewport] node to display. This is relative to the scene root, not to the node which uses the texture.

</member>

ERR_FAIL_COND(rb.is_null());

}

// Assign render data

// Use the format from rendererRD

RenderDataGLES3 render_data;

scene_state.ubo.emissive_exposure_normalization = -1.0; // Use default exposure normalization.

_setup_lights(&render_data, false, render_data.directional_light_count, render_data.omni_light_count, render_data.spot_light_count);

_fill_render_list(RENDER_LIST_OPAQUE, &render_data, PASS_MODE_COLOR);

render_list[RENDER_LIST_OPAQUE].sort_by_key();

}

}

glViewport(0, 0, rb->width, rb->height);

// Do depth prepass if it's explicitly enabled

_render_list_template<PASS_MODE_COLOR_TRANSPARENT>(&render_list_params_alpha, &render_data, 0, render_list[RENDER_LIST_ALPHA].elements.size(), true);

if (rb.is_valid()) {

_render_buffers_debug_draw(rb, p_shadow_atlas, p_occluder_debug_tex);

}

}

}

for (uint32_t i = p_from_element; i < p_to_element; i++) {

const GeometryInstanceSurface *surf = p_params->elements[i];

GeometryInstanceGLES3 *inst = surf->owner;

continue;

}

if constexpr (p_pass_mode == PASS_MODE_COLOR_TRANSPARENT) {

if (scene_state.current_depth_test != shader->depth_test) {

if (shader->depth_test == GLES3::SceneShaderData::DEPTH_TEST_DISABLED) {

glDisableVertexAttribArray(15);

}

}

}

void RasterizerSceneGLES3::render_material(const Transform3D &p_cam_transform, const Projection &p_cam_projection, bool p_cam_orthogonal, const PagedArray<RenderGeometryInstance *> &p_instances, RID p_framebuffer, const Rect2i &p_region) {

#include "render_scene_buffers_gles3.h"

#include "texture_storage.h"

RenderSceneBuffersGLES3::~RenderSceneBuffersGLES3() {

free_render_buffer_data();

}

void RenderSceneBuffersGLES3::configure(RID p_render_target, const Size2i p_internal_size, const Size2i p_target_size, float p_fsr_sharpness, float p_texture_mipmap_bias, RS::ViewportMSAA p_msaa, RenderingServer::ViewportScreenSpaceAA p_screen_space_aa, bool p_use_taa, bool p_use_debanding, uint32_t p_view_count) {

GLES3::TextureStorage *texture_storage = GLES3::TextureStorage::get_singleton();

//internal_size.x = p_internal_size.x; // ignore for now

//internal_size.y = p_internal_size.y;

GLES3::RenderTarget *rt = texture_storage->get_render_target(p_render_target);

is_transparent = rt->is_transparent;

}

void RenderSceneBuffersGLES3::free_render_buffer_data() {

}

#endif // GLES3_ENABLED

bool is_transparent = false;

RID render_target;

//built-in textures used for ping pong image processing and blurring

struct Blur {

}

if (t->tex_id != 0) {

t->tex_id = 0;

}

texture_owner.initialize_rid(p_texture, proxy_tex);

}

void TextureStorage::texture_2d_update(RID p_texture, const Ref<Image> &p_image, int p_layer) {

texture_set_data(p_texture, p_image, p_layer);

#ifdef TOOLS_ENABLED

glDepthMask(GL_FALSE);

{

glGenFramebuffers(1, &rt->fbo);

glBindFramebuffer(GL_FRAMEBUFFER, rt->fbo);

// color

} else {

glFramebufferTextureMultiviewOVR(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, rt->color, 0, 0, rt->view_count);

} else {

glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rt->color, 0);

}

if (status != GL_FRAMEBUFFER_COMPLETE) {

glDeleteFramebuffers(1, &rt->fbo);

glDeleteTextures(1, &rt->color);

rt->size.x = 0;

rt->size.y = 0;

rt->color = 0;

WARN_PRINT("Could not create render target, status: " + get_framebuffer_error(status));

return;

}

} else {

}

}

glClearColor(0, 0, 0, 0);

if (rt->fbo) {

glDeleteFramebuffers(1, &rt->fbo);

rt->fbo = 0;

rt->color = 0;

}

if (rt->backbuffer_fbo != 0) {

glDeleteFramebuffers(1, &rt->backbuffer_fbo);

_render_target_clear_sdf(rt);

}

RID TextureStorage::render_target_create() {

RenderTarget render_target;

//render_target.was_used = false;

void TextureStorage::render_target_free(RID p_rid) {

RenderTarget *rt = render_target_owner.get_or_null(p_rid);

_clear_render_target(rt);

Texture *t = get_texture(rt->texture);

if (t) {

t->is_render_target = false;

//memdelete(t);

}

render_target_owner.free(p_rid);

if (p_width == rt->size.x && p_height == rt->size.y && p_view_count == rt->view_count) {

return;

}

_clear_render_target(rt);

return rt->size;

}

RID TextureStorage::render_target_get_texture(RID p_render_target) {

RenderTarget *rt = render_target_owner.get_or_null(p_render_target);

ERR_FAIL_COND_V(!rt, RID());

return rt->texture;

}

rt->is_transparent = p_transparent;

}

bool TextureStorage::render_target_get_transparent(RID p_render_target) const {

// those functions change how they operate depending on the value of DIRECT_TO_SCREEN

_clear_render_target(rt);

rt->direct_to_screen = p_direct_to_screen;

_update_render_target(rt);

}

}

WARN_PRINT("2D MSAA is not yet supported for GLES3.");

_clear_render_target(rt);

rt->msaa = p_msaa;

_update_render_target(rt);

RID self;

bool is_proxy = false;

bool is_render_target = false;

RID proxy_to = RID();

void copy_from(const Texture &o) {

proxy_to = o.proxy_to;

is_proxy = o.is_proxy;

width = o.width;

height = o.height;

alloc_width = o.alloc_width;

RID self;

GLuint fbo = 0;

GLuint color = 0;

GLuint backbuffer_fbo = 0;

GLuint backbuffer = 0;

bool used_in_frame = false;

RS::ViewportMSAA msaa = RS::VIEWPORT_MSAA_DISABLED;

RID texture;

Color clear_color = Color(1, 1, 1, 1);

mutable RID_Owner<RenderTarget> render_target_owner;

void _clear_render_target(RenderTarget *rt);

void _update_render_target(RenderTarget *rt);

void _create_render_target_backbuffer(RenderTarget *rt);

void _render_target_allocate_sdf(RenderTarget *rt);

virtual void texture_3d_initialize(RID p_texture, Image::Format, int p_width, int p_height, int p_depth, bool p_mipmaps, const Vector<Ref<Image>> &p_data) override;

virtual void texture_proxy_initialize(RID p_texture, RID p_base) override; //all slices, then all the mipmaps, must be coherent

virtual void texture_2d_update(RID p_texture, const Ref<Image> &p_image, int p_layer = 0) override;

virtual void texture_3d_update(RID p_texture, const Vector<Ref<Image>> &p_data) override{};

virtual void texture_proxy_update(RID p_proxy, RID p_base) override;

virtual void render_target_set_vrs_texture(RID p_render_target, RID p_texture) override {}

virtual RID render_target_get_vrs_texture(RID p_render_target) const override { return RID(); }

virtual RID render_target_get_texture(RID p_render_target) override;

Variant default_value = Variant();

r_default_value_valid = false;

default_value = ClassDB::class_get_default_property_value(p_class_name, p_property_name, &r_default_value_valid);

} else {

// Cannot get default value of classes that can't be instantiated

<member name="noise" type="Noise" setter="set_noise" getter="get_noise">

The instance of the [Noise] object.

</member>

<member name="seamless" type="bool" setter="set_seamless" getter="get_seamless" default="false">

If [code]true[/code], a seamless texture is requested from the [Noise] resource.

[b]Note:[/b] Seamless noise textures may take longer to generate and/or can have a lower contrast compared to non-seamless noise depending on the used [Noise] resource. This is because some implementations use higher dimensions for generating seamless noise.

env_openxr.add_source_files(module_obj, "extensions/openxr_android_extension.cpp")

if env["vulkan"]:

env_openxr.add_source_files(module_obj, "extensions/openxr_vulkan_extension.cpp")

env_openxr.add_source_files(module_obj, "extensions/openxr_palm_pose_extension.cpp")

env_openxr.add_source_files(module_obj, "extensions/openxr_composition_layer_depth_extension.cpp")

#include "extensions/openxr_android_extension.h"

#endif

#ifdef VULKAN_ENABLED

#include "extensions/openxr_vulkan_extension.h"

#endif

#include "extensions/openxr_composition_layer_depth_extension.h"

#include "extensions/openxr_fb_display_refresh_rate_extension.h"

#include "extensions/openxr_fb_passthrough_extension_wrapper.h"

#endif

} else if (p_rendering_driver == "opengl3") {

#ifdef GLES3_ENABLED

#else

// shouldn't be possible...

ERR_FAIL_V(false);

case WINDOW_VIEW: {

return 0; // Not supported.

}

default: {

return 0;

}

print_verbose("Couldn't write vendor/renderer string.");

}

close(fdset[1]);

}

}

case WINDOW_VIEW: {

return 0; // Not supported.

}

default: {

return 0;

}

return use_vsync;

}

GLManager_X11::GLManager_X11(const Vector2i &p_size, ContextType p_context_type) {

context_type = p_context_type;

void set_use_vsync(bool p_use);

bool is_using_vsync() const;

GLManager_X11(const Vector2i &p_size, ContextType p_context_type);

~GLManager_X11();

};

case WINDOW_VIEW: {

return (int64_t)windows[p_window].window_view;

}

default: {

return 0;

}

void set_use_vsync(bool p_use);

bool is_using_vsync() const;

GLManager_MacOS(ContextType p_context_type);

~GLManager_MacOS();

};

return use_vsync;

}

GLManager_MacOS::GLManager_MacOS(ContextType p_context_type) {

context_type = p_context_type;

}

// Window (canvas)

bool DisplayServerWeb::check_size_force_redraw() {

}

void DisplayServerWeb::fullscreen_change_callback(int p_fullscreen) {

}

void DisplayServerWeb::window_set_rect_changed_callback(const Callable &p_callable, WindowID p_window) {

}

void DisplayServerWeb::window_set_window_event_callback(const Callable &p_callable, WindowID p_window) {

WindowMode window_mode = WINDOW_MODE_WINDOWED;

ObjectID window_attached_instance_id = {};

Callable window_event_callback;

Callable input_event_callback;

Callable input_text_callback;

case WINDOW_HANDLE: {

return (int64_t)windows[p_window].hWnd;

}

case WINDOW_VIEW: {

}

default: {

return 0;

}

return use_vsync;

}

GLManager_Windows::GLManager_Windows(ContextType p_context_type) {

context_type = p_context_type;

void set_use_vsync(bool p_use);

bool is_using_vsync() const;

GLManager_Windows(ContextType p_context_type);

~GLManager_Windows();

};

return dst;

}

case Variant::PACKED_INT32_ARRAY: {

return a;

} else {

Vector<int32_t> v;

v.resize(sz);

{

int32_t *vw = v.ptrw();

Variant va;

for (int32_t i = 0; i < sz; i++) {

}

}

case Variant::PACKED_INT64_ARRAY: {

return a;

} else {

Vector<int64_t> v;

v.resize(sz);

{

int64_t *vw = v.ptrw();

Variant va;

for (int64_t i = 0; i < sz; i++) {

}

}

case Variant::PACKED_FLOAT32_ARRAY: {

return a;

} else {

Vector<float> v;

v.resize(sz);

{

float *vw = v.ptrw();

Variant va;

for (int i = 0; i < sz; i++) {

}

}

case Variant::PACKED_FLOAT64_ARRAY: {

return a;

} else {

Vector<double> v;

v.resize(sz);

{

double *vw = v.ptrw();

Variant va;

for (int i = 0; i < sz; i++) {

}

}

case Variant::PACKED_VECTOR2_ARRAY: {

return a;

} else {

Vector<Vector2> v;

v.resize(sz);

{

Vector2 *vw = v.ptrw();

for (int i = 0; i < sz; i++) {

vw[i] = ar[i].lerp(br[i], c);

}

}

case Variant::PACKED_VECTOR3_ARRAY: {

return a;

} else {

Vector<Vector3> v;

v.resize(sz);

{

Vector3 *vw = v.ptrw();

for (int i = 0; i < sz; i++) {

vw[i] = ar[i].lerp(br[i], c);

}

}

case Variant::PACKED_COLOR_ARRAY: {

return a;

} else {

Vector<Color> v;

v.resize(sz);

{

Color *vw = v.ptrw();

for (int i = 0; i < sz; i++) {

vw[i] = ar[i].lerp(br[i], c);

BIND_ENUM_CONSTANT(DISPLAY_HANDLE);

BIND_ENUM_CONSTANT(WINDOW_HANDLE);

BIND_ENUM_CONSTANT(WINDOW_VIEW);

BIND_ENUM_CONSTANT(TTS_UTTERANCE_STARTED);

BIND_ENUM_CONSTANT(TTS_UTTERANCE_ENDED);

DISPLAY_HANDLE,

WINDOW_HANDLE,

WINDOW_VIEW,

};

typedef DisplayServer *(*CreateFunction)(const String &, WindowMode, VSyncMode, uint32_t, const Point2i *, const Size2i &, Error &r_error);

RID prev_index_array_rd;

RID prev_pipeline_rd;

RID prev_xforms_uniform_set;

bool shadow_pass = (p_params->pass_mode == PASS_MODE_SHADOW) || (p_params->pass_mode == PASS_MODE_SHADOW_DP);

continue;

}

//find cull variant

SceneShaderForwardMobile::ShaderData::CullVariant cull_variant;

RD::get_singleton()->draw_list_draw(draw_list, index_array_rd.is_valid(), instance_count);

}

}

/* Geometry instance */