+Files: ./thirdparty/misc/easing_equations.cpp

+Comment: Robert Penner's Easing Functions

+Copyright: 2001, Robert Penner

+License: BSD-3-clause

+

+env_base.__class__.disable_warnings = methods.disable_warnings

+opts.Add(BoolVariable('builtin_xatlas', "Use the built-in xatlas library", True))

+ disable_nonessential_warnings = ['-Wno-sign-compare']

+ env.Append(CCFLAGS=['-Wall'] + disable_nonessential_warnings)

+ env.Append(CCFLAGS=['-Wall', '-Wno-unused'] + disable_nonessential_warnings)

+# Add required thirdparty code.

+env_thirdparty = env.Clone()

+env_thirdparty.disable_warnings()

+

+# Misc thirdparty code: header paths are hardcoded, we don't need to append

+thirdparty_misc_dir = "#thirdparty/misc/"

+thirdparty_misc_sources = [

+thirdparty_misc_sources = [thirdparty_misc_dir + file for file in thirdparty_misc_sources]

+env_thirdparty.add_source_files(env.core_sources, thirdparty_misc_sources)

+

+# Zlib library, can be unbundled

+if env['builtin_zlib']:

+ thirdparty_zlib_dir = "#thirdparty/zlib/"

+ thirdparty_zlib_sources = [

+ "adler32.c",

+ "compress.c",

+ "crc32.c",

+ "deflate.c",

+ "infback.c",

+ "inffast.c",

+ "inflate.c",

+ "inftrees.c",

+ "trees.c",

+ "uncompr.c",

+ "zutil.c",

+ ]

+ thirdparty_zlib_sources = [thirdparty_zlib_dir + file for file in thirdparty_zlib_sources]

+

+ env_thirdparty.Append(CPPPATH=[thirdparty_zlib_dir])

+ # Needs to be available in main env too

+ env.Append(CPPPATH=[thirdparty_zlib_dir])

+

+ env_thirdparty.add_source_files(env.core_sources, thirdparty_zlib_sources)

+

+# Minizip library, could be unbundled in theory

+env_thirdparty.add_source_files(env.core_sources, thirdparty_minizip_sources)

+

+# Zstd library, can be unbundled in theory

+# though we currently use some private symbols

+# https://github.com/godotengine/godot/issues/17374

+if env['builtin_zstd']:

+ thirdparty_zstd_dir = "#thirdparty/zstd/"

+ thirdparty_zstd_sources = [

+ "common/entropy_common.c",

+ "common/error_private.c",

+ "common/fse_decompress.c",

+ "common/pool.c",

+ "common/threading.c",

+ "common/xxhash.c",

+ "common/zstd_common.c",

+ "compress/fse_compress.c",

+ "compress/huf_compress.c",

+ "compress/zstd_compress.c",

+ "compress/zstd_double_fast.c",

+ "compress/zstd_fast.c",

+ "compress/zstd_lazy.c",

+ "compress/zstd_ldm.c",

+ "compress/zstdmt_compress.c",

+ "compress/zstd_opt.c",

+ "decompress/huf_decompress.c",

+ "decompress/zstd_decompress.c",

+ ]

+ thirdparty_zstd_sources = [thirdparty_zstd_dir + file for file in thirdparty_zstd_sources]

+

+ env_thirdparty.Append(CPPPATH=[thirdparty_zstd_dir, thirdparty_zstd_dir + "common"])

+ env_thirdparty.Append(CCFLAGS="-DZSTD_STATIC_LINKING_ONLY")

+ env.Append(CPPPATH=thirdparty_zstd_dir)

+ # Also needed in main env includes will trigger warnings

+ env.Append(CCFLAGS="-DZSTD_STATIC_LINKING_ONLY")

+

+ env_thirdparty.add_source_files(env.core_sources, thirdparty_zstd_sources)

+ case STATUS_BODY:

+ case STATUS_CONNECTION_ERROR:

+ case STATUS_SSL_HANDSHAKE_ERROR: {

+ default: {} // nothing to do at this stage

+ // Do nothing.

+ // Do nothing also. Remote cannot produce a local call.

+ case MultiplayerAPI::RPC_MODE_MASTERSYNC: {

+ if (is_master)

+ r_skip_rpc = true; // I am the master, so skip remote call.

+ } // Do not break, fall over to other sync.

+ // Call it, sync always results in a local call.

+ r_skip_rpc = true; // I am the master, so skip remote call.

+ if (!network_peer.is_valid()) // It's possible that polling might have resulted in a disconnection, so check here.

+ break; // It's also possible that a packet or RPC caused a disconnection, so also check here.

+ ERR_EXPLAIN("Multiplayer root node was not initialized. If you are using custom multiplayer, remember to set the root node via MultiplayerAPI.set_root_node before using it");

+ ERR_EXPLAIN("Invalid packet received. Size too small.");

+ ERR_EXPLAIN("Invalid packet received. Size too small.");

+ ERR_EXPLAIN("Invalid packet received. Requested node was not found.");

+ // Detect cstring end.

+ ERR_EXPLAIN("Invalid packet received. Size too small.");

+ // Use full path (not cached yet).

+

+ ERR_EXPLAIN("Invalid packet received. Size smaller than declared.");

+ // Use cached path.

+ ERR_EXPLAIN("Invalid packet received. Requests invalid peer cache.");

+ ERR_EXPLAIN("Invalid packet received. Unabled to find requested cached node.");

+ // Do proper caching later.

+ ERR_EXPLAIN("Invalid packet received. Size too small.");

+ // Check that remote can call the RPC on this node.

+

+ ERR_EXPLAIN("RPC '" + String(p_name) + "' is not allowed from: " + itos(p_from) + ". Mode is " + itos((int)rpc_mode) + ", master is " + itos(p_node->get_network_master()) + ".");

+ ERR_EXPLAIN("Invalid packet received. Size too small.");

+

+ ERR_EXPLAIN("Invalid packet received. Unable to decode RPC argument.");

+

+ ERR_EXPLAIN("Invalid packet received. Size too small.");

+ // Check that remote can call the RSET on this node.

+

+ ERR_EXPLAIN("RSET '" + String(p_name) + "' is not allowed from: " + itos(p_from) + ". Mode is " + itos((int)rset_mode) + ", master is " + itos(p_node->get_network_master()) + ".");

+ Error err = decode_variant(value, &p_packet[p_offset], p_packet_len - p_offset);

+

+ ERR_EXPLAIN("Invalid packet received. Unable to decode RSET value.");

+ ERR_FAIL_COND(err != OK);

+ ERR_EXPLAIN("Invalid packet received. Size too small.");

+ // Encode path to send ack.

+ ERR_EXPLAIN("Invalid packet received. Size too small.");

+ ERR_EXPLAIN("Invalid packet received. Tries to confirm a path which was not found in cache.");

+ ERR_EXPLAIN("Invalid packet received. Source peer was not found in cache for the given path.");

+ List<int> peers_to_add; // If one is missing, take note to add it.

+ continue; // Continue, excluded.

+ continue; // Continue, not for this peer.

+ // Path was not cached, or was cached but is unconfirmed.

+ // Not cached at all, take note.

+ // Those that need to be added, send a message for this.

+ // Encode function name.

+ network_peer->set_target_peer(E->get()); // To all of you.

+ psc->confirmed_peers.insert(E->get(), false); // Insert into confirmed, but as false since it was not confirmed.

+ ERR_EXPLAIN("Unable to send RPC. Relative path is empty. THIS IS LIKELY A BUG IN THE ENGINE!");

+ // See if the path is cached.

+ // Path is not cached, create.

+ // Create base packet, lots of hardcode because it must be tight.

+ // Encode type.

+ // Encode ID.

+ // Encode function name.

+ // Set argument.

+ ERR_EXPLAIN("Unable to encode RSET value. THIS IS LIKELY A BUG IN THE ENGINE!");

+ // Call arguments.

+ ERR_EXPLAIN("Unable to encode RPC argument. THIS IS LIKELY A BUG IN THE ENGINE!");

+ // See if all peers have cached path (is so, call can be fast).

+ // Take chance and set transfer mode, since all send methods will use it.

+ // They all have verified paths, so send fast.

+ network_peer->set_target_peer(p_to); // To all of you.

+ network_peer->put_packet(packet_cache.ptr(), ofs); // A message with love.

+ // Not all verified path, so send one by one.

+ // Append path at the end, since we will need it for some packets.

+ continue; // Continue, excluded.

+ continue; // Continue, not for this peer.

+ ERR_CONTINUE(!F); // Should never happen.

+ network_peer->set_target_peer(E->get()); // To this one specifically.

+ // This one confirmed path, so use id.

+ // This one did not confirm path yet, so use entire path (sorry!).

+ encode_uint32(0x80000000 | ofs, &(packet_cache.write[1])); // Offset to path and flag.

+ path_get_cache.erase(p_id); // I no longer need your cache, sorry.

+ ERR_EXPLAIN("Trying to call an RPC while no network peer is active.");

+ ERR_EXPLAIN("Trying to call an RPC on a node which is not inside SceneTree.");

+ ERR_FAIL_COND(!p_node->is_inside_tree());

+ ERR_EXPLAIN("Trying to call an RPC via a network peer which is not connected.");

+ ERR_FAIL_COND(network_peer->get_connection_status() != NetworkedMultiplayerPeer::CONNECTION_CONNECTED);

+ // Check that send mode can use local call.

+ // Done below.

+ // Attempt with script.

+ ERR_EXPLAIN("Trying to RSET while no network peer is active.");

+ ERR_EXPLAIN("Trying to RSET on a node which is not inside SceneTree.");

+ ERR_FAIL_COND(!p_node->is_inside_tree());

+ ERR_EXPLAIN("Trying to send an RSET via a network peer which is not connected.");

+ ERR_FAIL_COND(network_peer->get_connection_status() != NetworkedMultiplayerPeer::CONNECTION_CONNECTED);

+ // Check that send mode can use local call.

+ // Attempt with script.

+ ERR_EXPLAIN("Trying to send an empty raw packet.");

+ ERR_EXPLAIN("Trying to send a raw packet while no network peer is active.");

+ ERR_EXPLAIN("Trying to send a raw packet via a network peer which is not connected.");

+ ERR_EXPLAIN("Invalid packet received. Size too small.");

+ ERR_EXPLAIN("No network peer is assigned. Unable to get unique network ID.");

+ // XXX Maybe fail silently? Maybe should actually return true to make development of both local and online multiplayer easier?

+ ERR_EXPLAIN("No network peer is assigned. I can't be a server.");

+ ERR_EXPLAIN("No network peer is assigned. Unable to set 'refuse_new_connections'.");

+ ERR_EXPLAIN("No network peer is assigned. Unable to get 'refuse_new_connections'.");

+ ERR_EXPLAIN("No network peer is assigned. Assume no peers are connected.");

+ BIND_ENUM_CONSTANT(RPC_MODE_SLAVE); // Deprecated.

+ BIND_ENUM_CONSTANT(RPC_MODE_SYNC); // Deprecated.

+ f->store_32((utf8.length() + 1) | 0x80000000);

+/*************************************************************************/

+/* zip_io.cpp */

+/*************************************************************************/

+/* This file is part of: */

+/* GODOT ENGINE */

+/* https://godotengine.org */

+/*************************************************************************/

+/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */

+/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */

+/* */

+/* Permission is hereby granted, free of charge, to any person obtaining */

+/* a copy of this software and associated documentation files (the */

+/* "Software"), to deal in the Software without restriction, including */

+/* without limitation the rights to use, copy, modify, merge, publish, */

+/* distribute, sublicense, and/or sell copies of the Software, and to */

+/* permit persons to whom the Software is furnished to do so, subject to */

+/* the following conditions: */

+/* */

+/* The above copyright notice and this permission notice shall be */

+/* included in all copies or substantial portions of the Software. */

+/* */

+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */

+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */

+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/

+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */

+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */

+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */

+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */

+/*************************************************************************/

+

+#include "zip_io.h"

+

+#include "core/os/copymem.h"

+

+void *zipio_open(void *data, const char *p_fname, int mode) {

+

+ FileAccess *&f = *(FileAccess **)data;

+

+ String fname;

+ fname.parse_utf8(p_fname);

+

+ if (mode & ZLIB_FILEFUNC_MODE_WRITE) {

+ f = FileAccess::open(fname, FileAccess::WRITE);

+ } else {

+

+ f = FileAccess::open(fname, FileAccess::READ);

+ }

+

+ if (!f)

+ return NULL;

+

+ return data;

+}

+

+uLong zipio_read(void *data, void *fdata, void *buf, uLong size) {

+

+ FileAccess *f = *(FileAccess **)data;

+ return f->get_buffer((uint8_t *)buf, size);

+}

+

+uLong zipio_write(voidpf opaque, voidpf stream, const void *buf, uLong size) {

+

+ FileAccess *f = *(FileAccess **)opaque;

+ f->store_buffer((uint8_t *)buf, size);

+ return size;

+}

+

+long zipio_tell(voidpf opaque, voidpf stream) {

+

+ FileAccess *f = *(FileAccess **)opaque;

+ return f->get_position();

+}

+

+long zipio_seek(voidpf opaque, voidpf stream, uLong offset, int origin) {

+

+ FileAccess *f = *(FileAccess **)opaque;

+

+ int pos = offset;

+ switch (origin) {

+

+ case ZLIB_FILEFUNC_SEEK_CUR:

+ pos = f->get_position() + offset;

+ break;

+ case ZLIB_FILEFUNC_SEEK_END:

+ pos = f->get_len() + offset;

+ break;

+ default:

+ break;

+ };

+

+ f->seek(pos);

+ return 0;

+}

+

+int zipio_close(voidpf opaque, voidpf stream) {

+

+ FileAccess *&f = *(FileAccess **)opaque;

+ if (f) {

+ f->close();

+ f = NULL;

+ }

+ return 0;

+}

+

+int zipio_testerror(voidpf opaque, voidpf stream) {

+

+ FileAccess *f = *(FileAccess **)opaque;

+ return (f && f->get_error() != OK) ? 1 : 0;

+}

+

+voidpf zipio_alloc(voidpf opaque, uInt items, uInt size) {

+

+ voidpf ptr = memalloc(items * size);

+ zeromem(ptr, items * size);

+ return ptr;

+}

+

+void zipio_free(voidpf opaque, voidpf address) {

+

+ memfree(address);

+}

+

+zlib_filefunc_def zipio_create_io_from_file(FileAccess **p_file) {

+

+ zlib_filefunc_def io;

+ io.opaque = p_file;

+ io.zopen_file = zipio_open;

+ io.zread_file = zipio_read;

+ io.zwrite_file = zipio_write;

+ io.ztell_file = zipio_tell;

+ io.zseek_file = zipio_seek;

+ io.zclose_file = zipio_close;

+ io.zerror_file = zipio_testerror;

+ io.alloc_mem = zipio_alloc;

+ io.free_mem = zipio_free;

+ return io;

+}

+// Not direclty used in this header, but assumed available in downstream users

+// like platform/*/export/export.cpp. Could be fixed, but probably better to have

+// thirdparty includes in as little headers as possible.

+void *zipio_open(void *data, const char *p_fname, int mode);

+uLong zipio_read(void *data, void *fdata, void *buf, uLong size);

+uLong zipio_write(voidpf opaque, voidpf stream, const void *buf, uLong size);

+long zipio_tell(voidpf opaque, voidpf stream);

+long zipio_seek(voidpf opaque, voidpf stream, uLong offset, int origin);

+int zipio_close(voidpf opaque, voidpf stream);

+int zipio_testerror(voidpf opaque, voidpf stream);

+voidpf zipio_alloc(voidpf opaque, uInt items, uInt size);

+void zipio_free(voidpf opaque, voidpf address);

+zlib_filefunc_def zipio_create_io_from_file(FileAccess **p_file);

+ for (int i = 1; i < data->path.size(); i++) {

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

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

+ flags(METHOD_FLAG_NORMAL),

+ ObjectID instance_id = ++instance_counter;

+ instances[instance_id] = p_object;

+ instance_checks[p_object] = instance_id;

+

+ return instance_id;

+ PROPERTY_USAGE_HIGH_END_GFX = 1 << 22,

+ List<PropertyInfo> arguments;

+ Vector<Variant> default_arguments;

+ case ACCESS_MAX: break; // Can't happen, but silences warning

+ case ACCESS_MAX: break; // Can't happen, but silences warning

+ max_errors_per_frame(GLOBAL_GET("network/limits/debugger_stdout/max_errors_per_frame")),

+ max_cps(GLOBAL_GET("network/limits/debugger_stdout/max_chars_per_second")),

+ char_count(0),

+#define ABS(m_v) (((m_v) < 0) ? (-(m_v)) : (m_v))

+#define SGN(m_v) (((m_v) < 0) ? (-1.0) : (+1.0))

+ Extra Mouse Button 1

+ Extra Mouse Button 2

+ Extra Mouse Button 1 Mask

+ Extra Mouse Button 2 Mask

+ return false

+ The [code]ArrayMesh[/code] is used to construct a [Mesh] by specifying the attributes as arrays. The most basic example is the creation of a single triangle

+ [codeblock]

+ var vertices = PoolVector3Array()

+ vertices.push_back(Vector3(0,1,0))

+ vertices.push_back(Vector3(1,0,0))

+ vertices.push_back(Vector3(0,0,1))

+ # Initialize the ArrayMesh.

+ var arr_mesh = ArrayMesh.new()

+ var arrays = []

+ arrays.resize(ArrayMesh.ARRAY_MAX)

+ arrays[ArrayMesh.ARRAY_VERTEX] = vertices

+ # Create the Mesh.

+ arr_mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arrays)

+ var m = MeshInstance.new()

+ m.mesh = arr_mesh

+ [/codeblock]

+ The [code]MeshInstance[/code] is ready to be added to the SceneTree to be shown.

+ If [code]true[/code] the mouse button's state is a double-click.

+ Packets are not acknowledged, no resend attempts are made for lost packets. Packets may arrive in any order. Potentially faster than [code]TRANSFER_MODE_UNRELIABLE_ORDERED[/code]. Use for non-critical data, and always consider whether the order matters.

+ Packets are not acknowledged, no resend attempts are made for lost packets. Packets are received in the order they were sent in. Potentially faster than [code]TRANSFER_MODE_RELIABLE[/code]. Use for non-critical data or data that would be outdated if received late due to resend attempt(s) anyway, for example movement and positional data.

+ Packets must be received and resend attempts should be made until the packets are acknowledged. Packets must be received in the order they were sent in. Most reliable transfer mode, but potentially slowest due to the overhead. Use for critical data that must be transmitted and arrive in order, for example an ability being triggered or a chat message. Consider carefully if the information really is critical, and use sparingly.

+ The arguments are used in the given order and separated by a space, so [code]OS.execute('ping', ['-w', '3', 'godotengine.org'], false)[/code] will resolve to [code]ping -w 3 godotengine.org[/code] in the system's shell.

+ <constant name="BODY_MODE_CHARACTER" value="3" enum="BodyMode">

+ Cast a [String] value to a floating point value. This method accepts float value strings like [code] '1.23' [/code] and exponential notation strings for its parameter so calling [code] float('1e3') [/code] will return 1000.0 and calling [code] float('1e-3') [/code] will return 0.001.

+env_thirdparty = env.Clone()

+env_thirdparty.disable_warnings()

+env_thirdparty.add_source_files(env.drivers_sources, thirdparty_sources)

+ void reflection_probe_set_resolution(RID p_probe, int p_resolution) {}

+ virtual bool is_low_end() const { return true; }

+

+ env_thirdparty = env.Clone()

+ env_thirdparty.disable_warnings()

+ env_thirdparty.add_source_files(env.drivers_sources, thirdparty_sources)

+

+env.add_source_files(env.drivers_sources, "*.cpp")

+ virtual bool is_low_end() const { return true; }

+

+

+ RasterizerStorageGLES2::ReflectionProbe *probe = storage->reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND_V(!probe, RID());

+

+ ReflectionProbeInstance *rpi = memnew(ReflectionProbeInstance);

+

+ rpi->probe_ptr = probe;

+ rpi->self = reflection_probe_instance_owner.make_rid(rpi);

+ rpi->probe = p_probe;

+ rpi->reflection_atlas_index = -1;

+ rpi->render_step = -1;

+ rpi->last_pass = 0;

+ rpi->current_resolution = 0;

+ rpi->dirty = true;

+

+ rpi->last_pass = 0;

+ rpi->index = 0;

+

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

+ glGenFramebuffers(1, &rpi->fbo[i]);

+ }

+

+ glGenFramebuffers(1, &rpi->fbo_blur);

+ glGenRenderbuffers(1, &rpi->depth);

+ glGenTextures(1, &rpi->cubemap);

+

+ return rpi->self;

+

+ ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);

+ ERR_FAIL_COND(!rpi);

+ rpi->transform = p_transform;

+ const ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);

+ ERR_FAIL_COND_V(!rpi, false);

+

+ bool need_redraw = rpi->probe_ptr->resolution != rpi->current_resolution || rpi->dirty || rpi->probe_ptr->update_mode == VS::REFLECTION_PROBE_UPDATE_ALWAYS;

+ rpi->dirty = false;

+ return need_redraw;

+ return true;

+

+ ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);

+ ERR_FAIL_COND_V(!rpi, false);

+

+ rpi->render_step = 0;

+

+ if (rpi->probe_ptr->resolution != rpi->current_resolution) {

+

+ //update cubemap if resolution changed

+ int size = rpi->probe_ptr->resolution;

+ rpi->current_resolution = size;

+

+ int lod = 0;

+

+ GLenum internal_format = GL_RGBA;

+ GLenum format = GL_RGBA;

+ GLenum type = GL_UNSIGNED_BYTE;

+

+ glActiveTexture(GL_TEXTURE0);

+ glBindTexture(GL_TEXTURE_CUBE_MAP, rpi->cubemap);

+

+ // Set the initial (empty) mipmaps, all need to be set for this to work in GLES2, even if later wont be used.

+ while (size >= 1) {

+

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

+ glTexImage2D(_cube_side_enum[i], lod, internal_format, size, size, 0, format, type, NULL);

+ if (size == rpi->current_resolution) {

+ //adjust framebuffer

+ glBindFramebuffer(GL_FRAMEBUFFER, rpi->fbo[i]);

+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, _cube_side_enum[i], rpi->cubemap, 0);

+ glBindRenderbuffer(GL_RENDERBUFFER, rpi->depth);

+ glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, size, size);

+ glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rpi->depth);

+

+#ifdef DEBUG_ENABLED

+ GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);

+ ERR_CONTINUE(status != GL_FRAMEBUFFER_COMPLETE);

+#endif

+ }

+ }

+

+ lod++;

+

+ size >>= 1;

+ }

+

+ glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

+ glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

+ glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

+ glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

+ }

+

+ return true;

+

+ ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);

+ ERR_FAIL_COND_V(!rpi, false);

+

+ int size = rpi->probe_ptr->resolution;

+

+ {

+ glBindBuffer(GL_ARRAY_BUFFER, 0);

+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

+ glDisable(GL_CULL_FACE);

+ glDisable(GL_DEPTH_TEST);

+ glDisable(GL_SCISSOR_TEST);

+ glDisable(GL_BLEND);

+ glDepthMask(GL_FALSE);

+

+ for (int i = 0; i < VS::ARRAY_MAX - 1; i++) {

+ glDisableVertexAttribArray(i);

+ }

+ }

+

+ //vdc cache

+ glActiveTexture(GL_TEXTURE1);

+ glBindTexture(GL_TEXTURE_2D, storage->resources.radical_inverse_vdc_cache_tex);

+

+ glBindFramebuffer(GL_FRAMEBUFFER, rpi->fbo_blur);

+ // now render to the framebuffer, mipmap level for mipmap level

+ int lod = 1;

+ glActiveTexture(GL_TEXTURE0);

+ glBindTexture(GL_TEXTURE_CUBE_MAP, rpi->cubemap);

+ glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); //use linear, no mipmaps so it does not read from what is being written to

+

+ size >>= 1;

+ int mipmaps = 6;

+ int mm_level = mipmaps - 1;

+

+ storage->shaders.cubemap_filter.set_conditional(CubemapFilterShaderGLES2::USE_SOURCE_PANORAMA, false);

+ storage->shaders.cubemap_filter.bind();

+

+ //blur

+ while (size >= 1) {

+

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

+ glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, _cube_side_enum[i], rpi->cubemap, lod);

+

+ glViewport(0, 0, size, size);

+ storage->bind_quad_array();

+ storage->shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES2::FACE_ID, i);

+ float roughness = CLAMP(lod / (float)(mipmaps - 1), 0, 1);

+ storage->shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES2::ROUGHNESS, roughness);

+ storage->shaders.cubemap_filter.set_uniform(CubemapFilterShaderGLES2::Z_FLIP, false);

+

+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

+ }

+

+ size >>= 1;

+

+ mm_level--;

+

+ lod++;

+ }

+

+ // restore ranges

+

+ glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

+ glBindFramebuffer(GL_FRAMEBUFFER, 0);

+

+ return true;

+ e->instancing = (e->instance->base_type == VS::INSTANCE_MULTIMESH) ? 1 : 0;

+ e->refprobe_0_index = RenderList::MAX_REFLECTION_PROBES; //refprobe disabled by default

+ e->refprobe_1_index = RenderList::MAX_REFLECTION_PROBES; //refprobe disabled by default

+ int rpsize = e->instance->reflection_probe_instances.size();

+ if (rpsize > 0) {

+ bool first = true;

+ rpsize = MIN(rpsize, 2); //more than 2 per object are not supported, this keeps it stable

+

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

+ ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(e->instance->reflection_probe_instances[i]);

+ if (rpi->last_pass != render_pass) {

+ continue;

+ }

+ if (first) {

+ e->refprobe_0_index = rpi->index;

+ first = false;

+ } else {

+ e->refprobe_1_index = rpi->index;

+ break;

+ }

+ }

+

+ /* if (e->refprobe_0_index > e->refprobe_1_index) { //if both are valid, swap them to keep order as best as possible

+ uint64_t tmp = e->refprobe_0_index;

+ e->refprobe_0_index = e->refprobe_1_index;

+ e->refprobe_1_index = tmp;

+ }*/

+ }

+ default: {}

+ glVertexAttrib4f(VS::ARRAY_NORMAL, 0.0, 0.0, 1, 1);

+ glEnableVertexAttribArray(INSTANCE_BONE_BASE + 0);

+ glEnableVertexAttribArray(INSTANCE_BONE_BASE + 1);

+ glEnableVertexAttribArray(INSTANCE_BONE_BASE + 2);

+ glVertexAttribPointer(INSTANCE_BONE_BASE + 0, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 12, (const void *)(sizeof(float) * 4 * 0));

+ glVertexAttribPointer(INSTANCE_BONE_BASE + 1, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 12, (const void *)(sizeof(float) * 4 * 1));

+ glVertexAttribPointer(INSTANCE_BONE_BASE + 2, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 12, (const void *)(sizeof(float) * 4 * 2));

+ glDisableVertexAttribArray(INSTANCE_BONE_BASE + 0);

+ glDisableVertexAttribArray(INSTANCE_BONE_BASE + 1);

+ glDisableVertexAttribArray(INSTANCE_BONE_BASE + 2);

+ glVertexAttrib4f(VS::ARRAY_NORMAL, 0.0, 0.0, 1, 1);

+ // prepare multimesh (disable)

+ glDisableVertexAttribArray(INSTANCE_ATTRIB_BASE + 0);

+ glDisableVertexAttribArray(INSTANCE_ATTRIB_BASE + 1);

+ glDisableVertexAttribArray(INSTANCE_ATTRIB_BASE + 2);

+ glDisableVertexAttribArray(INSTANCE_ATTRIB_BASE + 3);

+ glDisableVertexAttribArray(INSTANCE_ATTRIB_BASE + 4);

+ glDisableVertexAttribArray(INSTANCE_BONE_BASE + 0);

+ glDisableVertexAttribArray(INSTANCE_BONE_BASE + 1);

+ glDisableVertexAttribArray(INSTANCE_BONE_BASE + 2);

+ default: {}

+ /*

+*/

+ const float *base_buffer = multi_mesh->data.ptr();

+

+ const float *buffer = base_buffer + i * stride;

+

+ glVertexAttrib4fv(INSTANCE_ATTRIB_BASE + 0, &buffer[0]);

+ glVertexAttrib4fv(INSTANCE_ATTRIB_BASE + 1, &buffer[4]);

+ glVertexAttrib4fv(INSTANCE_ATTRIB_BASE + 2, &buffer[8]);

+ glVertexAttrib4f(INSTANCE_ATTRIB_BASE + 3, color_data[0] / 255.0, color_data[1] / 255.0, color_data[2] / 255.0, color_data[3] / 255.0);

+ glVertexAttrib4fv(INSTANCE_ATTRIB_BASE + 3, buffer + color_ofs);

+ glVertexAttrib4f(INSTANCE_ATTRIB_BASE + 4, custom_data[0] / 255.0, custom_data[1] / 255.0, custom_data[2] / 255.0, custom_data[3] / 255.0);

+ glVertexAttrib4fv(INSTANCE_ATTRIB_BASE + 4, buffer + custom_data_ofs);

+ default: {}

+ if (!state.render_no_shadows && p_light->light_ptr->shadow) {

+ if (!state.render_no_shadows && shadow_atlas && p_light->light_ptr->shadow) {

+ if (!state.render_no_shadows && shadow_atlas && p_light->light_ptr->shadow) {

+ if (!state.render_no_shadows && light_ptr->shadow && directional_shadow.depth) {

+ float attenuation = light_ptr->param[VS::LIGHT_PARAM_ATTENUATION];

+ if (!state.render_no_shadows && light_ptr->shadow && shadow_atlas && shadow_atlas->shadow_owners.has(light->self)) {

+ float attenuation = light_ptr->param[VS::LIGHT_PARAM_ATTENUATION];

+ if (!state.render_no_shadows && light->light_ptr->shadow && shadow_atlas && shadow_atlas->shadow_owners.has(light->self)) {

+ default: {}

+ }

+}

+

+void RasterizerSceneGLES2::_setup_refprobes(ReflectionProbeInstance *p_refprobe1, ReflectionProbeInstance *p_refprobe2, const Transform &p_view_transform, Environment *p_env) {

+

+ if (p_refprobe1) {

+ state.scene_shader.set_uniform(SceneShaderGLES2::REFPROBE1_USE_BOX_PROJECT, p_refprobe1->probe_ptr->box_projection);

+ state.scene_shader.set_uniform(SceneShaderGLES2::REFPROBE1_BOX_EXTENTS, p_refprobe1->probe_ptr->extents);

+ state.scene_shader.set_uniform(SceneShaderGLES2::REFPROBE1_BOX_OFFSET, p_refprobe1->probe_ptr->origin_offset);

+ state.scene_shader.set_uniform(SceneShaderGLES2::REFPROBE1_EXTERIOR, !p_refprobe1->probe_ptr->interior);

+ state.scene_shader.set_uniform(SceneShaderGLES2::REFPROBE1_INTENSITY, p_refprobe1->probe_ptr->intensity);

+

+ Color ambient;

+ if (p_refprobe1->probe_ptr->interior) {

+ ambient = p_refprobe1->probe_ptr->interior_ambient * p_refprobe1->probe_ptr->interior_ambient_energy;

+ ambient.a = p_refprobe1->probe_ptr->interior_ambient_probe_contrib;

+ } else if (p_env) {

+ ambient = p_env->ambient_color * p_env->ambient_energy;

+ ambient.a = p_env->ambient_sky_contribution;

+ }

+

+ state.scene_shader.set_uniform(SceneShaderGLES2::REFPROBE1_AMBIENT, ambient);

+

+ Transform proj = (p_view_transform.inverse() * p_refprobe1->transform).affine_inverse();

+

+ state.scene_shader.set_uniform(SceneShaderGLES2::REFPROBE1_LOCAL_MATRIX, proj);

+ }

+

+ if (p_refprobe2) {

+ state.scene_shader.set_uniform(SceneShaderGLES2::REFPROBE2_USE_BOX_PROJECT, p_refprobe2->probe_ptr->box_projection);

+ state.scene_shader.set_uniform(SceneShaderGLES2::REFPROBE2_BOX_EXTENTS, p_refprobe2->probe_ptr->extents);

+ state.scene_shader.set_uniform(SceneShaderGLES2::REFPROBE2_BOX_OFFSET, p_refprobe2->probe_ptr->origin_offset);

+ state.scene_shader.set_uniform(SceneShaderGLES2::REFPROBE2_EXTERIOR, !p_refprobe2->probe_ptr->interior);

+ state.scene_shader.set_uniform(SceneShaderGLES2::REFPROBE2_INTENSITY, p_refprobe2->probe_ptr->intensity);

+

+ Color ambient;

+ if (p_refprobe2->probe_ptr->interior) {

+ ambient = p_refprobe2->probe_ptr->interior_ambient * p_refprobe2->probe_ptr->interior_ambient_energy;

+ ambient.a = p_refprobe2->probe_ptr->interior_ambient_probe_contrib;

+ } else if (p_env) {

+ ambient = p_env->ambient_color * p_env->ambient_energy;

+ ambient.a = p_env->ambient_sky_contribution;

+ }

+ state.scene_shader.set_uniform(SceneShaderGLES2::REFPROBE2_AMBIENT, ambient);

+

+ Transform proj = (p_view_transform.inverse() * p_refprobe2->transform).affine_inverse();

+

+ state.scene_shader.set_uniform(SceneShaderGLES2::REFPROBE2_LOCAL_MATRIX, proj);

+ Vector2 screen_pixel_size = state.screen_pixel_size;

+ RasterizerStorageGLES2::GeometryOwner *prev_owner = NULL;

+ ReflectionProbeInstance *prev_refprobe_1 = NULL;

+ ReflectionProbeInstance *prev_refprobe_2 = NULL;

+ RasterizerStorageGLES2::Texture *prev_lightmap = NULL;

+ float lightmap_energy = 1.0;

+ bool prev_use_lightmap_capture = false;

+

+ ReflectionProbeInstance *refprobe_1 = NULL;

+ ReflectionProbeInstance *refprobe_2 = NULL;

+ RasterizerStorageGLES2::Texture *lightmap = NULL;

+ bool use_lightmap_capture = false;

+ bool rebind_light = false;

+ bool rebind_reflection = false;

+ bool rebind_lightmap = false;

+ rebind_light = true;

+

+ if (!unshaded && !accum_pass && e->refprobe_0_index != RenderList::MAX_REFLECTION_PROBES) {

+ ERR_FAIL_INDEX(e->refprobe_0_index, reflection_probe_count);

+ refprobe_1 = reflection_probe_instances[e->refprobe_0_index];

+ }

+ if (!unshaded && !accum_pass && e->refprobe_1_index != RenderList::MAX_REFLECTION_PROBES) {

+ ERR_FAIL_INDEX(e->refprobe_1_index, reflection_probe_count);

+ refprobe_2 = reflection_probe_instances[e->refprobe_1_index];

+ }

+

+ if (refprobe_1 != prev_refprobe_1 || refprobe_2 != prev_refprobe_2) {

+ state.scene_shader.set_conditional(SceneShaderGLES2::USE_REFLECTION_PROBE1, refprobe_1 != NULL);

+ state.scene_shader.set_conditional(SceneShaderGLES2::USE_REFLECTION_PROBE2, refprobe_2 != NULL);

+ if (refprobe_1 != NULL && refprobe_1 != prev_refprobe_1) {

+ glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 5);

+ glBindTexture(GL_TEXTURE_CUBE_MAP, refprobe_1->cubemap);

+ }

+ if (refprobe_2 != NULL && refprobe_2 != prev_refprobe_2) {

+ glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 6);

+ glBindTexture(GL_TEXTURE_CUBE_MAP, refprobe_2->cubemap);

+ }

+ rebind = true;

+ rebind_reflection = true;

+ }

+

+ use_lightmap_capture = !unshaded && !accum_pass && !e->instance->lightmap_capture_data.empty();

+

+ if (use_lightmap_capture != prev_use_lightmap_capture) {

+

+ state.scene_shader.set_conditional(SceneShaderGLES2::USE_LIGHTMAP_CAPTURE, use_lightmap_capture);

+ rebind = true;

+ }

+

+ if (!unshaded && !accum_pass && e->instance->lightmap.is_valid()) {

+

+ lightmap = storage->texture_owner.getornull(e->instance->lightmap);

+ lightmap_energy = 1.0;

+ if (lightmap) {

+ RasterizerStorageGLES2::LightmapCapture *capture = storage->lightmap_capture_data_owner.getornull(e->instance->lightmap_capture->base);

+ if (capture) {

+ lightmap_energy = capture->energy;

+ }

+ }

+ }

+

+ if (lightmap != prev_lightmap) {

+ state.scene_shader.set_conditional(SceneShaderGLES2::USE_LIGHTMAP, lightmap != NULL);

+ if (lightmap != NULL) {

+ glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 4);

+ glBindTexture(GL_TEXTURE_2D, lightmap->tex_id);

+ }

+ rebind = true;

+ rebind_lightmap = true;

+ }

+ bool instancing = e->instance->base_type == VS::INSTANCE_MULTIMESH;

+ state.scene_shader.set_conditional(SceneShaderGLES2::USE_SKELETON, true);

+ if (e->owner != prev_owner || e->geometry != prev_geometry || skeleton != prev_skeleton) {

+ if (i == 0 || shader_rebind) { //first time must rebind

+

+ //rebind all these

+ rebind_light = true;

+ rebind_reflection = true;

+ rebind_lightmap = true;

+ if (rebind_light && light) {

+ _setup_light(light, shadow_atlas, p_view_transform);

+ }

+

+ if (rebind_reflection && (refprobe_1 || refprobe_2)) {

+ _setup_refprobes(refprobe_1, refprobe_2, p_view_transform, p_env);

+ }

+

+ if (rebind_lightmap && lightmap) {

+ state.scene_shader.set_uniform(SceneShaderGLES2::LIGHTMAP_ENERGY, lightmap_energy);

+ }

+

+ if (use_lightmap_capture) { //this is per instance, must be set always if present

+ glUniform4fv(state.scene_shader.get_uniform_location(SceneShaderGLES2::LIGHTMAP_CAPTURES), 12, (const GLfloat *)e->instance->lightmap_capture_data.ptr());

+ state.scene_shader.set_uniform(SceneShaderGLES2::LIGHTMAP_CAPTURE_SKY, false);

+ }

+

+ prev_owner = e->owner;

+ prev_refprobe_1 = refprobe_1;

+ prev_refprobe_2 = refprobe_2;

+ prev_lightmap = lightmap;

+ prev_use_lightmap_capture = use_lightmap_capture;

+ state.scene_shader.set_conditional(SceneShaderGLES2::USE_SKELETON, false);

+ state.scene_shader.set_conditional(SceneShaderGLES2::USE_INSTANCING, false);

+ state.scene_shader.set_conditional(SceneShaderGLES2::USE_REFLECTION_PROBE1, false);

+ state.scene_shader.set_conditional(SceneShaderGLES2::USE_REFLECTION_PROBE2, false);

+ state.scene_shader.set_conditional(SceneShaderGLES2::USE_LIGHTMAP, false);

+ state.scene_shader.set_conditional(SceneShaderGLES2::USE_LIGHTMAP_CAPTURE, false);

+ GLuint current_fb = 0;

+ Environment *env = NULL;

+

+ int viewport_width, viewport_height;

+

+ if (p_reflection_probe.is_valid()) {

+ ReflectionProbeInstance *probe = reflection_probe_instance_owner.getornull(p_reflection_probe);

+ ERR_FAIL_COND(!probe);

+ state.render_no_shadows = !probe->probe_ptr->enable_shadows;

+

+ if (!probe->probe_ptr->interior) { //use env only if not interior

+ env = environment_owner.getornull(p_environment);

+ }

+

+ current_fb = probe->fbo[p_reflection_probe_pass];

+ state.screen_pixel_size.x = 1.0 / probe->probe_ptr->resolution;

+ state.screen_pixel_size.y = 1.0 / probe->probe_ptr->resolution;

+

+ viewport_width = probe->probe_ptr->resolution;

+ viewport_height = probe->probe_ptr->resolution;

+

+ } else {

+ state.render_no_shadows = false;

+ current_fb = storage->frame.current_rt->fbo;

+ env = environment_owner.getornull(p_environment);

+ state.screen_pixel_size.x = 1.0 / storage->frame.current_rt->width;

+ state.screen_pixel_size.y = 1.0 / storage->frame.current_rt->height;

+ viewport_width = storage->frame.current_rt->width;

+ viewport_height = storage->frame.current_rt->height;

+ }

+ if (p_reflection_probe_cull_count) {

+ reflection_probe_instances = (ReflectionProbeInstance **)alloca(sizeof(ReflectionProbeInstance *) * p_reflection_probe_cull_count);

+ reflection_probe_count = p_reflection_probe_cull_count;

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

+ ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_reflection_probe_cull_result[i]);

+ ERR_CONTINUE(!rpi);

+ rpi->last_pass = render_pass + 1; //will be incremented later

+ rpi->index = i;

+ reflection_probe_instances[i] = rpi;

+ }

+

+ } else {

+ reflection_probe_instances = NULL;

+ reflection_probe_count = 0;

+ }

+ glViewport(0, 0, viewport_width, viewport_height);

+ state.render_no_shadows = false;

+

+

+ if (light_instance_owner.owns(p_rid)) {

+

+ LightInstance *light_instance = light_instance_owner.getptr(p_rid);

+

+ //remove from shadow atlases..

+ for (Set<RID>::Element *E = light_instance->shadow_atlases.front(); E; E = E->next()) {

+ ShadowAtlas *shadow_atlas = shadow_atlas_owner.get(E->get());

+ ERR_CONTINUE(!shadow_atlas->shadow_owners.has(p_rid));

+ uint32_t key = shadow_atlas->shadow_owners[p_rid];

+ uint32_t q = (key >> ShadowAtlas::QUADRANT_SHIFT) & 0x3;

+ uint32_t s = key & ShadowAtlas::SHADOW_INDEX_MASK;

+

+ shadow_atlas->quadrants[q].shadows.write[s].owner = RID();

+ shadow_atlas->shadow_owners.erase(p_rid);

+ }

+

+ light_instance_owner.free(p_rid);

+ memdelete(light_instance);

+

+ } else if (shadow_atlas_owner.owns(p_rid)) {

+

+ ShadowAtlas *shadow_atlas = shadow_atlas_owner.get(p_rid);

+ shadow_atlas_set_size(p_rid, 0);

+ shadow_atlas_owner.free(p_rid);

+ memdelete(shadow_atlas);

+ } else if (reflection_probe_instance_owner.owns(p_rid)) {

+

+ ReflectionProbeInstance *reflection_instance = reflection_probe_instance_owner.get(p_rid);

+

+ reflection_probe_release_atlas_index(p_rid);

+ reflection_probe_instance_owner.free(p_rid);

+ memdelete(reflection_instance);

+

+ } else {

+ return false;

+ }

+

+ enum {

+ INSTANCE_ATTRIB_BASE = 8,

+ INSTANCE_BONE_BASE = 13,

+ };

+

+ bool render_no_shadows;

+

+ Vector2 screen_pixel_size;

+ struct ReflectionProbeInstance : public RID_Data {

+

+ RasterizerStorageGLES2::ReflectionProbe *probe_ptr;

+ RID probe;

+ RID self;

+ RID atlas;

+

+ int reflection_atlas_index;

+

+ int render_step;

+ int reflection_index;

+

+ GLuint fbo[6];

+ GLuint cubemap;

+ GLuint depth;

+

+ GLuint fbo_blur;

+

+ int current_resolution;

+ mutable bool dirty;

+

+ uint64_t last_pass;

+ uint32_t index;

+

+ Transform transform;

+ };

+

+ mutable RID_Owner<ReflectionProbeInstance> reflection_probe_instance_owner;

+

+ ReflectionProbeInstance **reflection_probe_instances;

+ int reflection_probe_count;

+

+ MAX_REFLECTION_PROBES = 255,

+ _FORCE_INLINE_ void _setup_refprobes(ReflectionProbeInstance *p_refprobe1, ReflectionProbeInstance *p_refprobe2, const Transform &p_view_transform, Environment *p_env);

+ int data_size = Image::get_image_data_size(texture->alloc_width, texture->alloc_height, real_format, texture->mipmaps > 1);

+ roughness = MIN(1.0, roughness); //keep max at 1

+ case ShaderLanguage::TYPE_SAMPLER2DARRAY:

+ case ShaderLanguage::TYPE_ISAMPLER2DARRAY:

+ case ShaderLanguage::TYPE_USAMPLER2DARRAY:

+ case ShaderLanguage::TYPE_SAMPLER3D:

+ case ShaderLanguage::TYPE_ISAMPLER3D:

+ case ShaderLanguage::TYPE_USAMPLER3D: {

+ // Not implemented in GLES2

+ mesh_aabb.size += Vector3(0.001, 0.001, 0.001); //in case mesh is empty in one of the sides

+

+ default: {}

+

+ ReflectionProbe *reflection_probe = memnew(ReflectionProbe);

+

+ reflection_probe->intensity = 1.0;

+ reflection_probe->interior_ambient = Color();

+ reflection_probe->interior_ambient_energy = 1.0;

+ reflection_probe->max_distance = 0;

+ reflection_probe->extents = Vector3(1, 1, 1);

+ reflection_probe->origin_offset = Vector3(0, 0, 0);

+ reflection_probe->interior = false;

+ reflection_probe->box_projection = false;

+ reflection_probe->enable_shadows = false;

+ reflection_probe->cull_mask = (1 << 20) - 1;

+ reflection_probe->update_mode = VS::REFLECTION_PROBE_UPDATE_ONCE;

+ reflection_probe->resolution = 128;

+

+ return reflection_probe_owner.make_rid(reflection_probe);

+

+ ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND(!reflection_probe);

+

+ reflection_probe->update_mode = p_mode;

+ reflection_probe->instance_change_notify();

+

+ ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND(!reflection_probe);

+

+ reflection_probe->intensity = p_intensity;

+

+ ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND(!reflection_probe);

+

+ reflection_probe->interior_ambient = p_ambient;

+

+ ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND(!reflection_probe);

+

+ reflection_probe->interior_ambient_energy = p_energy;

+

+ ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND(!reflection_probe);

+

+ reflection_probe->interior_ambient_probe_contrib = p_contrib;

+ ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND(!reflection_probe);

+

+ reflection_probe->max_distance = p_distance;

+ reflection_probe->instance_change_notify();

+void RasterizerStorageGLES2::reflection_probe_set_extents(RID p_probe, const Vector3 &p_extents) {

+

+ ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND(!reflection_probe);

+ reflection_probe->extents = p_extents;

+ reflection_probe->instance_change_notify();

+}

+

+ ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND(!reflection_probe);

+

+ reflection_probe->origin_offset = p_offset;

+ reflection_probe->instance_change_notify();

+ ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND(!reflection_probe);

+

+ reflection_probe->interior = p_enable;

+}

+

+ ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND(!reflection_probe);

+

+ reflection_probe->box_projection = p_enable;

+ ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND(!reflection_probe);

+

+ reflection_probe->enable_shadows = p_enable;

+ reflection_probe->instance_change_notify();

+}

+

+ ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND(!reflection_probe);

+

+ reflection_probe->cull_mask = p_layers;

+ reflection_probe->instance_change_notify();

+}

+

+void RasterizerStorageGLES2::reflection_probe_set_resolution(RID p_probe, int p_resolution) {

+

+ ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND(!reflection_probe);

+

+ reflection_probe->resolution = p_resolution;

+ const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND_V(!reflection_probe, AABB());

+

+ AABB aabb;

+ aabb.position = -reflection_probe->extents;

+ aabb.size = reflection_probe->extents * 2.0;

+

+ return aabb;

+

+ const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND_V(!reflection_probe, VS::REFLECTION_PROBE_UPDATE_ALWAYS);

+

+ return reflection_probe->update_mode;

+

+ const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND_V(!reflection_probe, 0);

+

+ return reflection_probe->cull_mask;

+

+ const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND_V(!reflection_probe, Vector3());

+

+ return reflection_probe->extents;

+

+ const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND_V(!reflection_probe, Vector3());

+

+ return reflection_probe->origin_offset;

+

+ const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND_V(!reflection_probe, false);

+

+ return reflection_probe->enable_shadows;

+

+ const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND_V(!reflection_probe, 0);

+

+ return reflection_probe->max_distance;

+}

+

+int RasterizerStorageGLES2::reflection_probe_get_resolution(RID p_probe) const {

+

+ const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);

+ ERR_FAIL_COND_V(!reflection_probe, 0);

+

+ return reflection_probe->resolution;

+

+ LightmapCapture *capture = memnew(LightmapCapture);

+ return lightmap_capture_data_owner.make_rid(capture);

+ LightmapCapture *capture = lightmap_capture_data_owner.getornull(p_capture);

+ ERR_FAIL_COND(!capture);

+ capture->bounds = p_bounds;

+ capture->instance_change_notify();

+AABB RasterizerStorageGLES2::lightmap_capture_get_bounds(RID p_capture) const {

+ const LightmapCapture *capture = lightmap_capture_data_owner.getornull(p_capture);

+ ERR_FAIL_COND_V(!capture, AABB());

+ return capture->bounds;

+void RasterizerStorageGLES2::lightmap_capture_set_octree(RID p_capture, const PoolVector<uint8_t> &p_octree) {

+

+ LightmapCapture *capture = lightmap_capture_data_owner.getornull(p_capture);

+ ERR_FAIL_COND(!capture);

+ ERR_FAIL_COND(p_octree.size() == 0 || (p_octree.size() % sizeof(LightmapCaptureOctree)) != 0);

+

+ capture->octree.resize(p_octree.size() / sizeof(LightmapCaptureOctree));

+ if (p_octree.size()) {

+ PoolVector<LightmapCaptureOctree>::Write w = capture->octree.write();

+ PoolVector<uint8_t>::Read r = p_octree.read();

+ copymem(w.ptr(), r.ptr(), p_octree.size());

+ }

+ capture->instance_change_notify();

+}

+

+ const LightmapCapture *capture = lightmap_capture_data_owner.getornull(p_capture);

+ ERR_FAIL_COND_V(!capture, PoolVector<uint8_t>());

+

+ if (capture->octree.size() == 0)

+ return PoolVector<uint8_t>();

+

+ PoolVector<uint8_t> ret;

+ ret.resize(capture->octree.size() * sizeof(LightmapCaptureOctree));

+ {

+ PoolVector<LightmapCaptureOctree>::Read r = capture->octree.read();

+ PoolVector<uint8_t>::Write w = ret.write();

+ copymem(w.ptr(), r.ptr(), ret.size());

+ }

+

+ return ret;

+ LightmapCapture *capture = lightmap_capture_data_owner.getornull(p_capture);

+ ERR_FAIL_COND(!capture);

+ capture->cell_xform = p_xform;

+ const LightmapCapture *capture = lightmap_capture_data_owner.getornull(p_capture);

+ ERR_FAIL_COND_V(!capture, Transform());

+ return capture->cell_xform;

+ LightmapCapture *capture = lightmap_capture_data_owner.getornull(p_capture);

+ ERR_FAIL_COND(!capture);

+ capture->cell_subdiv = p_subdiv;

+ const LightmapCapture *capture = lightmap_capture_data_owner.getornull(p_capture);

+ ERR_FAIL_COND_V(!capture, 0);

+ return capture->cell_subdiv;

+

+ LightmapCapture *capture = lightmap_capture_data_owner.getornull(p_capture);

+ ERR_FAIL_COND(!capture);

+ capture->energy = p_energy;

+

+ const LightmapCapture *capture = lightmap_capture_data_owner.getornull(p_capture);

+ ERR_FAIL_COND_V(!capture, 0);

+ return capture->energy;

+ const LightmapCapture *capture = lightmap_capture_data_owner.getornull(p_capture);

+ ERR_FAIL_COND_V(!capture, NULL);

+ return &capture->octree;

+

+ Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);

+ ERR_FAIL_COND(!skeleton);

+

+ skeleton->instances.insert(p_instance);

+

+ Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);

+ ERR_FAIL_COND(!skeleton);

+

+ skeleton->instances.erase(p_instance);

+

+ Instantiable *inst = NULL;

+ switch (p_instance->base_type) {

+ case VS::INSTANCE_MESH: {

+ inst = mesh_owner.getornull(p_base);

+ ERR_FAIL_COND(!inst);

+ } break;

+ case VS::INSTANCE_MULTIMESH: {

+ inst = multimesh_owner.getornull(p_base);

+ ERR_FAIL_COND(!inst);

+ } break;

+ case VS::INSTANCE_IMMEDIATE: {

+ inst = immediate_owner.getornull(p_base);

+ ERR_FAIL_COND(!inst);

+ } break;

+ /*case VS::INSTANCE_PARTICLES: {

+ inst = particles_owner.getornull(p_base);

+ ERR_FAIL_COND(!inst);

+ } break;*/

+ case VS::INSTANCE_REFLECTION_PROBE: {

+ inst = reflection_probe_owner.getornull(p_base);

+ ERR_FAIL_COND(!inst);

+ } break;

+ case VS::INSTANCE_LIGHT: {

+ inst = light_owner.getornull(p_base);

+ ERR_FAIL_COND(!inst);

+ } break;

+ /*case VS::INSTANCE_GI_PROBE: {

+ inst = gi_probe_owner.getornull(p_base);

+ ERR_FAIL_COND(!inst);

+ } break;*/

+ case VS::INSTANCE_LIGHTMAP_CAPTURE: {

+ inst = lightmap_capture_data_owner.getornull(p_base);

+ ERR_FAIL_COND(!inst);

+ } break;

+ default: {

+ if (!inst) {

+ ERR_FAIL();

+ }

+ }

+ }

+

+ inst->instance_list.add(&p_instance->dependency_item);

+

+ Instantiable *inst = NULL;

+

+ switch (p_instance->base_type) {

+ case VS::INSTANCE_MESH: {

+ inst = mesh_owner.getornull(p_base);

+ ERR_FAIL_COND(!inst);

+ } break;

+ case VS::INSTANCE_MULTIMESH: {

+ inst = multimesh_owner.getornull(p_base);

+ ERR_FAIL_COND(!inst);

+ } break;

+ case VS::INSTANCE_IMMEDIATE: {

+ inst = immediate_owner.getornull(p_base);

+ ERR_FAIL_COND(!inst);

+ } break;

+ /*case VS::INSTANCE_PARTICLES: {

+ inst = particles_owner.getornull(p_base);

+ ERR_FAIL_COND(!inst);

+ } break;*/

+ case VS::INSTANCE_REFLECTION_PROBE: {

+ inst = reflection_probe_owner.getornull(p_base);

+ ERR_FAIL_COND(!inst);

+ } break;

+ case VS::INSTANCE_LIGHT: {

+ inst = light_owner.getornull(p_base);

+ ERR_FAIL_COND(!inst);

+ } break;

+ /*case VS::INSTANCE_GI_PROBE: {

+ inst = gi_probe_owner.getornull(p_base);

+ ERR_FAIL_COND(!inst);

+ } break; */

+ case VS::INSTANCE_LIGHTMAP_CAPTURE: {

+ inst = lightmap_capture_data_owner.getornull(p_base);

+ ERR_FAIL_COND(!inst);

+ } break;

+ default: {

+

+ if (!inst) {

+ ERR_FAIL();

+ }

+ }

+ }

+

+ ERR_FAIL_COND(!inst);

+

+ inst->instance_list.remove(&p_instance->dependency_item);

+ glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, rt->width, rt->height);

+ } else if (reflection_probe_owner.owns(p_rid)) {

+ return VS::INSTANCE_REFLECTION_PROBE;

+ } else if (lightmap_capture_data_owner.owns(p_rid)) {

+ return VS::INSTANCE_LIGHTMAP_CAPTURE;

+ } else if (reflection_probe_owner.owns(p_rid)) {

+

+ // delete the texture

+ ReflectionProbe *reflection_probe = reflection_probe_owner.get(p_rid);

+ reflection_probe->instance_remove_deps();

+

+ reflection_probe_owner.free(p_rid);

+ memdelete(reflection_probe);

+

+ return true;

+ } else if (lightmap_capture_data_owner.owns(p_rid)) {

+

+ // delete the texture

+ LightmapCapture *lightmap_capture = lightmap_capture_data_owner.get(p_rid);

+ lightmap_capture->instance_remove_deps();

+

+ lightmap_capture_data_owner.free(p_rid);

+ memdelete(lightmap_capture);

+ return true;

+

+ config.float_texture_supported = config.extensions.has("GL_ARB_texture_float") || config.extensions.has("GL_OES_texture_float");

+ config.s3tc_supported = config.extensions.has("GL_EXT_texture_compression_s3tc");

+ config.etc1_supported = config.extensions.has("GL_OES_compressed_ETC1_RGB8_texture");

+ if (true /*||config.float_texture_supported*/) { //uint8 is similar and works everywhere

+ uint8_t radical_inverse[512];

+ radical_inverse[i] = uint8_t(CLAMP(value * 255.0, 0, 255));

+ glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 512, 1, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, radical_inverse);

+ //this needs to be enabled manually in OpenGL 2.1

+

+ glEnable(GL_POINT_SPRITE);

+ glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);

+ update_dirty_multimeshes();

+ struct Instantiable : public RID_Data {

+ Instantiable() {}

+ virtual ~Instantiable() {}

+ struct GeometryOwner : public Instantiable {

+ struct Geometry : public Instantiable {

+ struct Light : Instantiable {

+

+ struct ReflectionProbe : Instantiable {

+

+ VS::ReflectionProbeUpdateMode update_mode;

+ float intensity;

+ Color interior_ambient;

+ float interior_ambient_energy;

+ float interior_ambient_probe_contrib;

+ float max_distance;

+ Vector3 extents;

+ Vector3 origin_offset;

+ bool interior;

+ bool box_projection;

+ bool enable_shadows;

+ uint32_t cull_mask;

+ int resolution;

+ };

+

+ mutable RID_Owner<ReflectionProbe> reflection_probe_owner;

+

+ virtual void reflection_probe_set_resolution(RID p_probe, int p_resolution);

+ virtual int reflection_probe_get_resolution(RID p_probe) const;

+

+ struct LightmapCapture : public Instantiable {

+

+ PoolVector<LightmapCaptureOctree> octree;

+ AABB bounds;

+ Transform cell_xform;

+ int cell_subdiv;

+ float energy;

+ LightmapCapture() {

+ energy = 1.0;

+ cell_subdiv = 1;

+ }

+ };

+

+ mutable RID_Owner<LightmapCapture> lightmap_capture_data_owner;

+

+ code += "mod(float(";

+ code += "), float(";

+ code += "))";

+ for (size_t i = 0; i < default_arg_size; i++) {

+

+ case ShaderLanguage::TYPE_SAMPLER2DARRAY:

+ case ShaderLanguage::TYPE_ISAMPLER2DARRAY:

+ case ShaderLanguage::TYPE_USAMPLER2DARRAY:

+ case ShaderLanguage::TYPE_SAMPLER3D:

+ case ShaderLanguage::TYPE_ISAMPLER3D:

+ case ShaderLanguage::TYPE_USAMPLER3D: {

+ // Not implemented in GLES2

+ } break;

+

+ case ShaderLanguage::TYPE_VOID: {

+ // Nothing to do?

+ } break;

+ vec3 L = (2.0 * dot(V, H) * H - V);

+ vec3 val = texturePanorama(source_panorama, L).rgb;

+ vec3 val = textureCubeLod(source_cube, L, 0.0).rgb;

+ //mix using Linear, to approximate high end back-end

+ val = mix(pow((val + vec3(0.055)) * (1.0 / (1.0 + 0.055)), vec3(2.4)), val * (1.0 / 12.92), vec3(lessThan(val, vec3(0.04045))));

+

+ sum.rgb += val * NdotL;

+ vec3 a = vec3(0.055);

+ sum.rgb = mix((vec3(1.0) + a) * pow(sum.rgb, vec3(1.0 / 2.4)) - a, 12.92 * sum.rgb, vec3(lessThan(sum.rgb, vec3(0.0031308))));

+

+#if defined(ENABLE_COLOR_INTERP)

+#if defined(ENABLE_UV_INTERP)

+#if defined(ENABLE_UV2_INTERP) || defined(USE_LIGHTMAP)

+attribute highp vec4 bone_transform_row_0; // attrib:13

+attribute highp vec4 bone_transform_row_1; // attrib:14

+attribute highp vec4 bone_transform_row_2; // attrib:15

+#if defined(ENABLE_COLOR_INTERP)

+#if defined(ENABLE_UV_INTERP)

+#if defined(ENABLE_UV2_INTERP) || defined(USE_LIGHTMAP)

+uniform float light_attenuation;

+#ifdef USE_VERTEX_LIGHTING

+

+#ifdef USE_REFLECTION_PROBE1

+

+uniform mat4 refprobe1_local_matrix;

+varying mediump vec4 refprobe1_reflection_normal_blend;

+uniform vec3 refprobe1_box_extents;

+

+#ifndef USE_LIGHTMAP

+varying mediump vec3 refprobe1_ambient_normal;

+#endif

+

+#endif //reflection probe1

+

+#ifdef USE_REFLECTION_PROBE2

+

+uniform mat4 refprobe2_local_matrix;

+varying mediump vec4 refprobe2_reflection_normal_blend;

+uniform vec3 refprobe2_box_extents;

+

+#ifndef USE_LIGHTMAP

+varying mediump vec3 refprobe2_ambient_normal;

+#endif

+

+#endif //reflection probe2

+

+#endif //vertex lighting for refprobes

+

+

+#if defined(ENABLE_COLOR_INTERP)

+#if defined(ENABLE_UV_INTERP)

+#if defined(ENABLE_UV2_INTERP) || defined(USE_LIGHTMAP)

+ if (normalized_distance < 1.0) {

+ float omni_attenuation = pow(1.0 - normalized_distance, light_attenuation);

+

+ vec3 attenuation = vec3(omni_attenuation);

+ light_att = vec3(omni_attenuation);

+ } else {

+ light_att = vec3(0.0);

+ }

+ if (normalized_distance < 1.0) {

+ float spot_attenuation = pow(1.0 - normalized_distance, light_attenuation);

+ vec3 spot_dir = light_direction;

+ float spot_cutoff = light_spot_angle;

+ float angle = dot(-normalize(light_rel_vec), spot_dir);

+

+ if (angle > spot_cutoff) {

+

+ float scos = max(angle, spot_cutoff);

+ float spot_rim = max(0.0001, (1.0 - scos) / (1.0 - spot_cutoff));

+

+ spot_attenuation *= 1.0 - pow(spot_rim, light_spot_attenuation);

+

+ light_att = vec3(spot_attenuation);

+ } else {

+ light_att = vec3(0.0);

+ }

+ } else {

+ light_att = vec3(0.0);

+ }

+ shadow_coord4 = light_shadow_matrix4 * vi4;

+#ifdef USE_VERTEX_LIGHTING

+

+#ifdef USE_REFLECTION_PROBE1

+ {

+ vec3 ref_normal = normalize(reflect(vertex_interp, normal_interp));

+ vec3 local_pos = (refprobe1_local_matrix * vec4(vertex_interp, 1.0)).xyz;

+ vec3 inner_pos = abs(local_pos / refprobe1_box_extents);

+ float blend = max(inner_pos.x, max(inner_pos.y, inner_pos.z));

+

+ {

+ vec3 local_ref_vec = (refprobe1_local_matrix * vec4(ref_normal, 0.0)).xyz;

+ refprobe1_reflection_normal_blend.xyz = local_ref_vec;

+ refprobe1_reflection_normal_blend.a = blend;

+ }

+#ifndef USE_LIGHTMAP

+

+ refprobe1_ambient_normal = (refprobe1_local_matrix * vec4(normal_interp, 0.0)).xyz;

+#endif

+ }

+

+#endif //USE_REFLECTION_PROBE1

+

+#ifdef USE_REFLECTION_PROBE2

+ {

+ vec3 ref_normal = normalize(reflect(vertex_interp, normal_interp));

+ vec3 local_pos = (refprobe2_local_matrix * vec4(vertex_interp, 1.0)).xyz;

+ vec3 inner_pos = abs(local_pos / refprobe2_box_extents);

+ float blend = max(inner_pos.x, max(inner_pos.y, inner_pos.z));

+

+ {

+ vec3 local_ref_vec = (refprobe2_local_matrix * vec4(ref_normal, 0.0)).xyz;

+ refprobe2_reflection_normal_blend.xyz = local_ref_vec;

+ refprobe2_reflection_normal_blend.a = blend;

+ }

+#ifndef USE_LIGHTMAP

+

+ refprobe2_ambient_normal = (refprobe2_local_matrix * vec4(normal_interp, 0.0)).xyz;

+#endif

+ }

+

+#endif //USE_REFLECTION_PROBE2

+

+#endif //use vertex lighting

+#if defined(SCREEN_UV_USED)

+#ifdef USE_REFLECTION_PROBE1

+

+#ifdef USE_VERTEX_LIGHTING

+

+varying mediump vec4 refprobe1_reflection_normal_blend;

+#ifndef USE_LIGHTMAP

+varying mediump vec3 refprobe1_ambient_normal;

+#endif

+

+#else

+

+uniform bool refprobe1_use_box_project;

+uniform vec3 refprobe1_box_extents;

+uniform vec3 refprobe1_box_offset;

+uniform mat4 refprobe1_local_matrix;

+

+#endif //use vertex lighting

+

+uniform bool refprobe1_exterior;

+

+uniform highp samplerCube reflection_probe1; //texunit:-5

+

+uniform float refprobe1_intensity;

+uniform vec4 refprobe1_ambient;

+

+#endif //USE_REFLECTION_PROBE1

+

+#ifdef USE_REFLECTION_PROBE2

+

+#ifdef USE_VERTEX_LIGHTING

+

+varying mediump vec4 refprobe2_reflection_normal_blend;

+#ifndef USE_LIGHTMAP

+varying mediump vec3 refprobe2_ambient_normal;

+#endif

+

+#else

+

+uniform bool refprobe2_use_box_project;

+uniform vec3 refprobe2_box_extents;

+uniform vec3 refprobe2_box_offset;

+uniform mat4 refprobe2_local_matrix;

+

+#endif //use vertex lighting

+

+uniform bool refprobe2_exterior;

+

+uniform highp samplerCube reflection_probe2; //texunit:-6

+

+uniform float refprobe2_intensity;

+uniform vec4 refprobe2_ambient;

+

+#endif //USE_REFLECTION_PROBE2

+#if defined(USE_REFLECTION_PROBE1) || defined(USE_REFLECTION_PROBE2)

+

+void reflection_process(samplerCube reflection_map,

+#ifdef USE_VERTEX_LIGHTING

+ vec3 ref_normal,

+#ifndef USE_LIGHTMAP

+ vec3 amb_normal,

+#endif

+ float ref_blend,

+

+#else //no vertex lighting

+ vec3 normal, vec3 vertex,

+ mat4 local_matrix,

+ bool use_box_project, vec3 box_extents, vec3 box_offset,

+#endif //vertex lighting

+ bool exterior, float intensity, vec4 ref_ambient, float roughness, vec3 ambient, vec3 skybox, inout highp vec4 reflection_accum, inout highp vec4 ambient_accum) {

+

+ vec4 reflection;

+

+#ifdef USE_VERTEX_LIGHTING

+

+ reflection.rgb = textureCubeLod(reflection_map, ref_normal, roughness * RADIANCE_MAX_LOD).rgb;

+

+ float blend = ref_blend; //crappier blend formula for vertex

+ blend *= blend;

+ blend = max(0.0, 1.0 - blend);

+

+#else //fragment lighting

+

+ vec3 local_pos = (local_matrix * vec4(vertex, 1.0)).xyz;

+

+ if (any(greaterThan(abs(local_pos), box_extents))) { //out of the reflection box

+ return;

+ }

+

+ vec3 inner_pos = abs(local_pos / box_extents);

+ float blend = max(inner_pos.x, max(inner_pos.y, inner_pos.z));

+ blend = mix(length(inner_pos), blend, blend);

+ blend *= blend;

+ blend = max(0.0, 1.0 - blend);

+

+ //reflect and make local

+ vec3 ref_normal = normalize(reflect(vertex, normal));

+ ref_normal = (local_matrix * vec4(ref_normal, 0.0)).xyz;

+

+ if (use_box_project) { //box project

+

+ vec3 nrdir = normalize(ref_normal);

+ vec3 rbmax = (box_extents - local_pos) / nrdir;

+ vec3 rbmin = (-box_extents - local_pos) / nrdir;

+

+ vec3 rbminmax = mix(rbmin, rbmax, vec3(greaterThan(nrdir, vec3(0.0, 0.0, 0.0))));

+

+ float fa = min(min(rbminmax.x, rbminmax.y), rbminmax.z);

+ vec3 posonbox = local_pos + nrdir * fa;

+ ref_normal = posonbox - box_offset.xyz;

+ }

+

+ reflection.rgb = textureCubeLod(reflection_map, ref_normal, roughness * RADIANCE_MAX_LOD).rgb;

+#endif

+

+ if (exterior) {

+ reflection.rgb = mix(skybox, reflection.rgb, blend);

+ }

+ reflection.rgb *= intensity;

+ reflection.a = blend;

+ reflection.rgb *= blend;

+

+ reflection_accum += reflection;

+

+#ifndef USE_LIGHTMAP

+

+ vec4 ambient_out;

+#ifndef USE_VERTEX_LIGHTING

+

+ vec3 amb_normal = (local_matrix * vec4(normal, 0.0)).xyz;

+#endif

+

+ ambient_out.rgb = textureCubeLod(reflection_map, amb_normal, RADIANCE_MAX_LOD).rgb;

+ ambient_out.rgb = mix(ref_ambient.rgb, ambient_out.rgb, ref_ambient.a);

+ if (exterior) {

+ ambient_out.rgb = mix(ambient, ambient_out.rgb, blend);

+ }

+

+ ambient_out.a = blend;

+ ambient_out.rgb *= blend;

+ ambient_accum += ambient_out;

+

+#endif

+}

+

+#endif //use refprobe 1 or 2

+

+#ifdef USE_LIGHTMAP

+uniform mediump sampler2D lightmap; //texunit:-4

+uniform mediump float lightmap_energy;

+#endif

+

+#ifdef USE_LIGHTMAP_CAPTURE

+uniform mediump vec4[12] lightmap_captures;

+uniform bool lightmap_capture_sky;

+

+#endif

+

+#ifdef USE_RADIANCE_MAP

+

+uniform float light_attenuation;

+#if defined(ENABLE_COLOR_INTERP)

+#if defined(ENABLE_UV_INTERP)