* text=auto eol=lf

# Except for bat files, which are Windows only files

*.bat eol=crlf

# The above only works properly for Git 2.10+, so for older versions

# we need to manually list the binary files we don't want modified.

return cmdlinev;

}

String OS::get_locale() const {

return ::OS::get_singleton()->get_locale();

}

ClassDB::bind_method(D_METHOD("get_name"), &OS::get_name);

ClassDB::bind_method(D_METHOD("get_cmdline_args"), &OS::get_cmdline_args);

ClassDB::bind_method(D_METHOD("delay_usec", "usec"), &OS::delay_usec);

ClassDB::bind_method(D_METHOD("delay_msec", "msec"), &OS::delay_msec);

return data;

}

ERR_FAIL_COND_V_MSG(f.is_null(), String(), "File must be opened before use, or is lacking read-write permission.");

uint64_t original_pos = f->get_position();

const_cast<FileAccess *>(*f)->seek(0);

const_cast<FileAccess *>(*f)->seek(original_pos);

ClassDB::bind_method(D_METHOD("get_buffer", "length"), &File::get_buffer);

ClassDB::bind_method(D_METHOD("get_line"), &File::get_line);

ClassDB::bind_method(D_METHOD("get_csv_line", "delim"), &File::get_csv_line, DEFVAL(","));

ClassDB::bind_method(D_METHOD("get_md5", "path"), &File::get_md5);

ClassDB::bind_method(D_METHOD("get_sha256", "path"), &File::get_sha256);

ClassDB::bind_method(D_METHOD("is_big_endian"), &File::is_big_endian);

String get_name() const;

Vector<String> get_cmdline_args();

String get_locale() const;

String get_locale_language() const;

Vector<uint8_t> get_buffer(int64_t p_length) const; // Get an array of bytes.

String get_line() const;

Vector<String> get_csv_line(const String &p_delim = ",") const;

String get_md5(const String &p_path) const;

String get_sha256(const String &p_path) const;

return i;

}

Vector<uint8_t> sourcef;

uint64_t len = get_length();

sourcef.resize(len + 1);

w[len] = 0;

String s;

return s;

}

virtual String get_line() const;

virtual String get_token() const;

virtual Vector<String> get_csv_line(const String &p_delim = ",") const;

/**

* Use this for files WRITTEN in _big_ endian machines (ie, amiga/mac)

uint32_t min_index = 0;

real_t min_value = x;

for (uint32_t i = 1; i < 4; i++) {

min_index = i;

min_value = operator[](i);

}

uint32_t min_index = 0;

int32_t min_value = x;

for (uint32_t i = 1; i < 4; i++) {

min_index = i;

min_value = operator[](i);

}

return "GenericDevice";

}

_execpath = String::utf8(p_execpath);

_cmdline = p_args;

}

String OS::get_unique_id() const {

static uint64_t target_ticks;

String _execpath;

List<String> _cmdline;

bool _keep_screen_on = true; // set default value to true, because this had been true before godot 2.0.

bool low_processor_usage_mode = false;

int low_processor_usage_mode_sleep_usec = 10000;

virtual void finalize() = 0;

virtual void finalize_core() = 0;

virtual bool _check_internal_feature_support(const String &p_feature) = 0;

virtual String get_name() const = 0;

virtual List<String> get_cmdline_args() const { return _cmdline; }

virtual List<String> get_cmdline_platform_args() const { return List<String>(); }

virtual String get_model_name() const;

return ret;

}

if (!p_utf8) {

return ERR_INVALID_DATA;

}

uint8_t c = *ptrtmp >= 0 ? *ptrtmp : uint8_t(256 + *ptrtmp);

if (skip == 0) {

/* Determine the number of characters in sequence */

if ((c & 0x80) == 0) {

skip = 0;

uint8_t c = *p_utf8 >= 0 ? *p_utf8 : uint8_t(256 + *p_utf8);

if (skip == 0) {

/* Determine the number of characters in sequence */

if ((c & 0x80) == 0) {

*(dst++) = c;

CharString ascii(bool p_allow_extended = false) const;

CharString utf8() const;

static String utf8(const char *p_utf8, int p_len = -1);

Char16String utf16() const;

A high value makes the material appear more like a metal. Non-metals use their albedo as the diffuse color and add diffuse to the specular reflection. With non-metals, the reflection appears on top of the albedo color. Metals use their albedo as a multiplier to the specular reflection and set the diffuse color to black resulting in a tinted reflection. Materials work better when fully metal or fully non-metal, values between [code]0[/code] and [code]1[/code] should only be used for blending between metal and non-metal sections. To alter the amount of reflection use [member roughness].

</member>

<member name="metallic_specular" type="float" setter="set_specular" getter="get_specular" default="0.5">

[b]Note:[/b] Unlike [member metallic], this is not energy-conserving, so it should be left at [code]0.5[/code] in most cases. See also [member roughness].

</member>

<member name="metallic_texture" type="Texture2D" setter="set_texture" getter="get_texture">

Blend factor between the fog's color and the color of the background [Sky]. Must have [member background_mode] set to [constant BG_SKY].

This is useful to simulate [url=https://en.wikipedia.org/wiki/Aerial_perspective]aerial perspective[/url] in large scenes with low density fog. However, it is not very useful for high-density fog, as the sky will shine through. When set to [code]1.0[/code], the fog color comes completely from the [Sky]. If set to [code]0.0[/code], aerial perspective is disabled.

</member>

The exponential fog density to use. Higher values result in a more dense fog.

</member>

<member name="fog_enabled" type="bool" setter="set_fog_enabled" getter="is_fog_enabled" default="false">

<member name="fog_height_density" type="float" setter="set_fog_height_density" getter="get_fog_height_density" default="0.0">

The density used to increase fog as height decreases. To make fog increase as height increases, use a negative value.

</member>

The fog's color.

</member>

<member name="fog_light_energy" type="float" setter="set_fog_light_energy" getter="get_fog_light_energy" default="1.0">

<member name="volumetric_fog_enabled" type="bool" setter="set_volumetric_fog_enabled" getter="is_volumetric_fog_enabled" default="false">

Enables the volumetric fog effect. Volumetric fog uses a screen-aligned froxel buffer to calculate accurate volumetric scattering in the short to medium range. Volumetric fog interacts with [FogVolume]s and lights to calculate localized and global fog. Volumetric fog uses a PBR single-scattering model based on extinction, scattering, and emission which it exposes to users as density, albedo, and emission.

</member>

</member>

<member name="volumetric_fog_length" type="float" setter="set_volumetric_fog_length" getter="get_volumetric_fog_length" default="64.0">

The distance over which the volumetric fog is computed. Increase to compute fog over a greater range, decrease to add more detail when a long range is not needed. For best quality fog, keep this as low as possible.

</method>

<method name="get_as_text" qualifiers="const">

<return type="String" />

<description>

</description>

</method>

<method name="get_buffer" qualifiers="const">

<argument index="0" name="mesh" type="Mesh" />

<description>

Initializes the navigation mesh by setting the vertices and indices according to a [Mesh].

</description>

</method>

<method name="get_collision_mask_value" qualifiers="const">

}

[/csharp]

[/codeblocks]

</description>

</method>

<method name="get_config_dir" qualifiers="const">

<member name="tangential_accel_min" type="float" setter="set_param_min" getter="get_param_min" default="0.0">

Minimum equivalent of [member tangential_accel_max].

</member>

</members>

<constants>

<constant name="PARAM_INITIAL_LINEAR_VELOCITY" value="0" enum="Parameter">

<constant name="PARAM_ANIM_OFFSET" value="11" enum="Parameter">

Use with [method set_param_min], [method set_param_max], and [method set_param_texture] to set animation offset properties.

</constant>

Represents the size of the [enum Parameter] enum.

</constant>

<constant name="PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY" value="0" enum="ParticleFlags">

<constant name="EMISSION_SHAPE_MAX" value="7" enum="EmissionShape">

Represents the size of the [enum EmissionShape] enum.

</constant>

<constant name="SUB_EMITTER_DISABLED" value="0" enum="SubEmitterMode">

</constant>

<constant name="SUB_EMITTER_CONSTANT" value="1" enum="SubEmitterMode">

<constant name="SUB_EMITTER_AT_COLLISION" value="3" enum="SubEmitterMode">

</constant>

<constant name="SUB_EMITTER_MAX" value="4" enum="SubEmitterMode">

</constant>

</constants>

</class>

#endif // LIGHT_ANISOTROPY_USED

// F

float cLdotH5 = SchlickFresnel(cLdotH);

vec3 specular_brdf_NL = cNdotL * D * F * G;

float a004 = min(r.x * r.x, exp2(-9.28 * ndotv)) * r.x + r.y;

vec2 env = vec2(-1.04, 1.04) * a004 + r.zw;

#endif

}

OS::get_singleton()->print("\n");

OS::get_singleton()->print("Run options:\n");

#ifdef TOOLS_ENABLED

OS::get_singleton()->print(" -e, --editor Start the editor instead of running the scene.\n");

OS::get_singleton()->print(" -p, --project-manager Start the project manager, even if a project is auto-detected.\n");

/* argument parsing and main creation */

List<String> args;

List<String> main_args;

List<String> platform_args = OS::get_singleton()->get_cmdline_platform_args();

// Add command line arguments.

continue;

}

#endif

List<String>::Element *N = I->next();

show_help = true;

exit_code = ERR_HELP; // Hack to force an early exit in `main()` with a success code.

OS::get_singleton()->print("Missing --xr-mode argument, aborting.\n");

goto error;

}

} else {

main_args.push_back(I->get());

}

Logger::set_flush_stdout_on_print(ProjectSettings::get_singleton()->get("application/run/flush_stdout_on_print"));

// possibly be worth changing the default from vulkan to something lower spec,

// for the project manager, depending on how smooth the fallback is.

unregister_core_types();

OS::get_singleton()->_cmdline.clear();

if (message_queue) {

memdelete(message_queue);

OS::get_singleton()->delete_main_loop();

OS::get_singleton()->_cmdline.clear();

OS::get_singleton()->_execpath = "";

OS::get_singleton()->_local_clipboard = "";

find_batch_file,

)

version = get_default_version(env)

return find_batch_file(env, version, host_platform, target_platform)[0]

continue

elif [[ "$f" == *"-so_wrap."* ]]; then

continue

fi

# Ensure that files are UTF-8 formatted.

recode UTF-8 "$f" 2> /dev/null

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

#include "file_access_filesystem_jandroid.h"

#include "core/os/os.h"

#include "core/templates/local_vector.h"

#include "thread_jandroid.h"

#include <unistd.h>

jobject FileAccessFilesystemJAndroid::file_access_handler = nullptr;

if (elem == '\n' || elem == '\0') {

// Found the end of the line

const_cast<FileAccessFilesystemJAndroid *>(this)->seek(start_position + line_buffer_position + 1);

return String();

}

return result;

}

}

return String();

}

return result;

ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "no_depth_test"), "set_draw_flag", "get_draw_flag", FLAG_DISABLE_DEPTH_TEST);

ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "fixed_size"), "set_draw_flag", "get_draw_flag", FLAG_FIXED_SIZE);

ADD_PROPERTY(PropertyInfo(Variant::INT, "alpha_cut", PROPERTY_HINT_ENUM, "Disabled,Discard,Opaque Pre-Pass"), "set_alpha_cut_mode", "get_alpha_cut_mode");

ADD_PROPERTY(PropertyInfo(Variant::INT, "texture_filter", PROPERTY_HINT_ENUM, "Nearest,Linear,Nearest Mipmap,Linear Mipmap,Nearest Mipmap Anisotropic,Linear Mipmap Anisotropic"), "set_texture_filter", "get_texture_filter");

ADD_PROPERTY(PropertyInfo(Variant::INT, "render_priority", PROPERTY_HINT_RANGE, itos(RS::MATERIAL_RENDER_PRIORITY_MIN) + "," + itos(RS::MATERIAL_RENDER_PRIORITY_MAX) + ",1"), "set_render_priority", "get_render_priority");

ADD_PROPERTY(PropertyInfo(Variant::INT, "outline_render_priority", PROPERTY_HINT_RANGE, itos(RS::MATERIAL_RENDER_PRIORITY_MIN) + "," + itos(RS::MATERIAL_RENDER_PRIORITY_MAX) + ",1"), "set_outline_render_priority", "get_outline_render_priority");

RS::get_singleton()->material_set_param(material, "uv1_scale", Vector3(1, 1, 1));

RS::get_singleton()->material_set_param(material, "uv2_offset", Vector3(0, 0, 0));

RS::get_singleton()->material_set_param(material, "uv2_scale", Vector3(1, 1, 1));

mesh = RenderingServer::get_singleton()->mesh_create();

// Fog

bool fog_enabled = false;

float fog_light_energy = 1.0;

float fog_sun_scatter = 0.0;

float fog_height = 0.0;

float fog_height_density = 0.0; //can be negative to invert effect

float fog_aerial_perspective = 0.0;

float volumetric_fog_anisotropy = 0.2;

float volumetric_fog_length = 64.0;

float volumetric_fog_detail_spread = 2.0;

bool volumetric_fog_temporal_reproject = true;

float volumetric_fog_temporal_reproject_amount = 0.9;

void _update_volumetric_fog();

ADD_GROUP("Transparency", "");

ADD_PROPERTY(PropertyInfo(Variant::INT, "transparency", PROPERTY_HINT_ENUM, "Disabled,Alpha,Alpha Scissor,Alpha Hash,Depth Pre-Pass"), "set_transparency", "get_transparency");

ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "alpha_hash_scale", PROPERTY_HINT_RANGE, "0,2,0.01"), "set_alpha_hash_scale", "get_alpha_hash_scale");

ADD_PROPERTY(PropertyInfo(Variant::INT, "alpha_antialiasing_mode", PROPERTY_HINT_ENUM, "Disabled,Alpha Edge Blend,Alpha Edge Clip"), "set_alpha_antialiasing", "get_alpha_antialiasing");

ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "alpha_antialiasing_edge", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_alpha_antialiasing_edge", "get_alpha_antialiasing_edge");

set_transparency(TRANSPARENCY_DISABLED);

set_alpha_antialiasing(ALPHA_ANTIALIASING_OFF);

set_alpha_hash_scale(1.0);

set_alpha_antialiasing_edge(0.3);

shader_names->emission_ring_radius = "emission_ring_radius";

shader_names->emission_ring_inner_radius = "emission_ring_inner_radius";

shader_names->gravity = "gravity";

shader_names->lifetime_randomness = "lifetime_randomness";

shader_map[mk].users++;

return;

}

//must create a shader!

// Add a comment to describe the shader origin (useful when converting to ShaderMaterial).

code += "uniform float collision_bounce;\n";

}

//need a random function

code += "\n\n";

code += "float rand_from_seed(inout uint seed) {\n";

break;

}

}

code += " if (RESTART_VELOCITY) VELOCITY = (EMISSION_TRANSFORM * vec4(VELOCITY, 0.0)).xyz;\n";

code += " TRANSFORM = EMISSION_TRANSFORM * TRANSFORM;\n";

if (particle_flags[PARTICLE_FLAG_DISABLE_Z]) {

code += " VELOCITY.z = 0.0;\n";

if (color_initial_ramp.is_valid()) {

code += " float color_initial_rand = rand_from_seed(alt_seed);\n";

}

code += " float pi = 3.14159;\n";

code += " float degree_to_rad = pi / 180.0;\n";

code += "\n";

code += " vec3 diff = pos - org;\n";

code += " force += length(diff) > 0.0 ? normalize(diff) * tex_radial_accel * mix(radial_accel_min, radial_accel_max, rand_from_seed(alt_seed)) : vec3(0.0);\n";

code += " // apply tangential acceleration;\n";

if (particle_flags[PARTICLE_FLAG_DISABLE_Z]) {

code += " force += length(diff.yx) > 0.0 ? vec3(normalize(diff.yx * vec2(-1.0, 1.0)), 0.0) * tangent_accel_val : vec3(0.0);\n";

code += " // apply attractor forces\n";

code += " VELOCITY += force * DELTA;\n";

code += " // orbit velocity\n";

if (particle_flags[PARTICLE_FLAG_DISABLE_Z]) {

code += " float orbit_amount = tex_orbit_velocity * mix(orbit_velocity_min, orbit_velocity_max, rand_from_seed(alt_seed));\n";

code += " }\n";

}

code += " float dmp = mix(damping_min, damping_max, rand_from_seed(alt_seed));\n";

code += " if (dmp * tex_damping > 0.0) {\n";

code += " float v = length(VELOCITY);\n";

code += " TRANSFORM[3] = origin;\n";

}

}

if (particle_flags[PARTICLE_FLAG_DISABLE_Z]) {

code += " TRANSFORM[3].z = 0.0;\n";

}

if (collision_enabled) {

code += " if (COLLIDED) {\n";

code += " }\n";

}

if (sub_emitter_mode != SUB_EMITTER_DISABLED) {

code += " int emit_count = 0;\n";

switch (sub_emitter_mode) {

case PARAM_ANIM_OFFSET: {

RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->anim_offset_min, p_value);

} break;

case PARAM_MAX:

break; // Can't happen, but silences warning

}

case PARAM_ANIM_OFFSET: {

RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->anim_offset_max, p_value);

} break;

case PARAM_MAX:

break; // Can't happen, but silences warning

}

case PARAM_ANIM_OFFSET: {

RenderingServer::get_singleton()->material_set_param(_get_material(), shader_names->anim_offset_texture, tex_rid);

} break;

case PARAM_MAX:

break; // Can't happen, but silences warning

}

return emission_ring_inner_radius;

}

void ParticlesMaterial::set_gravity(const Vector3 &p_gravity) {

gravity = p_gravity;

Vector3 gset = gravity;

if (property.name.begins_with("orbit_") && !particle_flags[PARTICLE_FLAG_DISABLE_Z]) {

property.usage = PROPERTY_USAGE_NONE;

}

}

void ParticlesMaterial::set_sub_emitter_mode(SubEmitterMode p_sub_emitter_mode) {

ClassDB::bind_method(D_METHOD("set_emission_ring_inner_radius", "inner_radius"), &ParticlesMaterial::set_emission_ring_inner_radius);

ClassDB::bind_method(D_METHOD("get_emission_ring_inner_radius"), &ParticlesMaterial::get_emission_ring_inner_radius);

ClassDB::bind_method(D_METHOD("get_gravity"), &ParticlesMaterial::get_gravity);

ClassDB::bind_method(D_METHOD("set_gravity", "accel_vec"), &ParticlesMaterial::set_gravity);

ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "hue_variation_min", PROPERTY_HINT_RANGE, "-1,1,0.01"), "set_param_min", "get_param_min", PARAM_HUE_VARIATION);

ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "hue_variation_max", PROPERTY_HINT_RANGE, "-1,1,0.01"), "set_param_max", "get_param_max", PARAM_HUE_VARIATION);

ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, "hue_variation_curve", PROPERTY_HINT_RESOURCE_TYPE, "CurveTexture"), "set_param_texture", "get_param_texture", PARAM_HUE_VARIATION);

ADD_GROUP("Animation", "anim_");

ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "anim_speed_min", PROPERTY_HINT_RANGE, "0,16,0.01,or_lesser,or_greater"), "set_param_min", "get_param_min", PARAM_ANIM_SPEED);

ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "anim_speed_max", PROPERTY_HINT_RANGE, "0,16,0.01,or_lesser,or_greater"), "set_param_max", "get_param_max", PARAM_ANIM_SPEED);

BIND_ENUM_CONSTANT(EMISSION_SHAPE_RING);

BIND_ENUM_CONSTANT(EMISSION_SHAPE_MAX);

BIND_ENUM_CONSTANT(SUB_EMITTER_DISABLED);

BIND_ENUM_CONSTANT(SUB_EMITTER_CONSTANT);

BIND_ENUM_CONSTANT(SUB_EMITTER_AT_END);

set_emission_ring_height(1);

set_emission_ring_radius(1);

set_emission_ring_inner_radius(0);

set_gravity(Vector3(0, -9.8, 0));

set_lifetime_randomness(0);

PARAM_HUE_VARIATION,

PARAM_ANIM_SPEED,

PARAM_ANIM_OFFSET,

PARAM_MAX

};

uint32_t attractor_enabled : 1;

uint32_t collision_enabled : 1;

uint32_t collision_scale : 1;

};

static uint32_t hash(const MaterialKey &p_key) {

return hash_murmur3_one_32(p_key.key);

mk.collision_enabled = collision_enabled;

mk.attractor_enabled = attractor_interaction_enabled;

mk.collision_scale = collision_scale;

return mk;

}

StringName emission_ring_radius;

StringName emission_ring_inner_radius;

StringName gravity;

StringName lifetime_randomness;

float params_min[PARAM_MAX];

float params_max[PARAM_MAX];

Ref<Texture2D> tex_parameters[PARAM_MAX];

Color color;

bool anim_loop = false;

Vector3 gravity;

double lifetime_randomness = 0.0;

real_t get_emission_ring_inner_radius() const;

int get_emission_point_count() const;

void set_gravity(const Vector3 &p_gravity);

Vector3 get_gravity() const;

if (vrs_mode == RS::VIEWPORT_VRS_TEXTURE) {

RID vrs_texture = texture_storage->render_target_get_vrs_texture(p_render_target);

if (vrs_texture.is_valid()) {

// Copy into our density buffer

}

}

} else if (vrs_mode == RS::VIEWPORT_VRS_XR) {

if (interface.is_valid()) {

RID vrs_texture = interface->get_vrs_texture();

if (vrs_texture.is_valid()) {

// Copy into our density buffer

}

}

}

free_parameters_uniform_set(uniform_set);

}

FogShaderData *shader_data = memnew(FogShaderData);

return shader_data;

}

return Fog::get_singleton()->_create_fog_shader_func();

};

FogMaterialData *material_data = memnew(FogMaterialData);

material_data->shader_data = p_shader;

//update will happen later anyway so do nothing.

return material_data;

}

return Fog::get_singleton()->_create_fog_material_func(static_cast<FogShaderData *>(p_shader));

};

volumetric_fog_modes.push_back("");

volumetric_fog.shader.initialize(volumetric_fog_modes);

volumetric_fog.volume_ubo = RD::get_singleton()->uniform_buffer_create(sizeof(VolumetricFogShader::VolumeUBO));

}

material_storage->material_initialize(volumetric_fog.default_material);

material_storage->material_set_shader(volumetric_fog.default_material, volumetric_fog.default_shader);

volumetric_fog.default_shader_rd = volumetric_fog.shader.version_get_shader(md->shader_data->version, 0);

Vector<RD::Uniform> uniforms;

FogMaterialData *material = nullptr;

if (fog_material.is_valid()) {

if (!material || !material->shader_data->valid) {

material = nullptr;

}

if (!material) {

fog_material = volumetric_fog.default_material;

}

ERR_FAIL_COND(!material);

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

u.binding = 1;

if (p_settings.shadow_atlas_depth.is_null()) {

} else {

u.append_id(p_settings.shadow_atlas_depth);

}

if (p_settings.directional_shadow_depth.is_valid()) {

u.append_id(p_settings.directional_shadow_depth);

} else {

}

uniforms.push_back(u);

copy_uniforms.push_back(u);

RD::Uniform u;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

u.binding = 19;

RID sky_texture = RendererSceneRenderRD::get_singleton()->environment_get_sky(p_settings.env).is_valid() ? p_settings.sky->sky_get_radiance_texture_rd(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_settings.env)) : RID();

u.append_id(sky_texture.is_valid() ? sky_texture : radiance_texture);

uniforms.push_back(u);

Vector3i _point_get_position_in_froxel_volume(const Vector3 &p_point, float fog_end, const Vector2 &fog_near_size, const Vector2 &fog_far_size, float volumetric_fog_detail_spread, const Vector3 &fog_size, const Transform3D &p_cam_transform);

bool valid = false;

RID version;

virtual ~FogShaderData();

};

FogShaderData *shader_data = nullptr;

RID uniform_set;

bool uniform_set_updated;

virtual ~FogMaterialData();

};

public:

static Fog *get_singleton() { return singleton; }

if (j < cascades.size()) {

u.append_id(cascades[j].sdf_tex);

} else {

}

}

uniforms.push_back(u);

if (j < cascades.size()) {

u.append_id(cascades[j].sdf_tex);

} else {

}

}

uniforms.push_back(u);

if (j < cascades.size()) {

u.append_id(cascades[j].light_tex);

} else {

}

}

uniforms.push_back(u);

if (j < cascades.size()) {

u.append_id(cascades[j].light_aniso_0_tex);

} else {

}

}

uniforms.push_back(u);

if (j < cascades.size()) {

u.append_id(cascades[j].light_aniso_1_tex);

} else {

}

}

uniforms.push_back(u);

if (i < cascades.size()) {

u.append_id(cascades[i].sdf_tex);

} else {

}

}

uniforms.push_back(u);

if (i < cascades.size()) {

u.append_id(cascades[i].light_tex);

} else {

}

}

uniforms.push_back(u);

if (i < cascades.size()) {

u.append_id(cascades[i].light_aniso_0_tex);

} else {

}

}

uniforms.push_back(u);

if (i < cascades.size()) {

u.append_id(cascades[i].light_aniso_1_tex);

} else {

}

}

uniforms.push_back(u);

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

u.binding = 0;

if (p_sky->sky_use_cubemap_array) {

} else {

}

uniforms.push_back(u);

}

}

if (texture == RID()) {

}

if (texture != rb->rbgi.voxel_gi_textures[i]) {

if (rb->sdfgi && j < rb->sdfgi->cascades.size()) {

u.append_id(rb->sdfgi->cascades[j].sdf_tex);

} else {

}

}

uniforms.push_back(u);

if (rb->sdfgi && j < rb->sdfgi->cascades.size()) {

u.append_id(rb->sdfgi->cascades[j].light_tex);

} else {

}

}

uniforms.push_back(u);

if (rb->sdfgi && j < rb->sdfgi->cascades.size()) {

u.append_id(rb->sdfgi->cascades[j].light_aniso_0_tex);

} else {

}

}

uniforms.push_back(u);

if (rb->sdfgi && j < rb->sdfgi->cascades.size()) {

u.append_id(rb->sdfgi->cascades[j].light_aniso_1_tex);

} else {

}

}

uniforms.push_back(u);

if (rb->sdfgi) {

u.append_id(rb->sdfgi->occlusion_texture);

} else {

}

uniforms.push_back(u);

}

if (rb->sdfgi) {

u.append_id(rb->sdfgi->lightprobe_texture);

} else {

}

uniforms.push_back(u);

}

RD::Uniform u;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

u.binding = 14;

u.append_id(buffer);

uniforms.push_back(u);

}

RD::Uniform u;

u.uniform_type = RD::UNIFORM_TYPE_IMAGE;

u.binding = 19;

u.append_id(buffer);

uniforms.push_back(u);

}

if (radiance.is_valid() && p_version <= SKY_TEXTURE_SET_QUARTER_RES) {

u.append_id(radiance);

} else {

}

uniforms.push_back(u);

}

}

} else {

if (p_version < SKY_TEXTURE_SET_CUBEMAP) {

} else {

}

}

uniforms.push_back(u);

}

} else {

if (p_version < SKY_TEXTURE_SET_CUBEMAP) {

} else {

}

}

uniforms.push_back(u);

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

// SkyRD

SkyShaderData *shader_data = memnew(SkyShaderData);

return shader_data;

}

// !BAS! Why isn't _create_sky_shader_func not just static too?

return static_cast<RendererSceneRenderRD *>(RendererSceneRenderRD::singleton)->sky._create_sky_shader_func();

};

SkyMaterialData *material_data = memnew(SkyMaterialData);

material_data->shader_data = p_shader;

//update will happen later anyway so do nothing.

return material_data;

}

// !BAS! same here, we could just make _create_sky_material_func static?

return static_cast<RendererSceneRenderRD *>(RendererSceneRenderRD::singleton)->sky._create_sky_material_func(static_cast<SkyShaderData *>(p_shader));

};

}

// register our shader funds

{

ShaderCompiler::DefaultIdentifierActions actions;

material_storage->material_set_shader(sky_shader.default_material, sky_shader.default_shader);

sky_shader.default_shader_rd = sky_shader.shader.version_get_shader(md->shader_data->version, SKY_VERSION_BACKGROUND);

sky_scene_state.uniform_buffer = RD::get_singleton()->uniform_buffer_create(sizeof(SkySceneState::UBO));

RD::Uniform u;

u.binding = 0;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

u.append_id(vfog);

uniforms.push_back(u);

}

RD::Uniform u;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

u.binding = 0;

uniforms.push_back(u);

}

{

RD::Uniform u;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

u.binding = 1;

uniforms.push_back(u);

}

{

RD::Uniform u;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

u.binding = 2;

uniforms.push_back(u);

}

// cleanup anything created in init...

RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();

sky_shader.shader.version_free(md->shader_data->version);

RD::get_singleton()->free(sky_scene_state.directional_light_buffer);

RD::get_singleton()->free(sky_scene_state.uniform_buffer);

sky_material = sky_get_material(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_env));

if (sky_material.is_valid()) {

if (!material || !material->shader_data->valid) {

material = nullptr;

}

if (!material) {

sky_material = sky_shader.default_material;

}

ERR_FAIL_COND(!material);

SkyMaterialData *material = nullptr;

if (sky_material.is_valid()) {

if (!material || !material->shader_data->valid) {

material = nullptr;

}

if (!material) {

sky_material = sky_shader.default_material;

}

ERR_FAIL_COND(!material);

sky_material = sky_get_material(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_env));

if (sky_material.is_valid()) {

if (!material || !material->shader_data->valid) {

material = nullptr;

}

if (!material) {

sky_material = sky_shader.default_material;

}

}

if (background == RS::ENV_BG_CLEAR_COLOR || background == RS::ENV_BG_COLOR) {

sky_material = sky_scene_state.fog_material;

}

ERR_FAIL_COND(!material);

sky_material = sky_get_material(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_env));

if (sky_material.is_valid()) {

if (!material || !material->shader_data->valid) {

material = nullptr;

}

if (!material) {

sky_material = sky_shader.default_material;

}

ERR_FAIL_COND(!material);

sky_material = sky_get_material(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_env));

if (sky_material.is_valid()) {

if (!material || !material->shader_data->valid) {

material = nullptr;

}

if (!material) {

sky_material = sky_shader.default_material;

}

}

if (background == RS::ENV_BG_CLEAR_COLOR || background == RS::ENV_BG_COLOR) {

sky_material = sky_scene_state.fog_material;

}

ERR_FAIL_COND(!material);

// 128 is the max size of a push constant. We can replace "pad" but we can't add any more.

};

bool valid = false;

RID version;

RID default_shader_rd;

} sky_shader;

SkyShaderData *shader_data = nullptr;

RID uniform_set;

bool uniform_set_updated;

mutable RID_Owner<Sky, true> sky_owner;

int roughness_layers;

SkyRD();

void init();

if (p_radiance_texture.is_valid()) {

radiance_texture = p_radiance_texture;

} else {

}

RD::Uniform u;

u.binding = 2;

if (ref_texture.is_valid()) {

u.append_id(ref_texture);

} else {

}

uniforms.push_back(u);

}

texture = shadow_atlas_get_texture(p_render_data->shadow_atlas);

}

if (!texture.is_valid()) {

}

u.append_id(texture);

uniforms.push_back(u);

if (p_use_directional_shadow_atlas && directional_shadow_get_texture().is_valid()) {

u.append_id(directional_shadow_get_texture());

} else {

}

uniforms.push_back(u);

}

u.binding = 6;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

for (uint32_t i = 0; i < scene_state.max_lightmaps; i++) {

if (p_render_data && i < p_render_data->lightmaps->size()) {

RID base = lightmap_instance_get_lightmap((*p_render_data->lightmaps)[i]);

RD::Uniform u;

u.binding = 7;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

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

if (p_render_data && i < (int)p_render_data->voxel_gi_instances->size()) {

RID tex = gi.voxel_gi_instance_get_texture((*p_render_data->voxel_gi_instances)[i]);

u.binding = 9;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

RID dbt = rb ? render_buffers_get_back_depth_texture(p_render_data->render_buffers) : RID();

u.append_id(texture);

uniforms.push_back(u);

}

u.binding = 10;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

RID bbt = rb ? render_buffers_get_back_buffer_texture(p_render_data->render_buffers) : RID();

u.append_id(texture);

uniforms.push_back(u);

}

RD::Uniform u;

u.binding = 11;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

u.append_id(texture);

uniforms.push_back(u);

}

u.binding = 12;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

RID aot = rb ? render_buffers_get_ao_texture(p_render_data->render_buffers) : RID();

u.append_id(texture);

uniforms.push_back(u);

}

u.binding = 13;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

RID ambient_buffer = rb ? render_buffers_get_gi_ambient_texture(p_render_data->render_buffers) : RID();

u.append_id(texture);

uniforms.push_back(u);

}

u.binding = 14;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

RID reflection_buffer = rb ? render_buffers_get_gi_reflection_texture(p_render_data->render_buffers) : RID();

u.append_id(texture);

uniforms.push_back(u);

}

if (rb && render_buffers_is_sdfgi_enabled(p_render_data->render_buffers)) {

t = render_buffers_get_sdfgi_irradiance_probes(p_render_data->render_buffers);

} else {

}

u.append_id(t);

uniforms.push_back(u);

if (rb && render_buffers_is_sdfgi_enabled(p_render_data->render_buffers)) {

u.append_id(render_buffers_get_sdfgi_occlusion_texture(p_render_data->render_buffers));

} else {

}

uniforms.push_back(u);

}

if (rb && render_buffers_has_volumetric_fog(p_render_data->render_buffers)) {

vfog = render_buffers_get_volumetric_fog_texture(p_render_data->render_buffers);

if (vfog.is_null()) {

}

} else {

}

u.append_id(vfog);

uniforms.push_back(u);

u.binding = 19;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

RID ssil = rb ? render_buffers_get_ssil_texture(p_render_data->render_buffers) : RID();

u.append_id(texture);

uniforms.push_back(u);

}

}

{

// No radiance texture.

RD::Uniform u;

u.binding = 2;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

{

// No reflection atlas.

RD::Uniform u;

u.binding = 3;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

RD::Uniform u;

u.binding = 4;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

u.append_id(texture);

uniforms.push_back(u);

}

RD::Uniform u;

u.binding = 5;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

u.append_id(texture);

uniforms.push_back(u);

}

u.binding = 6;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

for (uint32_t i = 0; i < scene_state.max_lightmaps; i++) {

u.append_id(default_tex);

}

u.binding = 7;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

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

u.append_id(default_tex);

}

void *surface_shadow = nullptr;

if (!p_material->shader_data->uses_particle_trails && !p_material->shader_data->writes_modelview_or_projection && !p_material->shader_data->uses_vertex && !p_material->shader_data->uses_position && !p_material->shader_data->uses_discard && !p_material->shader_data->uses_depth_pre_pass && !p_material->shader_data->uses_alpha_clip && p_material->shader_data->cull_mode == SceneShaderForwardClustered::ShaderData::CULL_BACK) {

flags |= GeometryInstanceSurfaceDataCache::FLAG_USES_SHARED_SHADOW_MATERIAL;

RID shadow_mesh = mesh_storage->mesh_get_shadow_mesh(p_mesh);

while (material->next_pass.is_valid()) {

RID next_pass = material->next_pass;

if (!material || !material->shader_data->valid) {

break;

}

SceneShaderForwardClustered::MaterialData *material = nullptr;

if (m_src.is_valid()) {

if (!material || !material->shader_data->valid) {

material = nullptr;

}

material_storage->material_update_dependency(m_src, &ginstance->data->dependency_tracker);

}

} else {

m_src = scene_shader.default_material;

}

if (ginstance->data->material_overlay.is_valid()) {

m_src = ginstance->data->material_overlay;

if (material && material->shader_data->valid) {

if (ginstance->data->dirty_dependencies) {

material_storage->material_update_dependency(m_src, &ginstance->data->dependency_tracker);

}

}

ShaderData *shader_data = memnew(ShaderData);

singleton->shader_list.add(&shader_data->shader_list_element);

return shader_data;

free_parameters_uniform_set(uniform_set);

}

MaterialData *material_data = memnew(MaterialData);

material_data->shader_data = p_shader;

//update will happen later anyway so do nothing.

valid_color_pass_pipelines.insert(PIPELINE_COLOR_PASS_FLAG_MOTION_VECTORS);

{

//shader compiler

material_storage->material_initialize(default_material);

material_storage->material_set_shader(default_material, default_shader);

default_shader_rd = shader.version_get_shader(md->shader_data->version, SHADER_VERSION_COLOR_PASS);

default_shader_sdfgi_rd = shader.version_get_shader(md->shader_data->version, SHADER_VERSION_DEPTH_PASS_WITH_SDF);

material_storage->material_initialize(overdraw_material);

material_storage->material_set_shader(overdraw_material, overdraw_material_shader);

overdraw_material_shader_ptr = md->shader_data;

overdraw_material_uniform_set = md->uniform_set;

}

SHADER_SPECIALIZATION_DIRECTIONAL_SOFT_SHADOWS = 1 << 3,

};

enum BlendMode { //used internally

BLEND_MODE_MIX,

BLEND_MODE_ADD,

SelfList<ShaderData>::List shader_list;

return static_cast<SceneShaderForwardClustered *>(singleton)->_create_shader_func();

}

ShaderData *shader_data = nullptr;

RID uniform_set;

uint64_t last_pass = 0;

virtual ~MaterialData();

};

return static_cast<SceneShaderForwardClustered *>(singleton)->_create_material_func(static_cast<ShaderData *>(p_shader));

}

if (p_radiance_texture.is_valid()) {

radiance_texture = p_radiance_texture;

} else {

}

RD::Uniform u;

u.binding = 2;

if (ref_texture.is_valid()) {

u.append_id(ref_texture);

} else {

}

uniforms.push_back(u);

}

texture = shadow_atlas_get_texture(p_render_data->shadow_atlas);

}

if (!texture.is_valid()) {

}

u.append_id(texture);

uniforms.push_back(u);

if (p_use_directional_shadow_atlas && directional_shadow_get_texture().is_valid()) {

u.append_id(directional_shadow_get_texture());

} else {

}

uniforms.push_back(u);

}

u.binding = 6;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

for (uint32_t i = 0; i < scene_state.max_lightmaps; i++) {

if (p_render_data && i < p_render_data->lightmaps->size()) {

RID base = lightmap_instance_get_lightmap((*p_render_data->lightmaps)[i]);

u.binding = 7;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

u.ids.resize(MAX_VOXEL_GI_INSTANCESS);

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

if (i < (int)p_voxel_gi_instances.size()) {

RID tex = gi.voxel_gi_instance_get_texture(p_voxel_gi_instances[i]);

u.binding = 9;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

RID dbt = rb ? render_buffers_get_back_depth_texture(p_render_data->render_buffers) : RID();

u.append_id(texture);

uniforms.push_back(u);

}

u.binding = 10;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

RID bbt = rb ? render_buffers_get_back_buffer_texture(p_render_data->render_buffers) : RID();

u.append_id(texture);

uniforms.push_back(u);

}

void *surface_shadow = nullptr;

if (!p_material->shader_data->uses_particle_trails && !p_material->shader_data->writes_modelview_or_projection && !p_material->shader_data->uses_vertex && !p_material->shader_data->uses_discard && !p_material->shader_data->uses_depth_pre_pass && !p_material->shader_data->uses_alpha_clip) {

flags |= GeometryInstanceSurfaceDataCache::FLAG_USES_SHARED_SHADOW_MATERIAL;

RID shadow_mesh = mesh_storage->mesh_get_shadow_mesh(p_mesh);

while (material->next_pass.is_valid()) {

RID next_pass = material->next_pass;

if (!material || !material->shader_data->valid) {

break;

}

SceneShaderForwardMobile::MaterialData *material = nullptr;

if (m_src.is_valid()) {

if (!material || !material->shader_data->valid) {

material = nullptr;

}

material_storage->material_update_dependency(m_src, &ginstance->data->dependency_tracker);

}

} else {

m_src = scene_shader.default_material;

}

if (ginstance->data->material_overlay.is_valid()) {

m_src = ginstance->data->material_overlay;

if (material && material->shader_data->valid) {

if (ginstance->data->dirty_dependencies) {

material_storage->material_update_dependency(m_src, &ginstance->data->dependency_tracker);

}

}

ShaderData *shader_data = memnew(ShaderData);

singleton->shader_list.add(&shader_data->shader_list_element);

return shader_data;

free_parameters_uniform_set(uniform_set);

}

MaterialData *material_data = memnew(MaterialData);

material_data->shader_data = p_shader;

//update will happen later anyway so do nothing.

}

}

{

//shader compiler

material_storage->material_initialize(default_material);

material_storage->material_set_shader(default_material, default_shader);

default_shader_rd = shader.version_get_shader(md->shader_data->version, SHADER_VERSION_COLOR_PASS);

default_material_shader_ptr = md->shader_data;

material_storage->material_initialize(overdraw_material);

material_storage->material_set_shader(overdraw_material, overdraw_material_shader);

overdraw_material_shader_ptr = md->shader_data;

overdraw_material_uniform_set = md->uniform_set;

}

SHADER_VERSION_MAX

};

enum BlendMode { //used internally

BLEND_MODE_MIX,

BLEND_MODE_ADD,

virtual ~ShaderData();

};

return static_cast<SceneShaderForwardMobile *>(singleton)->_create_shader_func();

}

ShaderData *shader_data = nullptr;

RID uniform_set;

uint64_t last_pass = 0;

SelfList<ShaderData>::List shader_list;

return static_cast<SceneShaderForwardMobile *>(singleton)->_create_material_func(static_cast<ShaderData *>(p_shader));

}

vd.stride = 0;

descriptions.write[1] = vd;

}

//uvs

vd.stride = 0;

descriptions.write[2] = vd;

}

//bones

vd.stride = 0;

descriptions.write[3] = vd;

}

//weights

vd.stride = 0;

descriptions.write[4] = vd;

}

//check that everything is as it should be

} else {

screen = texture_storage->render_target_get_rd_backbuffer(p_to_render_target);

if (screen.is_null()) { //unallocated backbuffer

}

}

u.append_id(screen);

if (material != prev_material) {

CanvasMaterialData *material_data = nullptr;

if (material.is_valid()) {

}

if (material_data) {

RID material = ci->material_owner == nullptr ? ci->material : ci->material_owner->material;

if (material.is_valid()) {

if (md && md->shader_data->valid) {

if (md->shader_data->uses_screen_texture && canvas_group_owner == nullptr) {

if (!material_screen_texture_found) {

}

}

CanvasShaderData *shader_data = memnew(CanvasShaderData);

return shader_data;

}

free_parameters_uniform_set(uniform_set);

}

CanvasMaterialData *material_data = memnew(CanvasMaterialData);

material_data->shader_data = p_shader;

//update will happen later anyway so do nothing.

state.shadow_texture_size = GLOBAL_GET("rendering/2d/shadow_atlas/size");

//create functions for shader and material

state.time = 0;

ShaderCompiler compiler;

} shader;

enum BlendMode { //used internally

BLEND_MODE_MIX,

BLEND_MODE_ADD,

virtual ~CanvasShaderData();

};

return static_cast<RendererCanvasRenderRD *>(singleton)->_create_shader_func();

}

CanvasShaderData *shader_data = nullptr;

RID uniform_set;

virtual ~CanvasMaterialData();

};

return static_cast<RendererCanvasRenderRD *>(singleton)->_create_material_func(static_cast<CanvasShaderData *>(p_shader));

}

tonemap.exposure_texture = rb->luminance.current;

tonemap.auto_exposure_grey = environment_get_auto_exp_scale(p_render_data->environment);

} else {

}

if (can_use_effects && p_render_data->environment.is_valid() && environment_get_glow_enabled(p_render_data->environment)) {

tonemap.glow_map = texture_storage->texture_get_rd_texture(environment_get_glow_map(p_render_data->environment));

} else {

tonemap.glow_map_strength = 0.0f;

}

} else {

}

if (rb->screen_space_aa == RS::VIEWPORT_SCREEN_SPACE_AA_FXAA) {

tonemap.use_color_correction = false;

tonemap.use_1d_color_correction = false;

if (can_use_effects && p_render_data->environment.is_valid()) {

tonemap.use_bcs = environment_get_adjustments_enabled(p_render_data->environment);

}

tonemap.use_glow = false;

tonemap.use_auto_exposure = false;

tonemap.use_color_correction = false;

tonemap.use_1d_color_correction = false;

if (can_use_effects && p_render_data->environment.is_valid()) {

tonemap.use_bcs = environment_get_adjustments_enabled(p_render_data->environment);

RID shadow_atlas_texture = shadow_atlas_get_texture(p_shadow_atlas);

if (shadow_atlas_texture.is_null()) {

}

Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);

float a004 = min(r.x * r.x, exp2(-9.28 * ndotv)) * r.x + r.y;

vec2 env = vec2(-1.04, 1.04) * a004 + r.zw;

#endif

}

#endif // LIGHT_ANISOTROPY_USED

// F

float cLdotH5 = SchlickFresnel(cLdotH);

vec3 specular_brdf_NL = cNdotL * D * F * G;

}

for (int i = 0; i < lightmap_textures.size(); i++) {

}

}

ERR_FAIL_V(AABB());

}

/* REFLECTION PROBE */

RID LightStorage::reflection_probe_allocate() {

return reflection_probe->ambient_color_energy;

}

/* LIGHTMAP API */

RID LightStorage::lightmap_allocate() {

//erase lightmap users

if (lm->light_texture.is_valid()) {

if (t) {

t->lightmap_users.erase(p_lightmap);

}

}

lm->light_texture = p_light;

lm->uses_spherical_harmonics = p_uses_spherical_haromics;

if (!t) {

if (using_lightmap_array) {

if (lm->array_index >= 0) {

lightmap_probe_capture_update_speed = p_speed;

}

void LightStorage::lightmap_tap_sh_light(RID p_lightmap, const Vector3 &p_point, Color *r_sh) {

Lightmap *lm = lightmap_owner.get_or_null(p_lightmap);

ERR_FAIL_COND(!lm);

namespace RendererRD {

class LightStorage : public RendererLightStorage {

private:

static LightStorage *singleton;

/* LIGHT */

mutable RID_Owner<Light, true> light_owner;

/* REFLECTION PROBE */

mutable RID_Owner<ReflectionProbe, true> reflection_probe_owner;

/* LIGHTMAP */

bool using_lightmap_array;

Vector<RID> lightmap_textures;

uint64_t lightmap_array_version = 0;

/* LIGHT */

bool owns_light(RID p_rid) { return light_owner.owns(p_rid); };

void _light_initialize(RID p_rid, RS::LightType p_type);

virtual uint32_t light_get_max_sdfgi_cascade(RID p_light) override;

virtual uint64_t light_get_version(RID p_light) const override;

/* REFLECTION PROBE */

bool owns_reflection_probe(RID p_rid) { return reflection_probe_owner.owns(p_rid); };

virtual RID reflection_probe_allocate() override;

Color reflection_probe_get_ambient_color(RID p_probe) const;

float reflection_probe_get_ambient_color_energy(RID p_probe) const;

/* LIGHTMAP */

bool owns_lightmap(RID p_rid) { return lightmap_owner.owns(p_rid); };

virtual RID lightmap_allocate() override;

virtual void lightmap_tap_sh_light(RID p_lightmap, const Vector3 &p_point, Color *r_sh) override;

virtual void lightmap_set_probe_capture_update_speed(float p_speed) override;

virtual float lightmap_get_probe_capture_update_speed() const override {

return lightmap_probe_capture_update_speed;

}

}

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

MaterialStorage *material_storage = MaterialStorage::get_singleton();

bool uses_global_buffer = false;

}

}

MaterialStorage *material_storage = MaterialStorage::get_singleton();

if (global_buffer_E) {

}

}

TextureStorage *texture_storage = TextureStorage::get_singleton();

MaterialStorage *material_storage = MaterialStorage::get_singleton();

#ifdef TOOLS_ENABLED

RS::TextureDetectRoughnessChannel roughness_channel = RS::TEXTURE_DETECT_ROUGHNESS_R;

#endif

bool uses_global_textures = false;

case ShaderLanguage::TYPE_SAMPLER2D: {

switch (p_texture_uniforms[i].hint) {

case ShaderLanguage::ShaderNode::Uniform::HINT_DEFAULT_BLACK: {

} break;

case ShaderLanguage::ShaderNode::Uniform::HINT_ANISOTROPY: {

} break;

case ShaderLanguage::ShaderNode::Uniform::HINT_NORMAL: {

} break;

case ShaderLanguage::ShaderNode::Uniform::HINT_ROUGHNESS_NORMAL: {

} break;

default: {

} break;

}

} break;

case ShaderLanguage::TYPE_SAMPLERCUBE: {

switch (p_texture_uniforms[i].hint) {

case ShaderLanguage::ShaderNode::Uniform::HINT_DEFAULT_BLACK: {

} break;

default: {

} break;

}

} break;

case ShaderLanguage::TYPE_SAMPLERCUBEARRAY: {

} break;

case ShaderLanguage::TYPE_ISAMPLER3D:

case ShaderLanguage::TYPE_USAMPLER3D:

case ShaderLanguage::TYPE_SAMPLER3D: {

} break;

case ShaderLanguage::TYPE_ISAMPLER2DARRAY:

case ShaderLanguage::TYPE_USAMPLER2DARRAY:

case ShaderLanguage::TYPE_SAMPLER2DARRAY: {

} break;

default: {

bool srgb = p_use_linear_color && p_texture_uniforms[i].use_color;

for (int j = 0; j < textures.size(); j++) {

if (tex) {

rd_texture = (srgb && tex->rd_texture_srgb.is_valid()) ? tex->rd_texture_srgb : tex->rd_texture;

#endif

}

if (rd_texture.is_null()) {

}

#ifdef TOOLS_ENABLED

if (roughness_detect_texture && normal_detect_texture && !normal_detect_texture->path.is_empty()) {

}

}

if (p_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(p_uniform_set)) {

RD::get_singleton()->uniform_set_set_invalidation_callback(p_uniform_set, nullptr, nullptr);

RD::get_singleton()->free(p_uniform_set);

}

}

if ((uint32_t)ubo_data.size() != p_ubo_size) {

p_uniform_dirty = true;

if (uniform_buffer.is_valid()) {

_material_queue_update(material, true, true);

}

void MaterialStorage::material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) {

Material *material = material_owner.get_or_null(p_material);

ERR_FAIL_COND(!material);

}

}

ERR_FAIL_INDEX(p_shader_type, SHADER_TYPE_MAX);

material_data_request_func[p_shader_type] = p_function;

}

ERR_FAIL_INDEX_V(p_shader_type, SHADER_TYPE_MAX, nullptr);

return material_data_request_func[p_shader_type];

}

namespace RendererRD {

};

};

private:

static MaterialStorage *singleton;

/* Samplers */

/* GLOBAL SHADER UNIFORM API */

int32_t _global_shader_uniform_allocate(uint32_t p_elements);

void _global_shader_uniform_store_in_buffer(int32_t p_index, RS::GlobalShaderUniformType p_type, const Variant &p_value);

/* SHADER API */

ShaderDataRequestFunction shader_data_request_func[SHADER_TYPE_MAX];

mutable RID_Owner<Shader, true> shader_owner;

/* MATERIAL API */

MaterialDataRequestFunction material_data_request_func[SHADER_TYPE_MAX];

mutable RID_Owner<Material, true> material_owner;

SelfList<Material>::List material_update_list;

/* SHADER API */

bool owns_shader(RID p_rid) { return shader_owner.owns(p_rid); };

virtual RID shader_allocate() override;

/* MATERIAL API */

bool owns_material(RID p_rid) { return material_owner.owns(p_rid); };

void _material_queue_update(Material *material, bool p_uniform, bool p_texture);

virtual void material_free(RID p_rid) override;

virtual void material_set_shader(RID p_material, RID p_shader) override;

virtual void material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) override;

virtual Variant material_get_param(RID p_material, const StringName &p_param) const override;

return mesh->blend_shape_count > 0 || (mesh->has_bone_weights && p_has_skeleton);

}

/* MESH INSTANCE */

RID MeshStorage::mesh_instance_create(RID p_base) {

return multimesh->mesh;

}

Transform3D MeshStorage::multimesh_instance_get_transform(RID p_multimesh, int p_index) const {

MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);

ERR_FAIL_COND_V(!multimesh, Transform3D());

namespace RendererRD {

};

};

void _mesh_surface_generate_version_for_input_mask(Mesh::Surface::Version &v, Mesh::Surface *s, uint32_t p_input_mask, MeshInstance::Surface *mis = nullptr);

void _mesh_instance_clear(MeshInstance *mi);

void _mesh_instance_add_surface(MeshInstance *mi, Mesh *mesh, uint32_t p_surface);

/* MultiMesh */

mutable RID_Owner<MultiMesh, true> multimesh_owner;

MultiMesh *multimesh_dirty_list = nullptr;

/* Skeleton */

mutable RID_Owner<Skeleton, true> skeleton_owner;

MeshStorage();

virtual ~MeshStorage();

/* MESH API */

bool owns_mesh(RID p_rid) { return mesh_owner.owns(p_rid); };

virtual RID mesh_allocate() override;

return s->particles_render_index;

}

/* MESH INSTANCE API */

virtual RID mesh_instance_create(RID p_base) override;

virtual void mesh_instance_free(RID p_rid) override;

/* MULTIMESH API */

bool owns_multimesh(RID p_rid) { return multimesh_owner.owns(p_rid); };

virtual RID multimesh_allocate() override;

return multimesh->uniform_set_2d;

}

/* SKELETON API */

virtual RID skeleton_allocate() override;

virtual void skeleton_initialize(RID p_skeleton) override;

particles_modes.push_back("");

particles_shader.shader.initialize(particles_modes, String());

}

{

ShaderCompiler::DefaultIdentifierActions actions;

material_storage->material_initialize(particles_shader.default_material);

material_storage->material_set_shader(particles_shader.default_material, particles_shader.default_shader);

particles_shader.default_shader_rd = particles_shader.shader.version_get_shader(md->shader_data->version, 0);

Vector<RD::Uniform> uniforms;

for (uint32_t i = 0; i < ParticlesFrameParams::MAX_3D_TEXTURES; i++) {

RID rd_tex;

if (i < collision_3d_textures_used) {

}

}

if (rd_tex == RID()) {

}

u.append_id(rd_tex);

}

if (collision_heightmap_texture.is_valid()) {

u.append_id(collision_heightmap_texture);

} else {

}

uniforms.push_back(u);

}

RD::get_singleton()->buffer_update(p_particles->frame_params_buffer, 0, sizeof(ParticlesFrameParams) * p_particles->trail_params.size(), p_particles->trail_params.ptr());

if (!m) {

}

ERR_FAIL_COND(!m);

void ParticlesStorage::_particles_update_buffers(Particles *particles) {

uint32_t userdata_count = 0;

}

if (userdata_count != particles->userdata_count) {

}

}

bool ParticlesStorage::particles_is_inactive(RID p_particles) const {

ERR_FAIL_COND_V_MSG(RSG::threaded, false, "This function should never be used with threaded rendering, as it stalls the renderer.");

const Particles *particles = particles_owner.get_or_null(p_particles);

}

}

ParticlesShaderData *shader_data = memnew(ParticlesShaderData);

return shader_data;

}

free_parameters_uniform_set(uniform_set);

}

ParticlesMaterialData *material_data = memnew(ParticlesMaterialData);

material_data->shader_data = p_shader;

//update will happen later anyway so do nothing.

return particles_collision->type == RS::PARTICLES_COLLISION_TYPE_HEIGHTFIELD_COLLIDE;

}

RID ParticlesStorage::particles_collision_instance_create(RID p_collision) {

ParticlesCollisionInstance pci;

pci.collision = p_collision;

namespace RendererRD {

};

};

void _particles_process(Particles *p_particles, double p_delta);

void _particles_allocate_emission_buffer(Particles *particles);

/* Particle Shader */

bool valid = false;

RID version;

bool uses_collision = false;

virtual ~ParticlesShaderData();

};

return ParticlesStorage::get_singleton()->_create_particles_shader_func();

}

ParticlesShaderData *shader_data = nullptr;

RID uniform_set;

virtual ~ParticlesMaterialData();

};

return ParticlesStorage::get_singleton()->_create_particles_material_func(static_cast<ParticlesShaderData *>(p_shader));

}

/* Particles Collision */

mutable RID_Owner<ParticlesCollision, true> particles_collision_owner;

mutable RID_Owner<ParticlesCollisionInstance> particles_collision_instance_owner;

/* PARTICLES */

bool owns_particles(RID p_rid) { return particles_owner.owns(p_rid); }

virtual RID particles_allocate() override;

virtual void update_particles() override;

/* Particles Collision */

bool owns_particles_collision(RID p_rid) { return particles_collision_owner.owns(p_rid); }

virtual RID particles_collision_allocate() override;

virtual bool particles_collision_is_heightfield(RID p_particles_collision) const override;

virtual RID particles_collision_get_heightfield_framebuffer(RID p_particles_collision) const override;

//used from 2D and 3D

bool owns_particles_collision_instance(RID p_rid) { return particles_collision_instance_owner.owns(p_rid); }

virtual RID particles_collision_instance_create(RID p_collision) override;

using namespace RendererRD;

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

if (cleared_cache) {

return;

}

cleared_cache = true;

}

clear_sets();

}

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

if (RD::get_singleton()->texture_is_valid(rd_texture_srgb)) {

//erase this first, as it's a dependency of the one below

RD::get_singleton()->free(rd_texture_srgb);

ct = t->canvas_texture;

} else {

}

if (!ct) {

Texture texture;

texture.width = p_image->get_width();

texture.height = p_image->get_height();

Texture texture;

texture.layered_type = p_layered_type;

texture.width = p_layers[0]->get_width();

Texture texture;

texture.width = p_width;

texture.height = p_height;

texture.depth = p_depth;

ERR_FAIL_COND(p_image->get_width() != tex->width || p_image->get_height() != tex->height);

ERR_FAIL_COND(p_image->get_format() != tex->format);

ERR_FAIL_INDEX(p_layer, tex->layers);

}

void TextureStorage::texture_3d_update(RID p_texture, const Vector<Ref<Image>> &p_data) {

Texture *tex = texture_owner.get_or_null(p_texture);

ERR_FAIL_COND(!tex);

Image::Image3DValidateError verr = Image::validate_3d_image(tex->format, tex->width, tex->height, tex->depth, tex->mipmaps > 1, p_data);

if (verr != Image::VALIDATE_3D_OK) {

Vector<Ref<Image>> TextureStorage::texture_3d_get(RID p_texture) const {

Texture *tex = texture_owner.get_or_null(p_texture);

ERR_FAIL_COND_V(!tex, Vector<Ref<Image>>());

Vector<uint8_t> all_data = RD::get_singleton()->texture_get_data(tex->rd_texture, 0);

void TextureStorage::texture_set_size_override(RID p_texture, int p_width, int p_height) {

Texture *tex = texture_owner.get_or_null(p_texture);

ERR_FAIL_COND(!tex);

tex->width_2d = p_width;

tex->height_2d = p_height;

return AABB(-decal->extents, decal->extents * 2.0);

}

void TextureStorage::update_decal_atlas() {

RendererRD::CopyEffects *copy_effects = RendererRD::CopyEffects::get_singleton();

ERR_FAIL_NULL(copy_effects);

namespace RendererRD {

public:

TYPE_2D,

TYPE_LAYERED,

TYPE_3D

};

};

};

//textures can be created from threads, so this RID_Owner is thread safe

mutable RID_Owner<Texture, true> texture_owner;

struct TextureToRDFormat {

RD::DataFormat format;

/* DECAL API */

mutable RID_Owner<Decal, true> decal_owner;

/* RENDER TARGET API */

mutable RID_Owner<RenderTarget> render_target_owner;

void _clear_render_target(RenderTarget *rt);

void _update_render_target(RenderTarget *rt);

void _render_target_clear_sdf(RenderTarget *rt);

Rect2i _render_target_get_sdf_rect(const RenderTarget *rt) const;

public:

static TextureStorage *get_singleton();

_FORCE_INLINE_ RID texture_rd_get_default(DefaultRDTexture p_texture) {

return default_rd_textures[p_texture];

}

/* Canvas Texture API */

bool owns_canvas_texture(RID p_rid) { return canvas_texture_owner.owns(p_rid); };

virtual RID canvas_texture_allocate() override;

/* Texture API */

virtual bool can_create_resources_async() const override;

virtual Size2 texture_size_with_proxy(RID p_proxy) override;

//internal usage

_FORCE_INLINE_ RID texture_get_rd_texture(RID p_texture, bool p_srgb = false) {

if (p_texture.is_null()) {

return RID();

}

if (!tex) {

return RID();

if (p_texture.is_null()) {

return Size2i();

}

if (!tex) {

return Size2i();

void update_decal_atlas();

RID decal_atlas_get_texture() const;

RID decal_atlas_get_texture_srgb() const;

}

virtual AABB decal_get_aabb(RID p_decal) const override;

/* RENDER TARGET API */

virtual RID render_target_create() override;

virtual void render_target_free(RID p_rid) override;

void Utilities::base_update_dependency(RID p_base, DependencyTracker *p_instance) {

if (MeshStorage::get_singleton()->owns_mesh(p_base)) {

} else if (MeshStorage::get_singleton()->owns_multimesh(p_base)) {

}

} else if (LightStorage::get_singleton()->owns_reflection_probe(p_base)) {

} else if (TextureStorage::get_singleton()->owns_decal(p_base)) {

} else if (GI::get_singleton()->owns_voxel_gi(p_base)) {

GI::VoxelGI *gip = GI::get_singleton()->get_voxel_gi(p_base);

p_instance->update_dependency(&gip->dependency);

} else if (LightStorage::get_singleton()->owns_lightmap(p_base)) {

} else if (LightStorage::get_singleton()->owns_light(p_base)) {

} else if (ParticlesStorage::get_singleton()->owns_particles(p_base)) {

} else if (ParticlesStorage::get_singleton()->owns_particles_collision(p_base)) {

} else if (Fog::get_singleton()->owns_fog_volume(p_base)) {

Fog::FogVolume *fv = Fog::get_singleton()->get_fog_volume(p_base);

p_instance->update_dependency(&fv->dependency);

// Fog

bool fog_enabled = false;

float fog_light_energy = 1.0;

float fog_sun_scatter = 0.0;

float fog_height = 0.0;

float fog_height_density = 0.0; //can be negative to invert effect

float fog_aerial_perspective = 0.0;

float volumetric_fog_anisotropy = 0.2;

float volumetric_fog_length = 64.0;

float volumetric_fog_detail_spread = 2.0;

bool volumetric_fog_temporal_reprojection = true;

float volumetric_fog_temporal_reprojection_amount = 0.9;

// Glow

bool glow_enabled = false;

CHECK(row5[1] == "tab separated");

CHECK(row5[2] == "lines, good?");

}

} // namespace TestFileAccess

#endif // TEST_FILE_ACCESS_H

CHECK(String::utf16(cs) == s);

}

TEST_CASE("[String] Invalid UTF8 (non-standard)") {

ERR_PRINT_OFF

static const uint8_t u8str[] = { 0x45, 0xE3, 0x81, 0x8A, 0xE3, 0x82, 0x88, 0xE3, 0x81, 0x86, 0xF0, 0x9F, 0x8E, 0xA4, 0xF0, 0x82, 0x82, 0xAC, 0xED, 0xA0, 0x81, 0 };

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

args.push_back(String::utf8(argv[i]));

}

// Run custom test tools.

if (test_commands) {