+ <key>UseGroupMemberPagination</key>

+ <map>

+ <key>Comment</key>

+ <string>Enable pagination of group memeber list 50 members at a time.</string>

+ <key>Persist</key>

+ <integer>1</integer>

+ <key>Type</key>

+ <string>Boolean</string>

+ <key>Value</key>

+ <integer>0</integer>

+ </map>

+ <key>LuaDebugShowSource</key>

+ <map>

+ <key>Comment</key>

+ <string>Show source info in Lua Debug Console output</string>

+ <key>Persist</key>

+ <integer>1</integer>

+ <key>Type</key>

+ <string>Boolean</string>

+ <key>Value</key>

+ <integer>0</integer>

+ </map>

+ <key>MapShowGridCoords</key>

+ <map>

+ <key>Comment</key>

+ <string>Shows/hides the grid coordinates of each region on the world map.</string>

+ <key>Persist</key>

+ <integer>1</integer>

+ <key>Type</key>

+ <string>Boolean</string>

+ <key>Value</key>

+ <integer>0</integer>

+ </map>

+ <real>1.5</real>

+ <real>0.7</real>

+ <integer>1</integer>

+ <integer>1</integer>

+ <integer>8</integer>

+ * @file pbrTerrainBakeF.glsl

+/**

+ * @file terrainStampF.glsl

+ *

+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$

+ * Second Life Viewer Source Code

+ * Copyright (C) 2024, Linden Research, Inc.

+ *

+ * This library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation;

+ * version 2.1 of the License only.

+ *

+ * This library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this library; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ *

+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA

+ * $/LicenseInfo$

+ */

+

+/*[EXTRA_CODE_HERE]*/

+

+out vec4 frag_color;

+

+// Paint texture to stamp into the "paintmap"

+uniform sampler2D diffuseMap;

+

+in vec2 vary_texcoord0;

+

+void main()

+{

+ vec4 col = texture(diffuseMap, vary_texcoord0);

+ if (col.a <= 0.0f)

+ {

+ discard;

+ }

+

+ frag_color = max(col, vec4(0));

+}

+/**

+ * @file terrainStampV.glsl

+ *

+ * $LicenseInfo:firstyear=2007&license=viewerlgpl$

+ * Second Life Viewer Source Code

+ * Copyright (C) 2024, Linden Research, Inc.

+ *

+ * This library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation;

+ * version 2.1 of the License only.

+ *

+ * This library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this library; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ *

+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA

+ * $/LicenseInfo$

+ */

+

+uniform mat4 modelview_projection_matrix;

+uniform vec2 terrain_stamp_scale;

+

+in vec3 position;

+

+out vec2 vary_texcoord0;

+

+void main()

+{

+ gl_Position = modelview_projection_matrix * vec4(position, 1.0);

+ // Positions without transforms are treated as UVs for the purpose of this shader.

+ vary_texcoord0.xy = terrain_stamp_scale * position.xy;

+}

+

+RenderHeroProbeUpdateRate 1 6

+RenderHeroProbeUpdateRate 1 6

+ [=, this]()

+#include "llavatarname.h"

+#include "llavatarnamecache.h"

+#include "llviewercontrol.h"

+#include "llviewercamera.h"

+#include "resultset.h"

+

+ add("getID",

+ "Return your own avatar ID",

+ &LLAgentListener::getID,

+ llsd::map("reply", LLSD()));

+

+ add("getNearbyAvatarsList",

+ "Return result set key [\"result\"] for nearby avatars in a range of [\"dist\"]\n"

+ "if [\"dist\"] is not specified, 'RenderFarClip' setting is used\n"

+ "reply contains \"result\" table with \"id\", \"name\", \"global_pos\", \"region_pos\", \"region_id\" fields",

+ &LLAgentListener::getNearbyAvatarsList,

+ llsd::map("reply", LLSD()));

+

+ add("getNearbyObjectsList",

+ "Return result set key [\"result\"] for nearby objects in a range of [\"dist\"]\n"

+ "if [\"dist\"] is not specified, 'RenderFarClip' setting is used\n"

+ "reply contains \"result\" table with \"id\", \"global_pos\", \"region_pos\", \"region_id\" fields",

+ &LLAgentListener::getNearbyObjectsList,

+ llsd::map("reply", LLSD()));

+

+ add("getAgentScreenPos",

+ "Return screen position of the [\"avatar_id\"] avatar or own avatar if not specified\n"

+ "reply contains \"x\", \"y\" coordinates and \"onscreen\" flag to indicate if it's actually in within the current window\n"

+ "avatar render position is used as the point",

+ &LLAgentListener::getAgentScreenPos,

+ llsd::map("reply", LLSD()));

+

+void LLAgentListener::getID(LLSD const& event_data)

+{

+ Response response(llsd::map("id", gAgentID), event_data);

+}

+

+struct AvResultSet : public LL::ResultSet

+{

+ AvResultSet() : LL::ResultSet("nearby_avatars") {}

+ std::vector<LLVOAvatar*> mAvatars;

+

+ int getLength() const override { return narrow(mAvatars.size()); }

+ LLSD getSingle(int index) const override

+ {

+ auto av = mAvatars[index];

+ LLAvatarName av_name;

+ LLAvatarNameCache::get(av->getID(), &av_name);

+ LLVector3 region_pos = av->getCharacterPosition();

+ return llsd::map("id", av->getID(),

+ "global_pos", ll_sd_from_vector3d(av->getPosGlobalFromAgent(region_pos)),

+ "region_pos", ll_sd_from_vector3(region_pos),

+ "name", av_name.getUserName(),

+ "region_id", av->getRegion()->getRegionID());

+ }

+};

+

+struct ObjResultSet : public LL::ResultSet

+{

+ ObjResultSet() : LL::ResultSet("nearby_objects") {}

+ std::vector<LLViewerObject*> mObjects;

+

+ int getLength() const override { return narrow(mObjects.size()); }

+ LLSD getSingle(int index) const override

+ {

+ auto obj = mObjects[index];

+ return llsd::map("id", obj->getID(),

+ "global_pos", ll_sd_from_vector3d(obj->getPositionGlobal()),

+ "region_pos", ll_sd_from_vector3(obj->getPositionRegion()),

+ "region_id", obj->getRegion()->getRegionID());

+ }

+};

+

+

+F32 get_search_radius(LLSD const& event_data)

+{

+ static LLCachedControl<F32> render_far_clip(gSavedSettings, "RenderFarClip", 64);

+ F32 dist = render_far_clip;

+ if (event_data.has("dist"))

+ {

+ dist = llclamp((F32)event_data["dist"].asReal(), 1, 512);

+ }

+ return dist * dist;

+}

+

+void LLAgentListener::getNearbyAvatarsList(LLSD const& event_data)

+{

+ Response response(LLSD(), event_data);

+ auto avresult = new AvResultSet;

+

+ F32 radius = get_search_radius(event_data);

+ LLVector3d agent_pos = gAgent.getPositionGlobal();

+ for (LLCharacter* character : LLCharacter::sInstances)

+ {

+ LLVOAvatar* avatar = (LLVOAvatar*)character;

+ if (!avatar->isDead() && !avatar->isControlAvatar() && !avatar->isSelf())

+ {

+ if ((dist_vec_squared(avatar->getPositionGlobal(), agent_pos) <= radius))

+ {

+ avresult->mAvatars.push_back(avatar);

+ }

+ }

+ }

+ response["result"] = avresult->getKeyLength();

+}

+

+void LLAgentListener::getNearbyObjectsList(LLSD const& event_data)

+{

+ Response response(LLSD(), event_data);

+ auto objresult = new ObjResultSet;

+

+ F32 radius = get_search_radius(event_data);

+ S32 num_objects = gObjectList.getNumObjects();

+ LLVector3d agent_pos = gAgent.getPositionGlobal();

+ for (S32 i = 0; i < num_objects; ++i)

+ {

+ LLViewerObject* object = gObjectList.getObject(i);

+ if (object && object->getVolume() && !object->isAttachment())

+ {

+ if ((dist_vec_squared(object->getPositionGlobal(), agent_pos) <= radius))

+ {

+ objresult->mObjects.push_back(object);

+ }

+ }

+ }

+ response["result"] = objresult->getKeyLength();

+}

+

+void LLAgentListener::getAgentScreenPos(LLSD const& event_data)

+{

+ Response response(LLSD(), event_data);

+ LLVector3 render_pos;

+ if (event_data.has("avatar_id") && (event_data["avatar_id"].asUUID() != gAgentID))

+ {

+ LLUUID avatar_id(event_data["avatar_id"]);

+ for (LLCharacter* character : LLCharacter::sInstances)

+ {

+ LLVOAvatar* avatar = (LLVOAvatar*)character;

+ if (!avatar->isDead() && (avatar->getID() == avatar_id))

+ {

+ render_pos = avatar->getRenderPosition();

+ break;

+ }

+ }

+ }

+ else if (gAgentAvatarp.notNull() && gAgentAvatarp->isValid())

+ {

+ render_pos = gAgentAvatarp->getRenderPosition();

+ }

+ LLCoordGL screen_pos;

+ response["onscreen"] = LLViewerCamera::getInstance()->projectPosAgentToScreen(render_pos, screen_pos, false);

+ response["x"] = screen_pos.mX;

+ response["y"] = screen_pos.mY;

+}

+ void getID(LLSD const& event_data);

+ void getNearbyAvatarsList(LLSD const& event_data);

+ void getNearbyObjectsList(LLSD const& event_data);

+ void getAgentScreenPos(LLSD const& event_data);

+

+bool LLAvatarActions::canCall()

+ LLVoiceClient* voice_client = LLVoiceClient::getInstance();

+ return voice_client->voiceEnabled() && voice_client->isVoiceWorking();

+}

+// static

+bool LLAvatarActions::canCallTo(const LLUUID& id)

+ LLVoiceClient* voice_client = LLVoiceClient::getInstance();

+ return voice_client->voiceEnabled() && voice_client->isVoiceWorking() && voice_client->getVoiceEnabled(id);

+ * @return true if voice calls are available

+ static bool canCall();

+ static bool canCallTo(const LLUUID& id);

+#include <cmath>

+ // Disable textures

+ // Disable textures

+ // Disable textures

+ // Disable textures

+ mEnableCallbackRegistrar.add("Avatar.EnableCall", { boost::bind(&LLFloaterBump::canCall, this), cb_info::UNTRUSTED_BLOCK });

+bool LLFloaterBump::canCall()

+{

+ return LLAvatarActions::canCallTo(mItemUUID);

+}

+

+ bool canCall();

+ if (is_single_select)

+ {

+ return LLAvatarActions::canCallTo(single_id);

+ }

+ return is_single_select && LLAvatarActions::canCallTo(single_id);

+ LLCachedControl<bool> show_source_info(gSavedSettings, "LuaDebugShowSource", false);

+ std::string source_info = show_source_info ? data["source_info"].asString() : "";

+ mResultOutput->pasteTextWithLinebreaks(stringize(data["level"].asString(), source_info, data["msg"].asString()), true);

+ std::vector<LLSD> coros = mScriptList->getAllSelectedValues();

+ for (auto coro_name : coros)

+ std::vector<LLSD> prev_selected = mScriptList->getAllSelectedValues();

+ for (auto value : prev_selected)

+ {

+ mScriptList->setSelectedByValue(value, true);

+ }

+ if (!item->getSelected())

+ mScriptList->selectItemAt(x, y, MASK_NONE);

+

+ menu->setItemEnabled(std::string("open_folder"), (mScriptList->getNumSelected() == 1));

+ panel->getChild<LLLineEditor>("estate_id")->setValue((S32)region_info.mEstateID);

+

+ if (region)

+ {

+ panel->getChild<LLLineEditor>("grid_position_x")->setValue((S32)(region->getOriginGlobal()[VX] / 256));

+ panel->getChild<LLLineEditor>("grid_position_y")->setValue((S32)(region->getOriginGlobal()[VY] / 256));

+ }

+ else

+ {

+ panel->getChild<LLLineEditor>("grid_position_x")->setDefaultText();

+ panel->getChild<LLLineEditor>("grid_position_y")->setDefaultText();

+ }

+ getChildView("estate_id")->setEnabled(false);

+ getChildView("grid_position_x")->setEnabled(false);

+ getChildView("grid_position_y")->setEnabled(false);

+ if (hasFocus())

+ {

+ mLocationEditor->setFocus( true);

+ gFocusMgr.triggerFocusFlash();

+ }

+ LLSD metadata,

+ /***

+ * The simulator may have flagged this sender as a bot, if the viewer would like to display

+ * the chat text in a different color or font, the below code is how the viewer can

+ * tell if the sender is a bot.

+ *-----------------------------------------------------

+ bool is_bot = false;

+ if (metadata.has("sender"))

+ { // The server has identified this sender as a bot.

+ is_bot = metadata["sender"]["bot"].asBoolean();

+ }

+ *-----------------------------------------------------

+ */

+

+ std::string notice_name;

+ LLSD notice_args;

+ if (metadata.has("notice"))

+ { // The server has injected a notice into the IM conversation.

+ // These will be things like bot notifications, etc.

+ notice_name = metadata["notice"]["id"].asString();

+ notice_args = metadata["notice"]["data"];

+ }

+

+ // standard message, server may have injected a notice into the conversation.

+

+ std::string real_name;

+

+ if (!notice_name.empty())

+ { // The simulator has injected some sort of notice into the conversation.

+ // findString will only replace the contents of buffer if the notice_id is found.

+ LLTrans::findString(buffer, notice_name, notice_args);

+ real_name = SYSTEM_FROM;

+ }

+

+ gIMMgr->addMessage(session_id,

+ timestamp,

+ LLUUID::null,

+ real_name);

+ LLSD metadata;

+ if (message_data.has("metadata"))

+ {

+ metadata = message_data["metadata"];

+ }

+

+ metadata,

+ LLSD metadata,

+ U32 timestamp, // May be zero

+ LLUUID display_id,

+ std::string_view display_name)

+ std::string message_display_name = (display_name.empty()) ? from : std::string(display_name);

+ if (display_id.isNull() && (display_name.empty()))

+ {

+ display_id = other_participant_id;

+ }

+ if (!skip_message && !gAgent.isDoNotDisturb() && (gSavedSettings.getBOOL("PlaySoundNewConversation")))

+ LLIMModel::instance().addMessage(new_session_id, message_display_name, display_id, msg, true, is_region_msg, timestamp);

+ U32 timestamp = 0,

+ LLUUID display_id = LLUUID::null,

+ std::string_view display_name = "");

+ return llsd::map("id", cat->getUUID(),

+ "name", cat->getName(),

+ return llsd::map("id", item->getUUID(),

+ "name", item->getName(),

+ std::string source_info{ lua_tostring(L, -1) };

+

+ std::ostringstream out;

+ LLEventPumps::instance().obtain("lua output").post(llsd::map("msg", msg, "level", stringize(level, ": "), "source_info", source_info));

+ return source_info + msg;

+ fsyspath absolutePath(mSourceDir / mPathToResolve);

+ [L=L, path=mPathToResolve.string()]()

+ fsyspath absolutePathOpt = (abspath / mPathToResolve);

+ luaL_error(L, "error requiring module '%s'", mPathToResolve.string().data());

+std::atomic<S32> LLMeshRepoThread::sActiveHeaderRequests = 0;

+std::atomic<S32> LLMeshRepoThread::sActiveLODRequests = 0;

+ mThread->mWorkQueue.post([=, this]()

+ static std::atomic<S32> sActiveHeaderRequests;

+ static std::atomic<S32> sActiveLODRequests;

+ F32 physics_explode = (F32)mFMP->childGetValue("physics_explode").asReal();

+ if (physics_explode > 0.f)

+ offset *= physics_explode;

+ if (physics_explode > 0.f)

+ if (pass > 0)

+ {

+ std::size_t size = mVertexBuffer[mPreviewLOD][model].size();

+ for (U32 i = 0; i < size; ++i)

+ mEmojiWidth = (U16)(mIconFont->getWidthF32(LLWString(1, 0x1F431).c_str()) + mPadding * 2);

+ static LLCachedControl<bool> enable_pagination(gSavedSettings, "UseGroupMemberPagination", false);

+ const U32 page_size = enable_pagination() ? 50 : 0;

+ applyListViewFilter(EListViewItemType(LVIT_SHAPE + EListViewItemType(type)));

+ alpha *= llmax(lerp(1.0f, 0.0f, time / mControlFadeTime), 0.0f);

+ return LLAvatarActions::canCallTo(agent_id);

+static const std::string NO_DEVICE("No Device");

+ mLocalizedDeviceNames[NO_DEVICE] = getString("name_no_device");

+ getChildView("wait_text")->setVisible(!is_in_tuning_mode && mUseTuningMode);

+ LLVoiceClient* voice_client = LLVoiceClient::getInstance();

+

+ // grab current volume

+

+ voice_client->tuningSetMicVolume(current_volume);

+ bool device_settings_available = voice_client->deviceSettingsAvailable();

+ bool device_settings_updated = voice_client->deviceSettingsUpdated();

+ if (device_settings_available && !voice_client->getCaptureDevices().empty())

+ mCtrlInputDevices->setEnabled(true);

+ if (device_settings_updated)

+ for (auto& device : voice_client->getCaptureDevices())

+ else

+ {

+ mCtrlInputDevices->setEnabled(false);

+ mCtrlInputDevices->removeall();

+ mCtrlInputDevices->setLabel(getLocalizedDeviceName(NO_DEVICE));

+ }

+ }

+ if (mCtrlOutputDevices)

+ {

+ if (device_settings_available && !voice_client->getRenderDevices().empty())

+ mCtrlOutputDevices->setEnabled(true);

+ if (device_settings_updated)

+ for (auto& device : voice_client->getRenderDevices())

+ else

+ {

+ mCtrlOutputDevices->setEnabled(false);

+ mCtrlOutputDevices->removeall();

+ mCtrlOutputDevices->setLabel(getLocalizedDeviceName(NO_DEVICE));

+ }

+

+ getChild<LLSlider>("mic_volume_slider")->setEnabled(device_settings_available && !voice_client->getCaptureDevices().empty());

+ LLCachedControl<F32> sdr(gSavedSettings, "RenderSunDynamicRange", 1.f);

+ F32 sun_dynamic_range = llmax(sdr(), 0.0001f);

+#include <cmath>

+#include <cmath>

+#include "llrender2dutils.h"

+#include "llshadermgr.h"

+#include "llviewercontrol.h"

+namespace

+{

+#ifdef SHOW_ASSERT

+void check_tex(const LLViewerTexture& tex)

+}

+#else

+#define check_tex(tex)

+#endif

+} // namespace

+

+// static

+bool LLTerrainPaintMap::bakeHeightNoiseIntoPBRPaintMapRGB(const LLViewerRegion& region, LLViewerTexture& tex)

+{

+ check_tex(tex);

+ const S32 max_dim = llmax(tex.getWidth(), tex.getHeight());

+ scratch_target.allocate(max_dim, max_dim, GL_RGB, false, LLTexUnit::eTextureType::TT_TEXTURE,

+ // TODO: Huh... I just realized this view vector is not completely vertical

+ // TODO: Consider using LLGLSLShader::bindTexture

+ // TODO: Try a single big drawRange and see if that still works

+ const bool success = tex.getGLTexture()->setSubImageFromFrameBuffer(0, 0, 0, 0, tex.getWidth(), tex.getHeight());

+

+// *TODO: Decide when to apply the paint queue - ideally once per frame per region

+// Applies paints and then clears the paint queue

+// *NOTE The paint queue is also cleared when setting the paintmap texture

+void LLTerrainPaintMap::applyPaintQueueRGB(LLViewerTexture& tex, LLTerrainPaintQueue& queue)

+{

+ if (queue.empty()) { return; }

+

+ check_tex(tex);

+

+ gGL.getTexUnit(0)->bind(tex.getGLTexture(), false, true);

+

+ // glTexSubImage2D replaces all pixels in the rectangular region. That

+ // makes it unsuitable for alpha.

+ llassert(queue.getComponents() == LLTerrainPaint::RGB);

+ constexpr GLenum pixformat = GL_RGB;

+

+ const std::vector<LLTerrainPaint::ptr_t>& queue_list = queue.get();

+ for (size_t i = 0; i < queue_list.size(); ++i)

+ {

+ // It is currently the responsibility of the paint queue to convert

+ // incoming bits to the right bit depth for the paintmap (this could

+ // change in the future).

+ queue.convertBitDepths(i, 8);

+ const LLTerrainPaint::ptr_t& paint = queue_list[i];

+

+ if (paint->mData.empty()) { continue; }

+ constexpr GLint level = 0;

+ if ((paint->mStartX >= tex.getWidth() - 1) || (paint->mStartY >= tex.getHeight() - 1)) { continue; }

+ constexpr GLint miplevel = 0;

+ const S32 x_offset = paint->mStartX;

+ const S32 y_offset = paint->mStartY;

+ const S32 width = llmin(paint->mWidthX, tex.getWidth() - x_offset);

+ const S32 height = llmin(paint->mWidthY, tex.getHeight() - y_offset);

+ const U8* pixels = paint->mData.data();

+ constexpr GLenum pixtype = GL_UNSIGNED_BYTE;

+ // *TODO: Performance suggestion: Use the sub-image utility function

+ // that LLImageGL::setSubImage uses to split texture updates into

+ // lines, if that's faster.

+ glTexSubImage2D(GL_TEXTURE_2D, miplevel, x_offset, y_offset, width, height, pixformat, pixtype, pixels);

+ stop_glerror();

+ }

+

+ // Generating mipmaps at the end...

+ glGenerateMipmap(GL_TEXTURE_2D);

+ stop_glerror();

+

+ gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);

+

+ queue.clear();

+}

+

+namespace

+{

+

+// A general-purpose vertex buffer of a quad for stamping textures on the z=0

+// plane.

+// *NOTE: Because we know the vertex XY coordinates go from 0 to 1

+// pre-transform, UVs can be calculated from the vertices

+LLVertexBuffer* get_paint_triangle_buffer()

+{

+ static LLPointer<LLVertexBuffer> buf = new LLVertexBuffer(LLVertexBuffer::MAP_VERTEX);

+ static bool initialized = false;

+ if (!initialized)

+ {

+ // Two triangles forming a square from (0,0) to (1,1)

+ buf->allocateBuffer(/*vertices =*/ 4, /*indices =*/ 6);

+ LLStrider<U16> indices;

+ LLStrider<LLVector3> vertices;

+ buf->getVertexStrider(vertices);

+ buf->getIndexStrider(indices);

+ // y

+ // 2....3

+ // ^ . .

+ // | 0....1

+ // |

+ // -------> x

+ //

+ // triangle 1: 0,1,2

+ // triangle 2: 1,3,2

+ (*(vertices++)).set(0.0f, 0.0f, 0.0f);

+ (*(vertices++)).set(1.0f, 0.0f, 0.0f);

+ (*(vertices++)).set(0.0f, 1.0f, 0.0f);

+ (*(vertices++)).set(1.0f, 1.0f, 0.0f);

+ *(indices++) = 0;

+ *(indices++) = 1;

+ *(indices++) = 2;

+ *(indices++) = 1;

+ *(indices++) = 3;

+ *(indices++) = 2;

+ buf->unmapBuffer();

+ }

+ return buf.get();

+}

+

+};

+

+// static

+LLTerrainPaintQueue LLTerrainPaintMap::convertPaintQueueRGBAToRGB(LLViewerTexture& tex, LLTerrainPaintQueue& queue_in)

+{

+ check_tex(tex);

+ llassert(queue_in.getComponents() == LLTerrainPaint::RGBA);

+

+ // TODO: Avoid allocating a scratch render buffer and use mAuxillaryRT instead

+ // TODO: even if it means performing extra render operations to apply the paints, in rare cases where the paints can't all fit within an area that can be represented by the buffer

+ LLRenderTarget scratch_target;

+ const S32 max_dim = llmax(tex.getWidth(), tex.getHeight());

+ scratch_target.allocate(max_dim, max_dim, GL_RGB, false, LLTexUnit::eTextureType::TT_TEXTURE,

+ LLTexUnit::eTextureMipGeneration::TMG_NONE);

+ if (!scratch_target.isComplete())

+ {

+ llassert(false);

+ LL_WARNS() << "Failed to allocate render target" << LL_ENDL;

+ return false;

+ }

+ gGL.getTexUnit(0)->disable();

+ stop_glerror();

+

+ scratch_target.bindTarget();

+ glClearColor(0, 0, 0, 0);

+ scratch_target.clear();

+ const F32 target_half_width = (F32)scratch_target.getWidth() / 2.0f;

+ const F32 target_half_height = (F32)scratch_target.getHeight() / 2.0f;

+

+ LLVertexBuffer* buf = get_paint_triangle_buffer();

+

+ // Update projection matrix and viewport

+ // *NOTE: gl_state_for_2d also sets the modelview matrix. This will be overridden later.

+ {

+ stop_glerror();

+ gGL.matrixMode(LLRender::MM_PROJECTION);

+ gGL.pushMatrix();

+ gGL.loadIdentity();

+ gGL.ortho(-target_half_width, target_half_width, -target_half_height, target_half_height, 0.25f, 1.0f);

+ stop_glerror();

+ const LLRect texture_rect(0, scratch_target.getHeight(), scratch_target.getWidth(), 0);

+ glViewport(texture_rect.mLeft, texture_rect.mBottom, texture_rect.getWidth(), texture_rect.getHeight());

+ }

+

+ // View matrix

+ // Coordinates should be in pixels. 1.0f = 1 pixel on the framebuffer.

+ // Camera is centered in the middle of the framebuffer.

+ glm::mat4 view(glm::make_mat4((GLfloat*) OGL_TO_CFR_ROTATION));

+ {

+ LLViewerCamera camera;

+ const LLVector3 camera_origin(target_half_width, target_half_height, 0.5f);

+ const LLVector3 camera_look_down(target_half_width, target_half_height, 0.0f);

+ camera.lookAt(camera_origin, camera_look_down, LLVector3::y_axis);

+ camera.setAspect(F32(scratch_target.getHeight()) / F32(scratch_target.getWidth()));

+ GLfloat ogl_matrix[16];

+ camera.getOpenGLTransform(ogl_matrix);

+ view *= glm::make_mat4(ogl_matrix);

+ }

+

+ LLGLDisable stencil(GL_STENCIL_TEST);

+ LLGLDisable scissor(GL_SCISSOR_TEST);

+ LLGLEnable cull_face(GL_CULL_FACE);

+ LLGLDepthTest depth_test(GL_FALSE, GL_FALSE, GL_ALWAYS);

+ LLGLEnable blend(GL_BLEND);

+ gGL.setSceneBlendType(LLRender::BT_ALPHA);

+

+ LLGLSLShader& shader = gTerrainStampProgram;

+ shader.bind();

+

+ // First, apply the paint map as the background

+ {

+ glm::mat4 model;

+ {

+ model = glm::scale(model, glm::vec3((F32)tex.getWidth(), (F32)tex.getHeight(), 1.0f));

+ model = glm::translate(model, glm::vec3(0.0f, 0.0f, 0.0f));

+ }

+ glm::mat4 modelview = view * model;

+ gGL.matrixMode(LLRender::MM_MODELVIEW);

+ gGL.loadMatrix(glm::value_ptr(modelview));

+

+ shader.bindTexture(LLShaderMgr::DIFFUSE_MAP, &tex);

+ // We care about the whole paintmap, which is already a power of two.

+ // Hence, TERRAIN_STAMP_SCALE = (1.0,1.0)

+ shader.uniform2f(LLShaderMgr::TERRAIN_STAMP_SCALE, 1.0f, 1.0f);

+ buf->setBuffer();

+ buf->draw(LLRender::TRIANGLES, buf->getIndicesSize(), 0);

+ }

+

+ LLTerrainPaintQueue queue_out(LLTerrainPaint::RGB);

+

+ // Incrementally apply each RGBA paint to the render target, then extract

+ // the result back into memory as an RGB paint.

+ // Put each result in queue_out.

+ const std::vector<LLTerrainPaint::ptr_t>& queue_in_list = queue_in.get();

+ for (size_t i = 0; i < queue_in_list.size(); ++i)

+ {

+ // It is currently the responsibility of the paint queue to convert

+ // incoming bits to the right bit depth for paint operations (this

+ // could change in the future).

+ queue_in.convertBitDepths(i, 8);

+ const LLTerrainPaint::ptr_t& paint_in = queue_in_list[i];

+

+ // Modelview matrix for the current paint

+ // View matrix is already computed. Just need the model matrix.

+ // Orthographic projection matrix is already updated

+ glm::mat4 model;

+ {

+ model = glm::scale(model, glm::vec3(paint_in->mWidthX, paint_in->mWidthY, 1.0f));

+ model = glm::translate(model, glm::vec3(paint_in->mStartX, paint_in->mStartY, 0.0f));

+ }

+ glm::mat4 modelview = view * model;

+ gGL.matrixMode(LLRender::MM_MODELVIEW);

+ gGL.loadMatrix(glm::value_ptr(modelview));

+

+ // Generate temporary stamp texture from paint contents.

+ // Our stamp image needs to be a power of two.

+ // Because the paint data may not cover a whole power-of-two region,

+ // allocate a bigger 2x2 image if needed, but set the image data later

+ // for a subset of the image.

+ // Pixel data outside this subset is left undefined. We will use

+ // TERRAIN_STAMP_SCALE in the stamp shader to define the subset of the

+ // image we care about.

+ const U32 width_rounded = 1 << U32(ceil(log2(F32(paint_in->mWidthX))));

+ const U32 height_rounded = 1 << U32(ceil(log2(F32(paint_in->mWidthY))));

+ LLPointer<LLImageGL> stamp_image;

+ {

+ // Create image object (dimensions not yet initialized in GL)

+ U32 stamp_tex_name;

+ LLImageGL::generateTextures(1, &stamp_tex_name);

+ const U32 components = paint_in->mComponents;

+ constexpr LLGLenum target = GL_TEXTURE_2D;

+ const LLGLenum internal_format = paint_in->mComponents == 4 ? GL_RGBA8 : GL_RGB8;

+ const LLGLenum format = paint_in->mComponents == 4 ? GL_RGBA : GL_RGB;

+ constexpr LLGLenum type = GL_UNSIGNED_BYTE;

+ stamp_image = new LLImageGL(stamp_tex_name, components, target, internal_format, format, type, LLTexUnit::TAM_WRAP);

+ // Nearest-neighbor filtering to reduce surprises

+ stamp_image->setFilteringOption(LLTexUnit::TFO_POINT);

+

+ // Initialize the image dimensions in GL

+ constexpr U8* undefined_data_for_now = nullptr;

+ gGL.getTexUnit(0)->bind(stamp_image, false, true);

+ glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width_rounded, height_rounded, 0, format, type, undefined_data_for_now);

+ gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);

+ stamp_image->setSize(width_rounded, height_rounded, components);

+ stamp_image->setDiscardLevel(0);

+

+ // Manually set a subset of the image in GL

+ const U8* data = paint_in->mData.data();

+ const S32 data_width = paint_in->mWidthX;

+ const S32 data_height = paint_in->mWidthY;

+ constexpr S32 origin = 0;

+ // width = data_width; height = data_height. i.e.: Copy the full

+ // contents of data into the image.

+ stamp_image->setSubImage(data, data_width, data_height, origin, origin, /*width=*/data_width, /*height=*/data_height);

+ }

+

+ // Apply ("stamp") the paint to the render target

+ {

+ shader.bindTextureImageGL(LLShaderMgr::DIFFUSE_MAP, stamp_image);

+ const F32 width_fraction = F32(paint_in->mWidthX) / F32(width_rounded);

+ const F32 height_fraction = F32(paint_in->mWidthY) / F32(height_rounded);

+ shader.uniform2f(LLShaderMgr::TERRAIN_STAMP_SCALE, width_fraction, height_fraction);

+ buf->setBuffer();

+ buf->draw(LLRender::TRIANGLES, buf->getIndicesSize(), 0);

+ }

+

+ // Extract the result back into memory as an RGB paint

+ LLTerrainPaint::ptr_t paint_out = std::make_shared<LLTerrainPaint>();

+ {

+ paint_out->mStartX = paint_in->mStartX;

+ paint_out->mStartY = paint_in->mStartY;

+ paint_out->mWidthX = paint_in->mWidthX;

+ paint_out->mWidthY = paint_in->mWidthY;

+ paint_out->mBitDepth = 8; // Will be reduced to TerrainPaintBitDepth bits later

+ paint_out->mComponents = LLTerrainPaint::RGB;

+#ifdef SHOW_ASSERT

+ paint_out->assert_confined_to(tex);

+#endif

+ paint_out->confine_to(tex);

+ paint_out->mData.resize(paint_out->mComponents * paint_out->mWidthX * paint_out->mWidthY);

+ constexpr GLint miplevel = 0;

+ const S32 x_offset = paint_out->mStartX;

+ const S32 y_offset = paint_out->mStartY;

+ const S32 width = paint_out->mWidthX;

+ const S32 height = paint_out->mWidthY;

+ constexpr GLenum pixformat = GL_RGB;

+ constexpr GLenum pixtype = GL_UNSIGNED_BYTE;

+ llassert(paint_out->mData.size() <= std::numeric_limits<GLsizei>::max());

+ const GLsizei buf_size = (GLsizei)paint_out->mData.size();

+ U8* pixels = paint_out->mData.data();

+ glReadPixels(x_offset, y_offset, width, height, pixformat, pixtype, pixels);

+ }

+

+ // Enqueue the result to the new paint queue, with bit depths per color

+ // channel reduced from 8 to 5, and reduced from RGBA (paintmap

+ // sub-rectangle update with alpha mask) to RGB (paintmap sub-rectangle

+ // update without alpha mask). This format is suitable for sending

+ // over the network.

+ // *TODO: At some point, queue_out will pass through a network

+ // round-trip which will reduce the bit depth, making the

+ // pre-conversion step not necessary.

+ queue_out.enqueue(paint_out);

+ LLCachedControl<U32> bit_depth(gSavedSettings, "TerrainPaintBitDepth");

+ queue_out.convertBitDepths(queue_out.size()-1, bit_depth);

+ }

+

+ queue_in.clear();

+

+ scratch_target.flush();

+

+ LLGLSLShader::unbind();

+

+ gGL.matrixMode(LLRender::MM_PROJECTION);

+ gGL.popMatrix();

+

+ return queue_out;

+}

+

+// static

+LLTerrainPaintQueue LLTerrainPaintMap::convertBrushQueueToPaintRGB(const LLViewerRegion& region, LLViewerTexture& tex, LLTerrainBrushQueue& queue_in)

+{

+ check_tex(tex);

+

+ // TODO: Avoid allocating a scratch render buffer and use mAuxillaryRT instead

+ // TODO: even if it means performing extra render operations to apply the brushes, in rare cases where the paints can't all fit within an area that can be represented by the buffer

+ LLRenderTarget scratch_target;

+ const S32 max_dim = llmax(tex.getWidth(), tex.getHeight());

+ scratch_target.allocate(max_dim, max_dim, GL_RGB, false, LLTexUnit::eTextureType::TT_TEXTURE,

+ LLTexUnit::eTextureMipGeneration::TMG_NONE);

+ if (!scratch_target.isComplete())

+ {

+ llassert(false);

+ LL_WARNS() << "Failed to allocate render target" << LL_ENDL;

+ return false;

+ }

+ gGL.getTexUnit(0)->disable();

+ stop_glerror();

+

+ scratch_target.bindTarget();

+ glClearColor(0, 0, 0, 0);

+ scratch_target.clear();

+ const F32 target_half_width = (F32)scratch_target.getWidth() / 2.0f;

+ const F32 target_half_height = (F32)scratch_target.getHeight() / 2.0f;

+

+ LLVertexBuffer* buf = get_paint_triangle_buffer();

+

+ // Update projection matrix and viewport

+ // *NOTE: gl_state_for_2d also sets the modelview matrix. This will be overridden later.

+ {

+ stop_glerror();

+ gGL.matrixMode(LLRender::MM_PROJECTION);

+ gGL.pushMatrix();

+ gGL.loadIdentity();

+ gGL.ortho(-target_half_width, target_half_width, -target_half_height, target_half_height, 0.25f, 1.0f);

+ stop_glerror();

+ const LLRect texture_rect(0, scratch_target.getHeight(), scratch_target.getWidth(), 0);

+ glViewport(texture_rect.mLeft, texture_rect.mBottom, texture_rect.getWidth(), texture_rect.getHeight());

+ }

+

+ // View matrix

+ // Coordinates should be in pixels. 1.0f = 1 pixel on the framebuffer.

+ // Camera is centered in the middle of the framebuffer.

+ glm::mat4 view(glm::make_mat4((GLfloat*)OGL_TO_CFR_ROTATION));

+ {

+ LLViewerCamera camera;

+ const LLVector3 camera_origin(target_half_width, target_half_height, 0.5f);

+ const LLVector3 camera_look_down(target_half_width, target_half_height, 0.0f);

+ camera.lookAt(camera_origin, camera_look_down, LLVector3::y_axis);

+ camera.setAspect(F32(scratch_target.getHeight()) / F32(scratch_target.getWidth()));

+ GLfloat ogl_matrix[16];

+ camera.getOpenGLTransform(ogl_matrix);

+ view *= glm::make_mat4(ogl_matrix);

+ }

+

+ LLGLDisable stencil(GL_STENCIL_TEST);

+ LLGLDisable scissor(GL_SCISSOR_TEST);

+ LLGLEnable cull_face(GL_CULL_FACE);

+ LLGLDepthTest depth_test(GL_FALSE, GL_FALSE, GL_ALWAYS);

+ LLGLEnable blend(GL_BLEND);

+ gGL.setSceneBlendType(LLRender::BT_ALPHA);

+

+ LLGLSLShader& shader = gTerrainStampProgram;

+ shader.bind();

+

+ // First, apply the paint map as the background

+ {

+ glm::mat4 model;

+ {

+ model = glm::scale(model, glm::vec3((F32)tex.getWidth(), (F32)tex.getHeight(), 1.0f));

+ model = glm::translate(model, glm::vec3(0.0f, 0.0f, 0.0f));

+ }

+ glm::mat4 modelview = view * model;

+ gGL.matrixMode(LLRender::MM_MODELVIEW);

+ gGL.loadMatrix(glm::value_ptr(modelview));

+

+ shader.bindTexture(LLShaderMgr::DIFFUSE_MAP, &tex);

+ // We care about the whole paintmap, which is already a power of two.

+ // Hence, TERRAIN_STAMP_SCALE = (1.0,1.0)

+ shader.uniform2f(LLShaderMgr::TERRAIN_STAMP_SCALE, 1.0f, 1.0f);

+ buf->setBuffer();

+ buf->draw(LLRender::TRIANGLES, buf->getIndicesSize(), 0);

+ }

+

+ LLTerrainPaintQueue queue_out(LLTerrainPaint::RGB);

+

+ // Incrementally apply each brush stroke to the render target, then extract

+ // the result back into memory as an RGB paint.

+ // Put each result in queue_out.

+ const std::vector<LLTerrainBrush::ptr_t>& brush_list = queue_in.get();

+ for (size_t i = 0; i < brush_list.size(); ++i)

+ {

+ const LLTerrainBrush::ptr_t& brush_in = brush_list[i];

+

+ // Modelview matrix for the current brush

+ // View matrix is already computed. Just need the model matrix.

+ // Orthographic projection matrix is already updated

+ // *NOTE: Brush path information is in region space. It will need to be

+ // converted to paintmap pixel space before it makes sense.

+ F32 brush_width_x;

+ F32 brush_width_y;

+ F32 brush_start_x;

+ F32 brush_start_y;

+ {

+ F32 min_x = brush_in->mPath[0].mV[VX];

+ F32 max_x = min_x;

+ F32 min_y = brush_in->mPath[0].mV[VY];

+ F32 max_y = min_y;

+ for (size_t i = 1; i < brush_in->mPath.size(); ++i)

+ {

+ const F32 x = brush_in->mPath[i].mV[VX];

+ const F32 y = brush_in->mPath[i].mV[VY];

+ min_x = llmin(min_x, x);

+ max_x = llmax(max_x, x);

+ min_y = llmin(min_y, y);

+ max_y = llmax(max_y, y);

+ }

+ brush_width_x = brush_in->mBrushSize + (max_x - min_x);

+ brush_width_y = brush_in->mBrushSize + (max_y - min_y);

+ brush_start_x = min_x - (brush_in->mBrushSize / 2.0f);

+ brush_start_y = min_y - (brush_in->mBrushSize / 2.0f);

+ // Convert brush path information to paintmap pixel space from region

+ // space.

+ brush_width_x *= tex.getWidth() / region.getWidth();

+ brush_width_y *= tex.getHeight() / region.getWidth();

+ brush_start_x *= tex.getWidth() / region.getWidth();

+ brush_start_y *= tex.getHeight() / region.getWidth();

+ }

+ glm::mat4 model;

+ {

+ model = glm::scale(model, glm::vec3(brush_width_x, brush_width_y, 1.0f));

+ model = glm::translate(model, glm::vec3(brush_start_x, brush_start_y, 0.0f));

+ }

+ glm::mat4 modelview = view * model;

+ gGL.matrixMode(LLRender::MM_MODELVIEW);

+ gGL.loadMatrix(glm::value_ptr(modelview));

+

+ // Apply the "brush" to the render target

+ {

+ // TODO: Use different shader for this - currently this is using the stamp shader. The white image is just a placeholder for now

+ shader.bindTexture(LLShaderMgr::DIFFUSE_MAP, LLViewerFetchedTexture::sWhiteImagep);

+ shader.uniform2f(LLShaderMgr::TERRAIN_STAMP_SCALE, 1.0f, 1.0f);

+ buf->setBuffer();

+ buf->draw(LLRender::TRIANGLES, buf->getIndicesSize(), 0);

+ }

+

+ // Extract the result back into memory as an RGB paint

+ LLTerrainPaint::ptr_t paint_out = std::make_shared<LLTerrainPaint>();

+ {

+ paint_out->mStartX = U16(floor(brush_start_x));

+ paint_out->mStartY = U16(floor(brush_start_y));

+ const F32 dX = brush_start_x - F32(paint_out->mStartX);

+ const F32 dY = brush_start_y - F32(paint_out->mStartY);

+ paint_out->mWidthX = U16(ceil(brush_width_x + dX));

+ paint_out->mWidthY = U16(ceil(brush_width_y + dY));

+ paint_out->mBitDepth = 8; // Will be reduced to TerrainPaintBitDepth bits later

+ paint_out->mComponents = LLTerrainPaint::RGB;

+ // The brush strokes are expected to sometimes partially venture

+ // outside of the paintmap bounds.

+ paint_out->confine_to(tex);

+ paint_out->mData.resize(paint_out->mComponents * paint_out->mWidthX * paint_out->mWidthY);

+ constexpr GLint miplevel = 0;

+ const S32 x_offset = paint_out->mStartX;

+ const S32 y_offset = paint_out->mStartY;

+ const S32 width = paint_out->mWidthX;

+ const S32 height = paint_out->mWidthY;

+ constexpr GLenum pixformat = GL_RGB;

+ constexpr GLenum pixtype = GL_UNSIGNED_BYTE;

+ llassert(paint_out->mData.size() <= std::numeric_limits<GLsizei>::max());

+ const GLsizei buf_size = (GLsizei)paint_out->mData.size();

+ U8* pixels = paint_out->mData.data();

+ glReadPixels(x_offset, y_offset, width, height, pixformat, pixtype, pixels);

+ }

+

+ // Enqueue the result to the new paint queue, with bit depths per color

+ // channel reduced from 8 to 5, and reduced from RGBA (paintmap

+ // sub-rectangle update with alpha mask) to RGB (paintmap sub-rectangle

+ // update without alpha mask). This format is suitable for sending

+ // over the network.

+ // *TODO: At some point, queue_out will pass through a network

+ // round-trip which will reduce the bit depth, making the

+ // pre-conversion step not necessary.

+ queue_out.enqueue(paint_out);

+ LLCachedControl<U32> bit_depth(gSavedSettings, "TerrainPaintBitDepth");

+ queue_out.convertBitDepths(queue_out.size()-1, bit_depth);

+ }

+

+ queue_in.clear();

+

+ scratch_target.flush();

+

+ LLGLSLShader::unbind();

+

+ gGL.matrixMode(LLRender::MM_PROJECTION);

+ gGL.popMatrix();

+

+ return queue_out;

+}

+

+template<typename T>

+LLTerrainQueue<T>::LLTerrainQueue(LLTerrainQueue<T>& other)

+{

+ *this = other;

+}

+

+template<typename T>

+LLTerrainQueue<T>& LLTerrainQueue<T>::operator=(LLTerrainQueue<T>& other)

+{

+ mList = other.mList;

+ return *this;

+}

+

+template<typename T>

+bool LLTerrainQueue<T>::enqueue(std::shared_ptr<T>& t, bool dry_run)

+{

+ if (!dry_run) { mList.push_back(t); }

+ return true;

+}

+

+template<typename T>

+bool LLTerrainQueue<T>::enqueue(std::vector<std::shared_ptr<T>>& list)

+{

+ constexpr bool dry_run = true;

+ for (auto& t : list)

+ {

+ if (!enqueue(t, dry_run)) { return false; }

+ }

+ for (auto& t : list)

+ {

+ enqueue(t);

+ }

+ return true;

+}

+

+template<typename T>

+size_t LLTerrainQueue<T>::size() const

+{

+ return mList.size();

+}

+

+template<typename T>

+bool LLTerrainQueue<T>::empty() const

+{

+ return mList.empty();

+}

+

+template<typename T>

+void LLTerrainQueue<T>::clear()

+{

+ mList.clear();

+}

+

+void LLTerrainPaint::assert_confined_to(const LLTexture& tex) const

+{

+ llassert(mStartX >= 0 && mStartX < tex.getWidth());

+ llassert(mStartY >= 0 && mStartY < tex.getHeight());

+ llassert(mWidthX <= tex.getWidth() - mStartX);

+ llassert(mWidthY <= tex.getHeight() - mStartY);

+}

+

+void LLTerrainPaint::confine_to(const LLTexture& tex)

+{

+ mStartX = llmax(mStartX, 0);

+ mStartY = llmax(mStartY, 0);

+ mWidthX = llmin(mWidthX, tex.getWidth() - mStartX);

+ mWidthY = llmin(mWidthY, tex.getHeight() - mStartY);

+ assert_confined_to(tex);

+}

+

+LLTerrainPaintQueue::LLTerrainPaintQueue(U8 components)

+: mComponents(components)

+{

+ llassert(mComponents == LLTerrainPaint::RGB || mComponents == LLTerrainPaint::RGBA);

+}

+

+LLTerrainPaintQueue::LLTerrainPaintQueue(LLTerrainPaintQueue& other)

+: LLTerrainQueue<LLTerrainPaint>(other)

+, mComponents(other.mComponents)

+{

+ llassert(mComponents == LLTerrainPaint::RGB || mComponents == LLTerrainPaint::RGBA);

+}

+

+LLTerrainPaintQueue& LLTerrainPaintQueue::operator=(LLTerrainPaintQueue& other)

+{

+ LLTerrainQueue<LLTerrainPaint>::operator=(other);

+ mComponents = other.mComponents;

+ return *this;

+}

+

+bool LLTerrainPaintQueue::enqueue(LLTerrainPaint::ptr_t& paint, bool dry_run)

+{

+ llassert(paint);

+ if (!paint) { return false; }

+

+ // The paint struct should be pre-validated before this code is reached.

+ llassert(!paint->mData.empty());

+ // The internal paint map image is currently 8 bits, so that's the maximum

+ // allowed bit depth.

+ llassert(paint->mBitDepth > 0 && paint->mBitDepth <= 8);

+ llassert(paint->mData.size() == (mComponents * paint->mWidthX * paint->mWidthY));

+ llassert(paint->mWidthX > 0);

+ llassert(paint->mWidthY > 0);

+#ifdef SHOW_ASSERT

+ static LLCachedControl<U32> max_texture_width(gSavedSettings, "RenderMaxTextureResolution", 2048);

+#endif

+ llassert(paint->mWidthX <= max_texture_width);

+ llassert(paint->mWidthY <= max_texture_width);

+ llassert(paint->mStartX < max_texture_width);

+ llassert(paint->mStartY < max_texture_width);

+

+ return LLTerrainQueue<LLTerrainPaint>::enqueue(paint, dry_run);

+}

+

+bool LLTerrainPaintQueue::enqueue(LLTerrainPaintQueue& queue)

+{

+ return LLTerrainQueue<LLTerrainPaint>::enqueue(queue.mList);

+}

+

+void LLTerrainPaintQueue::convertBitDepths(size_t index, U8 target_bit_depth)

+{

+ llassert(target_bit_depth > 0 && target_bit_depth <= 8);

+ llassert(index < mList.size());

+

+ LLTerrainPaint::ptr_t& paint = mList[index];

+ if (paint->mBitDepth == target_bit_depth) { return; }

+

+ const F32 old_bit_max = F32((1 << paint->mBitDepth) - 1);

+ const F32 new_bit_max = F32((1 << target_bit_depth) - 1);

+ const F32 bit_conversion_factor = new_bit_max / old_bit_max;

+

+ for (U8& color : paint->mData)

+ {

+ color = (U8)llround(F32(color) * bit_conversion_factor);

+ }

+

+ paint->mBitDepth = target_bit_depth;

+}

+

+LLTerrainBrushQueue::LLTerrainBrushQueue()

+: LLTerrainQueue<LLTerrainBrush>()

+{

+}

+

+LLTerrainBrushQueue::LLTerrainBrushQueue(LLTerrainBrushQueue& other)

+: LLTerrainQueue<LLTerrainBrush>(other)

+{

+}

+

+LLTerrainBrushQueue& LLTerrainBrushQueue::operator=(LLTerrainBrushQueue& other)

+{

+ LLTerrainQueue<LLTerrainBrush>::operator=(other);

+ return *this;

+}

+

+bool LLTerrainBrushQueue::enqueue(LLTerrainBrush::ptr_t& brush, bool dry_run)

+{

+ llassert(brush->mBrushSize > 0);

+ llassert(!brush->mPath.empty());

+ llassert(brush->mPathOffset < brush->mPath.size());

+ llassert(brush->mPathOffset < 2); // Harmless, but doesn't do anything useful, so might be a sign of implementation error

+ return LLTerrainQueue<LLTerrainBrush>::enqueue(brush, dry_run);

+}

+

+bool LLTerrainBrushQueue::enqueue(LLTerrainBrushQueue& queue)

+{

+ return LLTerrainQueue<LLTerrainBrush>::enqueue(queue.mList);

+}

+

+template class LLTerrainQueue<LLTerrainPaint>;

+template class LLTerrainQueue<LLTerrainBrush>;

+#include <memory>

+#include <vector>

+

+#include "stdtypes.h"

+#include "v2math.h"

+

+class LLTexture;

+class LLTerrainPaintQueue;

+class LLTerrainBrushQueue;

+// TODO: Terrain painting across regions. Assuming painting is confined to one

+// region for now.

+

+ // This operation clears the queue

+ // TODO: Decide if clearing the queue is needed - seems inconsistent

+ static void applyPaintQueueRGB(LLViewerTexture& tex, LLTerrainPaintQueue& queue);

+

+ static LLTerrainPaintQueue convertPaintQueueRGBAToRGB(LLViewerTexture& tex, LLTerrainPaintQueue& queue_in);

+ // TODO: Implement (it's similar to convertPaintQueueRGBAToRGB but different shader + need to calculate the dimensions + need a different vertex buffer for each brush stroke)

+ static LLTerrainPaintQueue convertBrushQueueToPaintRGB(const LLViewerRegion& region, LLViewerTexture& tex, LLTerrainBrushQueue& queue_in);

+};

+

+template<typename T>

+class LLTerrainQueue

+{

+public:

+ LLTerrainQueue() = default;

+ LLTerrainQueue(LLTerrainQueue<T>& other);

+ LLTerrainQueue& operator=(LLTerrainQueue<T>& other);

+

+ bool enqueue(std::shared_ptr<T>& t, bool dry_run = false);

+ size_t size() const;

+ bool empty() const;

+ void clear();

+

+ const std::vector<std::shared_ptr<T>>& get() const { return mList; }

+

+protected:

+ bool enqueue(std::vector<std::shared_ptr<T>>& list);

+

+ std::vector<std::shared_ptr<T>> mList;

+};

+

+// Enqueued paint operations, in texture coordinates.

+// mData is always RGB or RGBA (determined by mComponents), with each U8

+// storing one color with a max value of (1 >> mBitDepth) - 1

+struct LLTerrainPaint

+{

+ using ptr_t = std::shared_ptr<LLTerrainPaint>;

+

+ U16 mStartX;

+ U16 mStartY;

+ U16 mWidthX;

+ U16 mWidthY;

+ U8 mBitDepth;

+ U8 mComponents;

+ static constexpr U8 RGB = 3;

+ static constexpr U8 RGBA = 4;

+ std::vector<U8> mData;

+

+ // Asserts that this paint's start/width fit within the bounds of the

+ // provided texture dimensions.

+ void assert_confined_to(const LLTexture& tex) const;

+ // Confines this paint's start/width so it fits within the bounds of the

+ // provided texture dimensions.

+ // Does not allocate mData.

+ void confine_to(const LLTexture& tex);

+};

+

+class LLTerrainPaintQueue : public LLTerrainQueue<LLTerrainPaint>

+{

+public:

+ LLTerrainPaintQueue() = delete;

+ // components determines what type of LLTerrainPaint is allowed. Must be 3 (RGB) or 4 (RGBA)

+ LLTerrainPaintQueue(U8 components);

+ LLTerrainPaintQueue(LLTerrainPaintQueue& other);

+ LLTerrainPaintQueue& operator=(LLTerrainPaintQueue& other);

+

+ bool enqueue(LLTerrainPaint::ptr_t& paint, bool dry_run = false);

+ bool enqueue(LLTerrainPaintQueue& queue);

+

+ U8 getComponents() const { return mComponents; }

+ // Convert mBitDepth for the LLTerrainPaint in the queue at index

+ // If mBitDepth is already equal to target_bit_depth, no conversion takes

+ // place.

+ // It is currently the responsibility of the paint queue to convert

+ // incoming bits to the right bit depth for the paintmap (this could

+ // change in the future).

+ void convertBitDepths(size_t index, U8 target_bit_depth);

+

+private:

+ U8 mComponents;

+};

+

+struct LLTerrainBrush

+{

+ using ptr_t = std::shared_ptr<LLTerrainBrush>;

+

+ // Width of the brush in region space. The brush is a square texture with

+ // alpha.

+ F32 mBrushSize;

+ // Brush path points in region space, excluding the vertical axis, which

+ // does not contribute to the paint map.

+ std::vector<LLVector2> mPath;

+ // Offset of the brush path to actually start drawing at. An offset of 0

+ // indicates that a brush stroke has just started (i.e. the user just

+ // pressed down the mouse button). An offset greater than 0 indicates the

+ // continuation of a brush stroke. Skipped entries in mPath are not drawn

+ // directly, but are used for stroke orientation and path interpolation.

+ // TODO: For the initial implementation, mPathOffset will be 0 and mPath

+ // will be of length of at most 1, leading to discontinuous paint paths.

+ // Then, mPathOffset may be 1 or 0, 1 indicating the continuation of a

+ // stroke with linear interpolation. It is unlikely that we will implement

+ // anything more sophisticated than that for now.

+ U8 mPathOffset;

+ // Indicates if this is the end of the brush stroke. Can occur if the mouse

+ // button is lifted, or if the mouse temporarily stops while held down.

+ bool mPathEnd;

+};

+

+class LLTerrainBrushQueue : public LLTerrainQueue<LLTerrainBrush>

+{

+public:

+ LLTerrainBrushQueue();

+ LLTerrainBrushQueue(LLTerrainBrushQueue& other);

+ LLTerrainBrushQueue& operator=(LLTerrainBrushQueue& other);

+

+ bool enqueue(LLTerrainBrush::ptr_t& brush, bool dry_run = false);

+ bool enqueue(LLTerrainBrushQueue& queue);

+ if (!mFetcher->mTextureCache || mFetcher->mTextureCache->readComplete(mCacheReadHandle, true))

+ if (!mFetcher->mTextureCache || mFetcher->mTextureCache->writeComplete(mCacheWriteHandle))

+ mRequestQueue.tryPost([=, this]()

+ static std::atomic<bool> reporting_started(false);

+ static std::atomic<S32> report_sequence(0);

+ if (tokens.size() >= 3) // Require at least [1] and [2]

+ setting_setup_signal_listener(gSavedSettings, "LocalTerrainPaintEnabled", handleSetShaderChanged);

+#include "llviewerstats.h"

+

+ // supplement with stats packet

+ stats.emplace("stats", LlsdToJson(capture_viewer_stats(true)));

+ [=, this]() // work done on update worker thread

+ [=, this]() // callback to main thread

+#include "llterrainpaintmap.h"

+ // This calls gLocalTerrainMaterials.setPaintType

+ // It also ensures the terrain bake shader is compiled (handleSetShaderChanged), so call this first

+ // *TODO: Fix compile errors in shader so it can be used for all platforms. Then we can unhide the shader from behind this setting and remove the hook to handleSetShaderChanged. This advanced setting is intended to be used as a local setting for testing terrain, not a feature flag, but it is currently used like a feature flag as a temporary hack.

+ // *TODO: Ideally we would call setPaintType *after* the paint map is well-defined. The terrain draw pool should be able to handle an undefined paint map in the meantime.

+ gSavedSettings.setBOOL("LocalTerrainPaintEnabled", true);

+

+ // TODO: Could probably get away with not using image raw here, now that we aren't writing bits via the CPU (see load_exr for example)

+class LLAdvancedTerrainEditLocalPaintMap : public view_listener_t

+{

+ bool handleEvent(const LLSD& userdata)

+ {

+ LLViewerTexture* tex = gLocalTerrainMaterials.getPaintMap();

+ if (!tex)

+ {

+ LL_WARNS() << "No local paint map available to edit" << LL_ENDL;

+ return false;

+ }

+

+ LLTerrainBrushQueue& brush_queue = gLocalTerrainMaterials.getBrushQueue();

+ LLTerrainPaintQueue& paint_request_queue = gLocalTerrainMaterials.getPaintRequestQueue();

+

+ const LLViewerRegion* region = gAgent.getRegion();

+ if (!region)

+ {

+ LL_WARNS() << "No current region for calculating paint operations" << LL_ENDL;

+ return false;

+ }

+ // TODO: Create the brush

+ // Just a dab for now

+ LLTerrainBrush::ptr_t brush = std::make_shared<LLTerrainBrush>();

+ brush->mBrushSize = 16.0f;

+ brush->mPath.emplace_back(17.0f, 17.0f);

+ brush->mPathOffset = 0;

+ brush->mPathEnd = true;

+ brush_queue.enqueue(brush);

+ LLTerrainPaintQueue brush_as_paint_queue = LLTerrainPaintMap::convertBrushQueueToPaintRGB(*region, *tex, brush_queue);

+ //paint_send_queue.enqueue(brush_as_paint_queue); // TODO: What was this line for? (it might also be a leftover line from an unfinished edit)

+

+ // TODO: Keep this around for later testing (i.e. when reducing framebuffer size and the offsets that requires)

+#if 0

+ // Enqueue a paint

+ // Modifies a subsection of the region paintmap with the material in

+ // the last slot.

+ // It is currently the responsibility of the paint queue to convert

+ // incoming bits to the right bit depth for the paintmap (this could

+ // change in the future).

+ LLTerrainPaint::ptr_t paint = std::make_shared<LLTerrainPaint>();

+ const U16 width = 33;

+ paint->mStartX = 1;

+ paint->mStartY = 1;

+ paint->mWidthX = width;

+ paint->mWidthY = width;

+ constexpr U8 bit_depth = 5;

+ paint->mBitDepth = bit_depth;

+ constexpr U8 max_value = (1 << bit_depth) - 1;

+ const size_t pixel_count = width * width;

+ const U8 components = LLTerrainPaint::RGBA;

+ paint->mComponents = components;

+ paint->mData.resize(components * pixel_count);

+ for (size_t h = 0; h < paint->mWidthY; ++h)

+ {

+ for (size_t w = 0; w < paint->mWidthX; ++w)

+ {

+ const size_t pixel = (h * paint->mWidthX) + w;

+ // Solid blue color

+ paint->mData[(components*pixel) + components - 2] = max_value; // blue

+ //// Alpha grid: 1.0 if odd for either dimension, 0.0 otherwise

+ //const U8 alpha = U8(F32(max_value) * F32(bool(w % 2) || bool(h % 2)));

+ //paint->mData[(components*pixel) + components - 1] = alpha; // alpha

+ // Alpha "frame"

+ const bool edge = w == 0 || h == 0 || w == (paint->mWidthX - 1) || h == (paint->mWidthY - 1);

+ const bool near_edge_frill = ((w == 1 || w == (paint->mWidthX - 2)) && (h % 2 == 0)) ||

+ ((h == 1 || h == (paint->mWidthY - 2)) && (w % 2 == 0));

+ const U8 alpha = U8(F32(max_value) * F32(edge || near_edge_frill));

+ paint->mData[(components*pixel) + components - 1] = alpha; // alpha

+ }

+ }

+ paint_request_queue.enqueue(paint);

+#endif

+

+ // Apply the paint queues ad-hoc right here for now.

+ // *TODO: Eventually the paint queue(s) should be applied at a

+ // predictable time in the viewer frame loop.

+ // TODO: In hindsight... maybe we *should* bind the paintmap to the render buffer. That makes a lot more sense, and we wouldn't have to reduce its resolution by settling for the bake buffer. If we do that, make a comment above convertPaintQueueRGBAToRGB that the texture is modified!

+ LLTerrainPaintQueue paint_send_queue = LLTerrainPaintMap::convertPaintQueueRGBAToRGB(*tex, paint_request_queue);

+ LLTerrainPaintQueue& paint_map_queue = gLocalTerrainMaterials.getPaintMapQueue();

+ paint_map_queue.enqueue(paint_send_queue);

+ LLTerrainPaintMap::applyPaintQueueRGB(*tex, paint_map_queue);

+

+ return true;

+ }

+};

+

+ static LLVOAvatar* findAvatar()

+ {

+ return find_avatar_from_object(LLSelectMgr::getInstance()->getSelection()->getPrimaryObject());

+ }

+

+ if (LLVOAvatar* avatar = findAvatar())

+

+public:

+ static bool isAvailable()

+ {

+ if (LLVOAvatar* avatar = findAvatar())

+ {

+ return LLAvatarActions::canCallTo(avatar->getID());

+ }

+ return LLAvatarActions::canCall();

+ }

+ view_listener_t::addMenu(new LLAdvancedTerrainEditLocalPaintMap(), "Advanced.TerrainEditLocalPaintMap");

+ enable.add("Avatar.EnableCall", boost::bind(&LLAvatarCall::isAvailable));

+ LLSD metadata;

+ if (msg->getNumberOfBlocksFast(_PREHASH_MetaData) > 0)

+ {

+ S32 metadata_size = msg->getSizeFast(_PREHASH_MetaData, 0, _PREHASH_Data);

+ std::string metadata_buffer;

+ metadata_buffer.resize(metadata_size, 0);

+

+ msg->getBinaryDataFast(_PREHASH_MetaData, _PREHASH_Data, &metadata_buffer[0], metadata_size, 0, metadata_size );

+ std::stringstream metadata_stream(metadata_buffer);

+ if (LLSDSerialize::fromBinary(metadata, metadata_stream, metadata_size) == LLSDParser::PARSE_FAILURE)

+ {

+ metadata.clear();

+ }

+ }

+

+ sender,

+ metadata);

+ U32 flags = (BEACON_SHOW_MAP | BEACON_FOCUS_MAP);

+ if (msg->has("Options"))

+ {

+ msg->getU32("Options", "Flags", flags);

+ }

+ if (flags & BEACON_SHOW_MAP)

+ {

+ bool old_auto_focus = instance->getAutoFocus();

+ instance->setAutoFocus(flags & BEACON_FOCUS_MAP);

+ instance->openFloater("center");

+ instance->setAutoFocus(old_auto_focus);

+ }

+LLGLSLShader gTerrainStampProgram;

+ if (gSavedSettings.getBOOL("LocalTerrainPaintEnabled"))

+ {

+ if (success)

+ {

+ LLGLSLShader* shader = &gTerrainStampProgram;

+ U32 bit_depth = gSavedSettings.getU32("TerrainPaintBitDepth");

+ // LLTerrainPaintMap currently uses an RGB8 texture internally

+ bit_depth = llclamp(bit_depth, 1, 8);

+ shader->mName = llformat("Terrain Stamp Shader RGB%o", bit_depth);

+

+ shader->mShaderFiles.clear();

+ shader->mShaderFiles.push_back(make_pair("interface/terrainStampV.glsl", GL_VERTEX_SHADER));

+ shader->mShaderFiles.push_back(make_pair("interface/terrainStampF.glsl", GL_FRAGMENT_SHADER));

+ shader->mShaderLevel = mShaderLevel[SHADER_INTERFACE];

+ const U32 value_range = (1 << bit_depth) - 1;

+ shader->addPermutation("TERRAIN_PAINT_PRECISION", llformat("%d", value_range));

+ success = success && shader->createShader();

+ //llassert(success);

+ if (!success)

+ {

+ LL_WARNS() << "Failed to create shader '" << shader->mName << "', disabling!" << LL_ENDL;

+ gSavedSettings.setBOOL("RenderCanUseTerrainBakeShaders", false);

+ // continue as if this shader never happened

+ success = true;

+ }

+ }

+ }

+

+extern LLGLSLShader gTerrainStampProgram;

+#include "scope_exit.h"

+ LLSD body = capture_viewer_stats(include_preferences);

+ LLCoreHttpUtil::HttpCoroutineAdapter::messageHttpPost(url, body,

+ "Statistics posted to sim", "Failed to post statistics to sim");

+}

+

+LLSD capture_viewer_stats(bool include_preferences)

+{

+ LLViewerStats& vstats{ LLViewerStats::instance() };

+ vstats.getRecording().pause();

+ LL::scope_exit cleanup([&vstats]{ vstats.getRecording().resume(); });

+ LLSD body;

+ return body;

+LLSD capture_viewer_stats(bool include_preferences);

+ if (obj != mDragHoveredObject)

+

+ // fonts use an GL_UNSIGNED_BYTE image format,

+ // so they need convertion, init buffers if needed

+ LLImageGL::allocateConversionBuffer();

+

+#include "llcallbacklist.h"

+ "type: \"COLOR\", \"DEPTH\"\n",

+ sendReply(llsd::map("error", stringize("Unrecognized type ", std::quoted(event["type"].asString()), " [\"COLOR\"] or [\"DEPTH\"] is expected.")), event);

+ return;

+ sendReply(llsd::map("error", stringize("File path is empty.")), event);

+ return;

+ sendReply(llsd::map("error", stringize("Unrecognized format. [\"png\"], [\"jpeg\"] or [\"bmp\"] is expected.")), event);

+ return;

+ // take snapshot on the main coro

+ doOnIdleOneTime([this, event, filename, width, height, showui, showhud, rebuild, type, format]()

+ { sendReply(llsd::map("result", mViewerWindow->saveSnapshot(filename, width, height, showui, showhud, rebuild, type, format)), event); });

+

+ const bool changed = paint_map != mPaintMap;

+ // The paint map has changed, so edits are no longer valid

+ mPaintRequestQueue.clear();

+ mPaintMapQueue.clear();

+#include "llterrainpaintmap.h"

+ // Queue of client-triggered brush operations that need to be converted

+ // into a form that can be sent to the server.

+ // TODO: Consider getting rid of mPaintRequestQueue, as it's not really needed (brushes go directly to RGB queue)

+ LLTerrainBrushQueue& getBrushQueue() { return mBrushQueue; }

+ // Queue of client-triggered paint operations that need to be converted

+ // into a form that can be sent to the server.

+ // Paints in this queue are in RGBA format.

+ LLTerrainPaintQueue& getPaintRequestQueue() { return mPaintRequestQueue; }

+ // Paint queue for current paint map - this queue gets applied directly to

+ // the paint map. Paints within are assumed to have already been sent to

+ // the server. Paints in this queue are in RGB format.

+ LLTerrainPaintQueue& getPaintMapQueue() { return mPaintMapQueue; }

+ LLTerrainBrushQueue mBrushQueue;

+ LLTerrainPaintQueue mPaintRequestQueue{U8(4)};

+ LLTerrainPaintQueue mPaintMapQueue{U8(3)};

+bool LLVoiceClient::isCaptureNoDevice()

+{

+ return LLWebRTCVoiceClient::getInstance()->isCaptureNoDevice();

+}

+

+bool LLVoiceClient::isRenderNoDevice()

+{

+ return LLWebRTCVoiceClient::getInstance()->isRenderNoDevice();

+}

+

+ virtual bool isCaptureNoDevice() = 0;

+ virtual bool isRenderNoDevice() = 0;

+

+ bool isCaptureNoDevice();

+ bool isRenderNoDevice();

+ static LLCachedControl<bool> show_visualizer(gSavedSettings, "VoiceVisualizerEnabled", true);

+

+ LLSD args;

+ args["URL"] = LLTrans::getString("voice_morphing_url");

+ args["PREMIUM_URL"] = LLTrans::getString("premium_voice_morphing_url");

+

+ bool isCaptureNoDevice() override { return false; };

+ bool isRenderNoDevice() override { return false; };

+

+ mDeviceSettingsAvailable(false),

+ mIsTimerActive(false),

+ stopTimer();

+}

+

+void LLWebRTCVoiceClient::stopTimer()

+{

+ if (mIsTimerActive)

+ {

+ LLMuteList::instanceExists();

+ {

+ LLMuteList::getInstance()->removeObserver(this);

+ }

+ mIsTimerActive = false;

+ LL::Timers::instance().cancel(mVoiceTimerHandle);

+ }

+// This voice loop is called every 100ms

+void LLWebRTCVoiceClient::connectionTimer()

+ LL_PROFILE_ZONE_SCOPED_CATEGORY_VOICE;

+ bool voiceEnabled = mVoiceEnabled;

+

+ if (!isAgentAvatarValid())

+ {

+ if (sShuttingDown)

+ cleanUp();

+ return;

+ }

+ LLViewerRegion* regionp = gAgent.getRegion();

+ if (!regionp)

+ {

+ if (sShuttingDown)

+ cleanUp();

+ return;

+ }

+ if (!mProcessChannels)

+ {

+ // we've switched away from webrtc voice, so shut all channels down.

+ // leave channel can be called again and again without adverse effects.

+ // it merely tells channels to shut down if they're not already doing so.

+ leaveChannel(false);

+ }

+ else if (inSpatialChannel())

+ {

+ bool useEstateVoice = true;

+ // add session for region or parcel voice.

+ if (!regionp || regionp->getRegionID().isNull())

+ // no region, no voice.

+ return;

+ voiceEnabled = voiceEnabled && regionp->isVoiceEnabled();

+ if (voiceEnabled)

+ {

+ LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();

+ // check to see if parcel changed.

+ if (parcel && parcel->getLocalID() != INVALID_PARCEL_ID)

+ // parcel voice

+ if (!parcel->getParcelFlagAllowVoice())

+ voiceEnabled = false;

+ else if (!parcel->getParcelFlagUseEstateVoiceChannel())

+ // use the parcel-specific voice channel.

+ S32 parcel_local_id = parcel->getLocalID();

+ std::string channelID = regionp->getRegionID().asString() + "-" + std::to_string(parcel->getLocalID());

+

+ useEstateVoice = false;

+ if (!inOrJoiningChannel(channelID))

+ {

+ startParcelSession(channelID, parcel_local_id);

+ }

+ if (voiceEnabled && useEstateVoice && !inEstateChannel())

+ // estate voice

+ startEstateSession();

+ if (!voiceEnabled)

+ {

+ // voice is disabled, so leave and disable PTT

+ leaveChannel(true);

+ }

+ else

+ {

+ // we're in spatial voice, and voice is enabled, so determine positions in order

+ // to send position updates.

+ updatePosition();

+ }

+ [=, this] {

+ if (sShuttingDown)

+ {

+ cleanUp();

+ }

+ mDeviceSettingsAvailable = false;

+ mDeviceSettingsAvailable = false;

+

+ [=, this]

+ mDeviceSettingsAvailable = true;

+ mDeviceSettingsAvailable = false;

+ mDeviceSettingsAvailable = false;

+bool LLWebRTCVoiceClient::isCaptureNoDevice()

+{

+ return mCaptureDevices.empty() || mWebRTCDeviceInterface->isCaptureNoDevice();

+}

+

+bool LLWebRTCVoiceClient::isRenderNoDevice()

+{

+ return mRenderDevices.empty() || mWebRTCDeviceInterface->isRenderNoDevice();

+}

+

+ mTuningMicGain = volume;

+ if (isRenderNoDevice())

+ {

+ volume = 0;

+ }

+ if (isCaptureNoDevice())

+ return 0;

+

+ if (mIsInTuningMode)

+ return (1.0f - mWebRTCDeviceInterface->getTuningAudioLevel() * LEVEL_SCALE_WEBRTC) * mTuningMicGain / 2.1f;

+

+ return (1.0f - mWebRTCDeviceInterface->getPeerConnectionAudioLevel() * LEVEL_SCALE_WEBRTC) * mMicGain / 2.1f;

+ if (clearCurrentList)

+ return mIsTimerActive;

+ mSpeakerVolume = volume;

+ << " coro "<< (mIsTimerActive ? "active" : "inactive")

+ if (!mIsTimerActive)

+ LL_DEBUGS("Voice") << "Starting" << LL_ENDL;

+ mIsTimerActive = true;

+ LLMuteList::getInstance()->addObserver(this);

+ mVoiceTimerHandle = LL::Timers::instance().scheduleEvery([this]() { connectionTimer(); return false; }, UPDATE_THROTTLE_SECONDS);

+ [=, this] {

+ LL::WorkQueue::postMaybe(mMainQueue, [=, this] { mIceCandidates.push_back(candidate); });

+ [=, this] {

+ [=, this] {

+ [=, this] {

+ [=, this] {

+ LL::WorkQueue::postMaybe(mMainQueue, [=, this] { LLVoiceWebRTCConnection::OnDataReceivedImpl(data, binary); });

+ [=, this] {

+#include "llcallbacklist.h"

+ bool deviceSettingsAvailable() override { return mDeviceSettingsAvailable; }

+ bool isCaptureNoDevice() override;

+ bool isRenderNoDevice() override;

+

+ void connectionTimer();

+ // stop state machine

+ void stopTimer();

+

+ bool mDeviceSettingsAvailable;

+ // and false when the panelvoicedevicesettings has queried for an update status.

+ bool mIsTimerActive;

+ LL::Timers::handle_t mVoiceTimerHandle;

+#include "llmutex.h"

+

+ static LLCachedControl<bool> print_coords(gSavedSettings, "MapShowGridCoords");

+ static LLFontGL* font = LLFontGL::getFontSansSerifSmallBold();

+

+ auto print = [&](std::string text, F32 x, F32 y, bool use_ellipses)

+ {

+ font->renderUTF8(text, 0,

+ (F32)llfloor(left + x), (F32)llfloor(bottom + y),

+ LLColor4::white,

+ LLFontGL::LEFT, LLFontGL::BASELINE, LLFontGL::NORMAL, LLFontGL::DROP_SHADOW,

+ S32_MAX, //max_chars

+ (S32)mMapScale, //max_pixels

+ NULL,

+ use_ellipses);

+ };

+

+ std::string grid_name = info->getName();

+ grid_name += " (" + sStringsMap["offline"] + ")";

+

+ if (print_coords)

+ print(grid_name, 3, 14, true);

+ // Obtain and print the grid map coordinates

+ LLVector3d region_pos = info->getGlobalOrigin();

+ std::string grid_coords = llformat("[%.0f, %.0f]", region_pos[VX] / 256, region_pos[VY] / 256);

+ print(grid_coords, 3, 2, false);

+ else

+ print(grid_name, 3, 2, true);

+#include <cmath> // log()

+// Called from LLViewHighlightTransparent when "Highlight Transparent" is toggled

+ const U32 types_to_traverse[] =

+ LLViewerRegion::PARTITION_VOLUME,

+ LLViewerRegion::PARTITION_BRIDGE,

+ LLViewerRegion::PARTITION_AVATAR

+ };

+ LLOctreeDirty dirty;

+ for (LLViewerRegion* region : LLWorld::getInstance()->getRegionList())

+ {

+ for (U32 type : types_to_traverse)

+ {

+ LLSpatialPartition* part = region->getSpatialPartition(type);

+ dirty.traverse(part->mOctree);

+ }

+local result_view = require 'result_view'

+

+local function result(keys)

+ local result_table = {

+ result=result_view(keys.result),

+ -- call result_table:close() to release result sets before garbage

+ -- collection or script completion

+ close = function(self)

+ result_view.close(keys.result[1])

+ end

+ }

+ -- When the result_table is destroyed, close its result_views.

+ return LL.setdtor('LLAgent result', result_table, result_table.close)

+end

+function LLAgent.getID()

+ return leap.request('LLAgent', {op = 'getID'}).id

+end

+

+-- Get the nearby avatars in a range of provided "dist",

+-- if "dist" is not specified, "RenderFarClip" setting is used

+-- reply will contain "result" table with following fields:

+-- "id", "global_pos", "region_pos", "name", "region_id"

+function LLAgent.getNearbyAvatarsList(...)

+ local args = mapargs('dist', ...)

+ args.op = 'getNearbyAvatarsList'

+ return result(leap.request('LLAgent', args))

+end

+

+-- reply will contain "result" table with following fields:

+-- "id", "global_pos", "region_pos", "region_id"

+function LLAgent.getNearbyObjectsList(...)

+ local args = mapargs('dist', ...)

+ args.op = 'getNearbyObjectsList'

+ return result(leap.request('LLAgent', args))

+end

+

+-- Get screen position of your own avatar or any other (if "avatar_id" is specified)

+-- reply contains "x", "y" coordinates and "onscreen" flag to indicate if it's actually in within the current window

+-- avatar render position is used as the point

+function LLAgent.getAgentScreenPos(...)

+ local args = mapargs('avatar_id', ...)

+ args.op = 'getAgentScreenPos'

+ return leap.request('LLAgent', args)

+end

+

+function UI.toggleFloater(...)

+ local args = mapargs('name,key', ...)

+ args.op = 'toggleInstance'

+ leap.send("LLFloaterReg", args)

+local LLAgent = require 'LLAgent'

+local LLListener = require 'LLListener'

+local agent_id = LLAgent.getID()

+ -- ignore messages and commands from other avatars

+ if event_data.from_id ~= agent_id then

+ return true

+ elseif string.find(event_data.message, '[LUA]') then

+for _, key in pairs(anims) do

+ table.insert(anim_ids, {id = key.id, name = key.name})

+ local random_anim = anim_ids[math.random(#anim_ids)]

+ local anim_info = LLAgent.getAnimationInfo(random_anim.id)

+ print("Starting animation locally: " .. random_anim.name)

+ print("Loop: " .. tostring(anim_info.is_loop) .. " Joints: " .. anim_info.num_joints .. " Duration " .. tonumber(string.format("%.2f", anim_info.duration)))

+ LLAgent.playAnimation{item_id=random_anim.id}

+ if anim_info.is_loop or anim_info.duration > 3 then

+ LLAgent.stopAnimation(random_anim.id)

+ self:post({action="set_enabled", ctrl_name="open_btn", value = not event_data.value})

+inspect = require 'inspect'

+LLAgent = require 'LLAgent'

+

+-- Get the list of nearby avatars and print the info

+local nearby_avatars = LLAgent.getNearbyAvatarsList()

+if nearby_avatars.result.length == 0 then

+ print("No avatars nearby")

+else

+ print("Nearby avatars:")

+ for _, av in pairs(nearby_avatars.result) do

+ print(av.name ..' ID: ' .. av.id ..' Global pos:' .. inspect(av.global_pos))

+ end

+end

+

+-- Get the list of nearby objects in 3m range and print the info

+local nearby_objects = LLAgent.getNearbyObjectsList(3)

+if nearby_objects.result.length == 0 then

+ print("No objects nearby")

+else

+ print("Nearby objects:")

+ local pos={}

+ for _, obj in pairs(nearby_objects.result) do

+ print('ID: ' .. obj.id ..' Global pos:' .. inspect(obj.global_pos))

+ end

+end

+LLAgent = require 'LLAgent'

+

+local screen_pos = LLAgent.getAgentScreenPos()

+if screen_pos.onscreen then

+ print("Avatar screen coordinates X: " .. screen_pos.x .. " Y: " .. screen_pos.y)

+else

+ print("Avatar is not on the screen")

+end

+ UI.popup:tip('Toolbars were reshuffled')

+ UI.popup:tip('Canceled')

+ <string name="bot_warning">

+Du chatter med en bot, [NAME]. Del ikke personlige oplysninger.

+Læs mere på https://second.life/scripted-agents.

+ </string>

+ <panel.string name="time_stamp_template_ampm">[wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour12,datetime,local]:[min,datetime,local]:[second,datetime,local] [ampm,datetime,slt]</panel.string>

+ <panel.string name="time_stamp_template">[wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local]</panel.string>

+ <floater.string name="timeStampAMPM">

+ [wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour12,datetime,local]:[min,datetime,local]:[second,datetime,local] [ampm,datetime,slt]

+ </floater.string>

+ [wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local]

+ [day,datetime,slt].[mthnum,datetime,slt].[year,datetime,slt]

+ <string name="acquired_date_ampm">

+ [wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour12,datetime,local]:[min,datetime,local]:[second,datetime,local] [ampm,datetime,local]

+ </string>

+ [wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local]

+ <string name="acquired_date_ampm">

+ [wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour12,datetime,local]:[min,datetime,local]:[second,datetime,local] [ampm,datetime,local]

+ </string>

+ [wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local]

+ [day,datetime,slt].[mthnum,datetime,slt].[year,datetime,slt]

+ <string

+ name="date_format_full"

+ value="SL-Geburtstag: [day,datetime,utc]. [mth,datetime,utc]. [year,datetime,utc]" />

+ <string

+ name="date_format_short"

+ value="SL-Geburtstag: [day,datetime,utc]. [mth,datetime,utc]." />

+ [weekday, datetime, slt], [day, datetime, slt]. [month, datetime, slt] [year, datetime, slt]

+ [wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour,datetime,local]:[min,datetime,local]:[second,datetime,local]

+ </panel.string>

+ <panel.string name="acquiredDateAMPM">

+ [wkday,datetime,local]. [day,datetime,local]. [mth,datetime,local]. [year,datetime,local] [hour12,datetime,local]:[min,datetime,local]:[second,datetime,local] [ampm,datetime,local]

+ <string name="AboutTime">[day, datetime, slt]. [month, datetime, slt] [year, datetime, slt] [hour, datetime, slt]:[min, datetime, slt]:[second,datetime,slt]</string>

+ <string name="GroupPlanningDate">[day,datetime,utc].[mthnum,datetime,utc].[year,datetime,utc]</string>

+ <string name="GroupMoneyDate">[weekday,datetime,utc] [day,datetime,utc]. [mth,datetime,utc]. [year,datetime,utc]</string>

+ <string name="bot_warning">

+ Sie chatten mit einem Bot, [NAME]. Geben Sie keine persönlichen Informationen weiter.

+Erfahren Sie mehr unter https://second.life/scripted-agents.

+ </string>

+ <string name="AvatarBirthDateFormat">[day,datetime,slt].[mthnum,datetime,slt].[year,datetime,slt]</string>

+ <check_box

+ control_name="LuaDebugShowSource"

+ follows="right|top"

+ height="15"

+ label="Show source info"

+ layout="topleft"

+ top="10"

+ right ="-70"

+ tool_tip="Show source info in Lua Debug Console output"

+ name="show_script_name"

+ width="70"/>

+ multi_select="true"

+ height="150"

+ <check_box

+ name="grid_coords_chk"

+ control_name="MapShowGridCoords"

+ layout="topleft"

+ follows="top|right"

+ top_pad="2"

+ left="3"

+ height="16"

+ width="22"

+ />

+ <text

+ name="grid_coords_label"

+ type="string"

+ layout="topleft"

+ follows="top|right"

+ top_delta="2"

+ left_pad="3"

+ height="16"

+ width="220"

+ halign="left"

+ length="1"

+ >Show grid map coordinates</text>

+

+ height="306"

+ height="121"

+ label="Edit Local Paintmap"

+ name="Edit Local Paintmap">

+ <menu_item_call.on_click

+ function="Advanced.TerrainEditLocalPaintMap" />

+ </menu_item_call>

+ <menu_item_call

+ enabled="true"

+ max_val="4.0"

+ follows="right|top"

+ font="SansSerif"

+ height="20"

+ layout="topleft"

+ top_delta="0"

+ right="-100"

+ name="estate_id_lbl"

+ width="80">

+ Estate ID:

+ </text>

+ <line_editor

+ follows="right|top"

+ font="SansSerif"

+ height="20"

+ layout="topleft"

+ top_delta="0"

+ name="estate_id"

+ enabled="false"

+ right="-10"

+ initial_value="unknown"

+ width="85" />

+ <text

+ follows="right|top"

+ font="SansSerif"

+ height="20"

+ layout="topleft"

+ top_delta="0"

+ right="-100"

+ name="grid_position_lbl"

+ width="80">

+ Grid Position:

+ </text>

+ <line_editor

+ follows="right|top"

+ font="SansSerif"

+ height="20"

+ layout="topleft"

+ right="-55"

+ name="grid_position_x"

+ enabled="false"

+ top_delta="0"

+ default_text="n/a"

+ width="40" />

+ <line_editor

+ follows="right|top"

+ font="SansSerif"

+ height="20"

+ layout="topleft"

+ right="-10"

+ name="grid_position_y"

+ enabled="false"

+ top_delta="0"

+ default_text="n/a"

+ width="40" />

+ <text

+ <string name="bot_warning">

+ You are chatting with a bot, [NAME]. Do not share any personal information.

+Learn more at https://second.life/scripted-agents.

+ </string>

+ width="20" />

+ visible="false"

+ <string name="bot_warning">

+Estás conversando con un bot, [NAME]. No compartas información personal.

+Más información en https://second.life/scripted-agents.

+ </string>

+ <string name="bot_warning">

+Vous discutez avec un bot, [NAME]. Ne partagez pas d’informations personnelles.

+En savoir plus sur https://second.life/scripted-agents.

+ </string>

+ <string name="bot_warning">

+Stai parlando con un bot, [NAME]. Non condividere informazioni personali.

+Scopri di più su https://second.life/scripted-agents.

+ </string>

+ <string name="bot_warning">

+[NAME]とチャットしています。個人情報を共有しないでください。

+詳細は https://second.life/scripted-agents をご覧ください。

+ </string>

+ <string name="bot_warning">

+Rozmawiasz z botem [NAME]. Nie udostępniaj żadnych danych osobowych.

+Dowiedz się więcej na https://second.life/scripted-agents.

+ </string>

+ <string name="bot_warning">

+Você está conversando com um bot, [NAME]. Não compartilhe informações pessoais.

+Saiba mais em https://second.life/scripted-agents.

+ </string>

+ <string name="bot_warning">

+Вы общаетесь с ботом [NAME]. Не передавайте личные данные.

+Подробнее на https://second.life/scripted-agents.

+ </string>

+ <string name="bot_warning">

+Bir bot ile sohbet ediyorsunuz, [NAME]. Kişisel bilgilerinizi paylaşmayın.

+Daha fazla bilgi için: https://second.life/scripted-agents.

+ </string>

+ <string name="bot_warning">

+您正在与人工智能机器人 [NAME] 聊天。请勿分享任何个人信息。

+了解更多：https://second.life/scripted-agents。

+ </string>

+ fsyspath settings{ newview / "app_settings" / "settings.xml" };

+ gSavedSettings.loadFromFile(settings, true);

+ std::string require{ fsyspath(newview / "scripts" / "lua" / "require") };

+ # SDL2

+ for libfile in (

+ 'libSDL2-2.0.dylib',

+ ):

+ dylibs += path_optional(os.path.join(relpkgdir, libfile), libfile)

+