316 lines
7.6 KiB
C++
316 lines
7.6 KiB
C++
/**
|
|
* @file llagentbenefits.cpp
|
|
*
|
|
* $LicenseInfo:firstyear=2019&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2019, 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$
|
|
*/
|
|
|
|
#include "llviewerprecompiledheaders.h"
|
|
#include "llagentbenefits.h"
|
|
|
|
// <FS:Ansariel> OpenSim legacy economy
|
|
#include "llagent.h"
|
|
#include "llagentpicksinfo.h"
|
|
#include "lleconomy.h"
|
|
#include "llstartup.h"
|
|
#include "llviewercontrol.h"
|
|
#include "llviewernetwork.h"
|
|
#include "llviewerregion.h"
|
|
// </FS:Ansariel>
|
|
|
|
LLAgentBenefits::LLAgentBenefits():
|
|
m_initalized(false),
|
|
m_animated_object_limit(-1),
|
|
m_animation_upload_cost(-1),
|
|
m_attachment_limit(-1),
|
|
m_group_membership_limit(-1),
|
|
m_picks_limit(-1),
|
|
m_sound_upload_cost(-1),
|
|
m_texture_upload_cost(-1),
|
|
m_create_group_cost(-1)
|
|
{
|
|
}
|
|
|
|
LLAgentBenefits::~LLAgentBenefits()
|
|
{
|
|
}
|
|
|
|
// This could be extended to a template scheme or otherwise modified
|
|
// to support other types, if and when needed. Currently all fields
|
|
// the viewer cares about are integer.
|
|
bool get_required_S32(const LLSD& sd, const LLSD::String& key, S32& value)
|
|
{
|
|
value = -1;
|
|
if (sd.has(key))
|
|
{
|
|
value = sd[key].asInteger();
|
|
return true;
|
|
}
|
|
|
|
LL_WARNS("Benefits") << "Missing required benefit field " << key << LL_ENDL;
|
|
return false;
|
|
}
|
|
|
|
bool LLAgentBenefits::init(const LLSD& benefits_sd)
|
|
{
|
|
LL_DEBUGS("Benefits") << "initializing benefits from " << benefits_sd << LL_ENDL;
|
|
|
|
if (!get_required_S32(benefits_sd, "animated_object_limit", m_animated_object_limit))
|
|
{
|
|
return false;
|
|
}
|
|
if (!get_required_S32(benefits_sd, "animation_upload_cost", m_animation_upload_cost))
|
|
{
|
|
return false;
|
|
}
|
|
if (!get_required_S32(benefits_sd, "attachment_limit", m_attachment_limit))
|
|
{
|
|
return false;
|
|
}
|
|
if (!get_required_S32(benefits_sd, "create_group_cost", m_create_group_cost))
|
|
{
|
|
return false;
|
|
}
|
|
if (!get_required_S32(benefits_sd, "group_membership_limit", m_group_membership_limit))
|
|
{
|
|
return false;
|
|
}
|
|
if (!get_required_S32(benefits_sd, "picks_limit", m_picks_limit))
|
|
{
|
|
return false;
|
|
}
|
|
if (!get_required_S32(benefits_sd, "sound_upload_cost", m_sound_upload_cost))
|
|
{
|
|
return false;
|
|
}
|
|
if (!get_required_S32(benefits_sd, "texture_upload_cost", m_texture_upload_cost))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// FIXME PREMIUM - either use this field or get rid of it
|
|
m_initalized = true;
|
|
return true;
|
|
}
|
|
|
|
S32 LLAgentBenefits::getAnimatedObjectLimit() const
|
|
{
|
|
// <FS:Ansariel> OpenSim legacy economy
|
|
//return m_animated_object_limit;
|
|
if (LLGridManager::instance().isInSecondLife())
|
|
{
|
|
return m_animated_object_limit;
|
|
}
|
|
else
|
|
{
|
|
S32 max_attach = 0;
|
|
if (gSavedSettings.getBOOL("AnimatedObjectsIgnoreLimits"))
|
|
{
|
|
max_attach = getAttachmentLimit();
|
|
}
|
|
else
|
|
{
|
|
if (gAgent.getRegion())
|
|
{
|
|
LLSD features;
|
|
gAgent.getRegion()->getSimulatorFeatures(features);
|
|
if (features.has("AnimatedObjects"))
|
|
{
|
|
max_attach = features["AnimatedObjects"]["MaxAgentAnimatedObjectAttachments"].asInteger();
|
|
}
|
|
}
|
|
}
|
|
return max_attach;
|
|
}
|
|
// </FS:Ansariel>
|
|
}
|
|
|
|
S32 LLAgentBenefits::getAnimationUploadCost() const
|
|
{
|
|
// <FS:Ansariel> OpenSim legacy economy
|
|
//return m_animation_upload_cost;
|
|
return LLGridManager::instance().isInSecondLife() ? m_animation_upload_cost : LLGlobalEconomy::instance().getPriceUpload();
|
|
// </FS:Ansariel>
|
|
}
|
|
|
|
S32 LLAgentBenefits::getAttachmentLimit() const
|
|
{
|
|
// <FS:Ansariel> OpenSim legacy economy
|
|
//return m_attachment_limit;
|
|
if (LLGridManager::instance().isInSecondLife())
|
|
{
|
|
return m_attachment_limit;
|
|
}
|
|
else
|
|
{
|
|
const S32 MAX_AGENT_ATTACHMENTS = 38;
|
|
|
|
S32 max_attach = MAX_AGENT_ATTACHMENTS;
|
|
|
|
if (gAgent.getRegion())
|
|
{
|
|
LLSD features;
|
|
gAgent.getRegion()->getSimulatorFeatures(features);
|
|
if (features.has("MaxAgentAttachments"))
|
|
{
|
|
max_attach = features["MaxAgentAttachments"].asInteger();
|
|
}
|
|
}
|
|
return max_attach;
|
|
}
|
|
// </FS:Ansariel>
|
|
}
|
|
|
|
S32 LLAgentBenefits::getCreateGroupCost() const
|
|
{
|
|
// <FS:Ansariel> OpenSim legacy economy
|
|
//return m_create_group_cost;
|
|
return LLGridManager::instance().isInSecondLife() ? m_create_group_cost : 0;
|
|
// </FS:Ansariel>
|
|
}
|
|
|
|
S32 LLAgentBenefits::getGroupMembershipLimit() const
|
|
{
|
|
// <FS:Ansariel> OpenSim legacy economy
|
|
//return m_group_membership_limit;
|
|
return LLGridManager::instance().isInSecondLife() ? m_group_membership_limit : gMaxAgentGroups;
|
|
// </FS:Ansariel>
|
|
}
|
|
|
|
S32 LLAgentBenefits::getPicksLimit() const
|
|
{
|
|
// <FS:Ansariel> OpenSim legacy economy
|
|
//return m_picks_limit;
|
|
return LLGridManager::instance().isInSecondLife() ? m_picks_limit : LLAgentPicksInfo::instance().getMaxNumberOfPicks();
|
|
// </FS:Ansariel>
|
|
}
|
|
|
|
S32 LLAgentBenefits::getSoundUploadCost() const
|
|
{
|
|
// <FS:Ansariel> OpenSim legacy economy
|
|
//return m_sound_upload_cost;
|
|
return LLGridManager::instance().isInSecondLife() ? m_sound_upload_cost : LLGlobalEconomy::instance().getPriceUpload();
|
|
// </FS:Ansariel>
|
|
}
|
|
|
|
S32 LLAgentBenefits::getTextureUploadCost() const
|
|
{
|
|
// <FS:Ansariel> OpenSim legacy economy
|
|
//return m_texture_upload_cost;
|
|
return LLGridManager::instance().isInSecondLife() ? m_texture_upload_cost : LLGlobalEconomy::instance().getPriceUpload();
|
|
// </FS:Ansariel>
|
|
}
|
|
|
|
bool LLAgentBenefits::findUploadCost(LLAssetType::EType& asset_type, S32& cost) const
|
|
{
|
|
bool succ = false;
|
|
if (asset_type == LLAssetType::AT_TEXTURE)
|
|
{
|
|
cost = getTextureUploadCost();
|
|
succ = true;
|
|
}
|
|
else if (asset_type == LLAssetType::AT_SOUND)
|
|
{
|
|
cost = getSoundUploadCost();
|
|
succ = true;
|
|
}
|
|
else if (asset_type == LLAssetType::AT_ANIMATION)
|
|
{
|
|
cost = getAnimationUploadCost();
|
|
succ = true;
|
|
}
|
|
return succ;
|
|
}
|
|
|
|
LLAgentBenefitsMgr::LLAgentBenefitsMgr()
|
|
{
|
|
}
|
|
|
|
LLAgentBenefitsMgr::~LLAgentBenefitsMgr()
|
|
{
|
|
}
|
|
|
|
// static
|
|
const LLAgentBenefits& LLAgentBenefitsMgr::current()
|
|
{
|
|
return instance().mCurrent;
|
|
}
|
|
|
|
// static
|
|
const LLAgentBenefits& LLAgentBenefitsMgr::get(const std::string& package)
|
|
{
|
|
if (instance().mPackageMap.find(package) != instance().mPackageMap.end())
|
|
{
|
|
return instance().mPackageMap[package];
|
|
}
|
|
else
|
|
{
|
|
return instance().mDefault;
|
|
}
|
|
}
|
|
|
|
// static
|
|
bool LLAgentBenefitsMgr::init(const std::string& package, const LLSD& benefits_sd)
|
|
{
|
|
LLAgentBenefits benefits;
|
|
if (!benefits.init(benefits_sd))
|
|
{
|
|
LL_WARNS("Benefits") << "Unable to initialize package " << package << " from sd " << benefits_sd << LL_ENDL;
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
instance().mPackageMap[package] = benefits;
|
|
}
|
|
return true;
|
|
|
|
}
|
|
|
|
// static
|
|
bool LLAgentBenefitsMgr::initCurrent(const std::string& package, const LLSD& benefits_sd)
|
|
{
|
|
LLAgentBenefits benefits;
|
|
if (!benefits.init(benefits_sd))
|
|
{
|
|
LL_WARNS("Benefits") << "Unable to initialize package " << package << " from sd " << benefits_sd << LL_ENDL;
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
instance().mCurrent = benefits;
|
|
instance().mCurrentName = package;
|
|
}
|
|
return true;
|
|
|
|
}
|
|
|
|
// static
|
|
bool LLAgentBenefitsMgr::has(const std::string& package)
|
|
{
|
|
return instance().mPackageMap.find(package) != instance().mPackageMap.end();
|
|
}
|
|
|
|
//static
|
|
bool LLAgentBenefitsMgr::isCurrent(const std::string& package)
|
|
{
|
|
return instance().mCurrentName == package;
|
|
}
|