livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

QAR-1284 ip-takedown tools simulator work is ready for merge 

svn merge -r115879:116020 svn+ssh://svn.lindenlab.com/svn/linden/branches/dmcat/dmcat-5
no conflicts
master
Andrew Meadows 2009-04-01 17:11:37 +00:00
parent a8525c90b9
commit 3d4e04b556
13 changed files with 769 additions and 455 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
indra/llcommon/lllivefile.cpp
View File

@ -167,3 +167,12 @@ void LLLiveFile::addToEventTimer()
impl.mEventTimer = new LiveFileEventTimer(*this, impl.mRefreshPeriod);
}
void LLLiveFile::setRefreshPeriod(F32 seconds)
{
if (seconds < 0.f)
{
seconds = -seconds;
}
impl.mRefreshPeriod = seconds;
}

2
indra/llcommon/lllivefile.h
View File

@ -52,6 +52,8 @@ public:
// Normally, just calling checkAndReload() is enough. In some cases
// though, you may need to let the live file periodically check itself.
void setRefreshPeriod(F32 seconds);
protected:
virtual void loadFile() = 0; // Implement this to load your file if it changed

23
indra/llinventory/llinventory.cpp
View File

@ -333,15 +333,6 @@ void LLInventoryItem::copyItem(const LLInventoryItem* other)
mCreationDate = other->mCreationDate;
}
// As a constructor alternative, the clone() method works like a
// copy constructor, but gens a new UUID.
void LLInventoryItem::cloneItem(LLPointer<LLInventoryItem>& newitem) const
{
newitem = new LLInventoryItem;
newitem->copyItem(this);
newitem->mUUID.generate();
}
const LLPermissions& LLInventoryItem::getPermissions() const
{
return mPermissions;
@ -934,6 +925,12 @@ BOOL LLInventoryItem::exportLegacyStream(std::ostream& output_stream, BOOL inclu
LLSD LLInventoryItem::asLLSD() const
{
LLSD sd = LLSD();
asLLSD(sd);
return sd;
}
void LLInventoryItem::asLLSD( LLSD& sd ) const
{
sd[INV_ITEM_ID_LABEL] = mUUID;
sd[INV_PARENT_ID_LABEL] = mParentUUID;
sd[INV_PERMISSIONS_LABEL] = ll_create_sd_from_permissions(mPermissions);
@ -965,11 +962,9 @@ LLSD LLInventoryItem::asLLSD() const
sd[INV_NAME_LABEL] = mName;
sd[INV_DESC_LABEL] = mDescription;
sd[INV_CREATION_DATE_LABEL] = (S32) mCreationDate;
return sd;
}
bool LLInventoryItem::fromLLSD(LLSD& sd)
bool LLInventoryItem::fromLLSD(const LLSD& sd)
{
mInventoryType = LLInventoryType::IT_NONE;
mAssetUUID.setNull();
@ -1419,7 +1414,7 @@ void LLInventoryCategory::packMessage(LLMessageSystem* msg) const
msg->addStringFast(_PREHASH_Name, mName);
}
bool LLInventoryCategory::fromLLSD(LLSD& sd)
bool LLInventoryCategory::fromLLSD(const LLSD& sd)
{
std::string w;
@ -1661,6 +1656,7 @@ LLSD ll_create_sd_from_inventory_item(LLPointer<LLInventoryItem> item)
return rv;
}
/* deprecated, use LLInventoryItem::fromLLSD() instead
LLPointer<LLInventoryItem> ll_create_item_from_sd(const LLSD& sd_item)
{
LLPointer<LLInventoryItem> rv = new LLInventoryItem;
@ -1690,6 +1686,7 @@ LLPointer<LLInventoryItem> ll_create_item_from_sd(const LLSD& sd_item)
rv->setCreationDate(sd_item[INV_CREATION_DATE_LABEL].asInteger());
return rv;
}
*/
LLSD ll_create_sd_from_inventory_category(LLPointer<LLInventoryCategory> cat)
{

87
indra/llinventory/llinventory.h
View File

@ -89,7 +89,7 @@ public:
void copyObject(const LLInventoryObject* other); // LLRefCount requires custom copy
// accessors
const LLUUID& getUUID() const;
virtual const LLUUID& getUUID() const;
const LLUUID& getParentUUID() const;
const std::string& getName() const;
LLAssetType::EType getType() const;
@ -225,10 +225,7 @@ public:
LLInventoryItem(const LLInventoryItem* other);
virtual void copyItem(const LLInventoryItem* other); // LLRefCount requires custom copy
// As a constructor alternative, the clone() method works like a
// copy constructor, but gens a new UUID.
// It is up to the caller to delete (unref) the item.
virtual void cloneItem(LLPointer<LLInventoryItem>& newitem) const;
void generateUUID() { mUUID.generate(); }
// accessors
const LLPermissions& getPermissions() const;
@ -276,7 +273,8 @@ public:
S32 packBinaryBucket(U8* bin_bucket, LLPermissions* perm_override = NULL) const;
void unpackBinaryBucket(U8* bin_bucket, S32 bin_bucket_size);
LLSD asLLSD() const;
bool fromLLSD(LLSD& sd);
void asLLSD( LLSD& sd ) const;
bool fromLLSD(const LLSD& sd);
};
@ -317,7 +315,7 @@ public:
virtual void unpackMessage(LLMessageSystem* msg, const char* block, S32 block_num = 0);
LLSD asLLSD() const;
bool fromLLSD(LLSD& sd);
bool fromLLSD(const LLSD& sd);
// file support
virtual BOOL importFile(LLFILE* fp);
@ -338,85 +336,12 @@ protected:
// Useful bits
//-----------------------------------------------------------------------------
// This functor tests if an item is transferrable and returns true if
// it is. Derived from unary_function<> so that the object can be used
// in stl-compliant adaptable predicates (eg, not1<>). You might want
// to use this in std::partition() or similar logic.
struct IsItemTransferable : public std::unary_function<LLInventoryItem*, bool>
{
LLUUID mDestID;
IsItemTransferable(const LLUUID& dest_id) : mDestID(dest_id) {}
bool operator()(const LLInventoryItem* item) const
{
return (item->getPermissions().allowTransferTo(mDestID)) ? true:false;
}
};
// This functor is used to set the owner and group of inventory items,
// for example, in a simple std::for_each() loop. Note that the call
// to setOwnerAndGroup can fail if authority_id != LLUUID::null.
struct SetItemOwnerAndGroup
{
LLUUID mAuthorityID;
LLUUID mOwnerID;
LLUUID mGroupID;
SetItemOwnerAndGroup(const LLUUID& authority_id,
const LLUUID& owner_id,
const LLUUID& group_id) :
mAuthorityID(authority_id), mOwnerID(owner_id), mGroupID(group_id) {}
void operator()(LLInventoryItem* item) const
{
LLPermissions perm = item->getPermissions();
bool is_atomic = (LLAssetType::AT_OBJECT == item->getType()) ? false : true;
perm.setOwnerAndGroup(mAuthorityID, mOwnerID, mGroupID, is_atomic);
// If no owner id is set, this is equivalent to a deed action.
// Clear 'share with group'.
if (mOwnerID.isNull())
{
perm.setMaskGroup(PERM_NONE);
}
item->setPermissions(perm);
}
};
// This functor is used to unset the share with group, everyone perms, and
// for sale info for objects being sold through contents.
struct SetNotForSale
{
LLUUID mAgentID;
LLUUID mGroupID;
SetNotForSale(const LLUUID& agent_id,
const LLUUID& group_id) :
mAgentID(agent_id), mGroupID(group_id) {}
void operator()(LLInventoryItem* item) const
{
// Clear group & everyone permissions.
LLPermissions perm = item->getPermissions();
perm.setGroupBits(mAgentID, mGroupID, FALSE, PERM_MODIFY | PERM_MOVE | PERM_COPY);
perm.setEveryoneBits(mAgentID, mGroupID, FALSE, PERM_MOVE | PERM_COPY);
item->setPermissions(perm);
// Mark group & everyone permissions for overwrite on the next
// rez if it is an object.
if(LLAssetType::AT_OBJECT == item->getType())
{
U32 flags = item->getFlags();
flags |= LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_GROUP;
flags |= LLInventoryItem::II_FLAGS_OBJECT_PERM_OVERWRITE_EVERYONE;
item->setFlags(flags);
}
// Clear for sale info.
item->setSaleInfo(LLSaleInfo::DEFAULT);
}
};
typedef std::list<LLPointer<LLInventoryObject> > InventoryObjectList;
// These functions convert between structured data and an inventroy
// item, appropriate for serialization.
LLSD ll_create_sd_from_inventory_item(LLPointer<LLInventoryItem> item);
LLPointer<LLInventoryItem> ll_create_item_from_sd(const LLSD& sd_item);
//LLPointer<LLInventoryItem> ll_create_item_from_sd(const LLSD& sd_item);
LLSD ll_create_sd_from_inventory_category(LLPointer<LLInventoryCategory> cat);
LLPointer<LLInventoryCategory> ll_create_category_from_sd(const LLSD& sd_cat);

2
indra/llinventory/llsaleinfo.cpp
View File

@ -111,7 +111,7 @@ LLSD LLSaleInfo::asLLSD() const
return sd;
}
bool LLSaleInfo::fromLLSD(LLSD& sd, BOOL& has_perm_mask, U32& perm_mask)
bool LLSaleInfo::fromLLSD(const LLSD& sd, BOOL& has_perm_mask, U32& perm_mask)
{
const char *w;

2
indra/llinventory/llsaleinfo.h
View File

@ -98,7 +98,7 @@ public:
BOOL exportLegacyStream(std::ostream& output_stream) const;
LLSD asLLSD() const;
operator LLSD() const { return asLLSD(); }
bool fromLLSD(LLSD& sd, BOOL& has_perm_mask, U32& perm_mask);
bool fromLLSD(const LLSD& sd, BOOL& has_perm_mask, U32& perm_mask);
BOOL importLegacyStream(std::istream& input_stream, BOOL& has_perm_mask, U32& perm_mask);
LLXMLNode *exportFileXML() const;

2
indra/llprimitive/CMakeLists.txt
View File

@ -18,6 +18,7 @@ include_directories(
set(llprimitive_SOURCE_FILES
llmaterialtable.cpp
llprimitive.cpp
llprimtexturelist.cpp
lltextureanim.cpp
lltextureentry.cpp
lltreeparams.cpp
@ -31,6 +32,7 @@ set(llprimitive_HEADER_FILES
legacy_object_types.h
llmaterialtable.h
llprimitive.h
llprimtexturelist.h
lltextureanim.h
lltextureentry.h
lltreeparams.h

411
indra/llprimitive/llprimitive.cpp
View File

@ -44,6 +44,7 @@
#include "llstring.h"
#include "lldatapacker.h"
#include "llsdutil.h"
#include "llprimtexturelist.h"
/**
* exported constants
@ -112,6 +113,7 @@ const F32 FLEXIBLE_OBJECT_DEFAULT_LENGTH = 1.0f;
const BOOL FLEXIBLE_OBJECT_DEFAULT_USING_COLLISION_SPHERE = FALSE;
const BOOL FLEXIBLE_OBJECT_DEFAULT_RENDERING_COLLISION_SPHERE = FALSE;
const S32 MAX_FACE_BITS = 9;
const char *SCULPT_DEFAULT_TEXTURE = "be293869-d0d9-0a69-5989-ad27f1946fd4"; // old inverted texture: "7595d345-a24c-e7ef-f0bd-78793792133e";
@ -151,7 +153,8 @@ bool LLPrimitive::cleanupVolumeManager()
//===============================================================
LLPrimitive::LLPrimitive()
: mMiscFlags(0)
: mTextureList(),
mMiscFlags(0)
{
mPrimitiveCode = 0;
@ -168,20 +171,12 @@ LLPrimitive::LLPrimitive()
mAngularVelocity.setVec(0.f,0.f,0.f);
mScale.setVec(1.f,1.f,1.f);
mNumTEs = 0;
mTextureList = NULL;
}
//===============================================================
LLPrimitive::~LLPrimitive()
{
if (mTextureList)
{
delete [] mTextureList;
mTextureList = NULL;
}
clearTextureList();
// Cleanup handled by volume manager
if (mVolumep)
{
@ -190,6 +185,10 @@ LLPrimitive::~LLPrimitive()
mVolumep = NULL;
}
void LLPrimitive::clearTextureList()
{
}
//===============================================================
// static
LLPrimitive *LLPrimitive::createPrimitive(LLPCode p_code)
@ -213,15 +212,7 @@ LLPrimitive *LLPrimitive::createPrimitive(LLPCode p_code)
void LLPrimitive::init_primitive(LLPCode p_code)
{
LLMemType m1(LLMemType::MTYPE_PRIMITIVE);
if (mNumTEs)
{
if (mTextureList)
{
delete [] mTextureList;
}
mTextureList = new LLTextureEntry[mNumTEs];
}
clearTextureList();
mPrimitiveCode = p_code;
}
@ -231,342 +222,146 @@ void LLPrimitive::setPCode(const U8 p_code)
}
//===============================================================
const LLTextureEntry * LLPrimitive::getTE(const U8 te_num) const
LLTextureEntry* LLPrimitive::getTE(const U8 index) const
{
// if we're asking for a non-existent face, return null
if (mNumTEs && (te_num< mNumTEs))
{
return(&mTextureList[te_num]);
}
else
{
return(NULL);
}
return mTextureList.getTexture(index);
}
//===============================================================
void LLPrimitive::setNumTEs(const U8 num_tes)
{
if (num_tes == mNumTEs)
{
return;
}
// Right now, we don't try and preserve entries when the number of faces
// changes.
LLMemType m1(LLMemType::MTYPE_PRIMITIVE);
if (num_tes)
{
LLTextureEntry *new_tes;
new_tes = new LLTextureEntry[num_tes];
U32 i;
for (i = 0; i < num_tes; i++)
{
if (i < mNumTEs)
{
new_tes[i] = mTextureList[i];
}
else if (mNumTEs)
{
new_tes[i] = mTextureList[mNumTEs - 1];
}
else
{
new_tes[i] = LLTextureEntry();
}
}
delete[] mTextureList;
mTextureList = new_tes;
}
else
{
delete[] mTextureList;
mTextureList = NULL;
}
mNumTEs = num_tes;
mTextureList.setSize(num_tes);
}
//===============================================================
void LLPrimitive::setAllTETextures(const LLUUID &tex_id)
{
U8 i;
for (i = 0; i < mNumTEs; i++)
{
mTextureList[i].setID(tex_id);
}
mTextureList.setAllIDs(tex_id);
}
//===============================================================
void LLPrimitive::setTE(const U8 index, const LLTextureEntry &te)
void LLPrimitive::setTE(const U8 index, const LLTextureEntry& te)
{
mTextureList[index] = te;
mTextureList.copyTexture(index, te);
}
S32 LLPrimitive::setTETexture(const U8 te, const LLUUID &tex_id)
S32 LLPrimitive::setTETexture(const U8 index, const LLUUID &id)
{
// if we're asking for a non-existent face, return null
if (te >= mNumTEs)
{
llwarns << "setting non-existent te " << te << llendl
return 0;
}
return mTextureList[te].setID(tex_id);
return mTextureList.setID(index, id);
}
S32 LLPrimitive::setTEColor(const U8 te, const LLColor4 &color)
S32 LLPrimitive::setTEColor(const U8 index, const LLColor4 &color)
{
// if we're asking for a non-existent face, return null
if (te >= mNumTEs)
{
llwarns << "setting non-existent te " << te << llendl
return 0;
}
return mTextureList[te].setColor(color);
return mTextureList.setColor(index, color);
}
S32 LLPrimitive::setTEColor(const U8 te, const LLColor3 &color)
S32 LLPrimitive::setTEColor(const U8 index, const LLColor3 &color)
{
// if we're asking for a non-existent face, return null
if (te >= mNumTEs)
{
llwarns << "setting non-existent te " << te << llendl
return 0;
}
return mTextureList[te].setColor(color);
return mTextureList.setColor(index, color);
}
S32 LLPrimitive::setTEAlpha(const U8 te, const F32 alpha)
S32 LLPrimitive::setTEAlpha(const U8 index, const F32 alpha)
{
// if we're asking for a non-existent face, return null
if (te >= mNumTEs)
{
llwarns << "setting non-existent te " << te << llendl
return 0;
}
return mTextureList[te].setAlpha(alpha);
return mTextureList.setAlpha(index, alpha);
}
//===============================================================
S32 LLPrimitive::setTEScale(const U8 te, const F32 s, const F32 t)
S32 LLPrimitive::setTEScale(const U8 index, const F32 s, const F32 t)
{
// if we're asking for a non-existent face, return null
if (te >= mNumTEs)
{
llwarns << "Setting nonexistent face" << llendl;
return 0;
}
return mTextureList[te].setScale(s,t);
return mTextureList.setScale(index, s, t);
}
// BUG: slow - done this way because texture entries have some
// voodoo related to texture coords
S32 LLPrimitive::setTEScaleS(const U8 te, const F32 s)
S32 LLPrimitive::setTEScaleS(const U8 index, const F32 s)
{
if (te >= mNumTEs)
{
llwarns << "Setting nonexistent face" << llendl;
return 0;
}
F32 ignore, t;
mTextureList[te].getScale(&ignore, &t);
return mTextureList[te].setScale(s,t);
return mTextureList.setScaleS(index, s);
}
// BUG: slow - done this way because texture entries have some
// voodoo related to texture coords
S32 LLPrimitive::setTEScaleT(const U8 te, const F32 t)
S32 LLPrimitive::setTEScaleT(const U8 index, const F32 t)
{
if (te >= mNumTEs)
{
llwarns << "Setting nonexistent face" << llendl;
return 0;
}
F32 s, ignore;
mTextureList[te].getScale(&s, &ignore);
return mTextureList[te].setScale(s,t);
return mTextureList.setScaleT(index, t);
}
//===============================================================
S32 LLPrimitive::setTEOffset(const U8 te, const F32 s, const F32 t)
S32 LLPrimitive::setTEOffset(const U8 index, const F32 s, const F32 t)
{
// if we're asking for a non-existent face, return null
if (te >= mNumTEs)
{
llwarns << "Setting nonexistent face" << llendl;
return 0;
}
return mTextureList[te].setOffset(s,t);
return mTextureList.setOffset(index, s, t);
}
// BUG: slow - done this way because texture entries have some
// voodoo related to texture coords
S32 LLPrimitive::setTEOffsetS(const U8 te, const F32 s)
S32 LLPrimitive::setTEOffsetS(const U8 index, const F32 s)
{
if (te >= mNumTEs)
{
llwarns << "Setting nonexistent face" << llendl;
return 0;
}
F32 ignore, t;
mTextureList[te].getOffset(&ignore, &t);
return mTextureList[te].setOffset(s,t);
return mTextureList.setOffsetS(index, s);
}
// BUG: slow - done this way because texture entries have some
// voodoo related to texture coords
S32 LLPrimitive::setTEOffsetT(const U8 te, const F32 t)
S32 LLPrimitive::setTEOffsetT(const U8 index, const F32 t)
{
if (te >= mNumTEs)
{
llwarns << "Setting nonexistent face" << llendl;
return 0;
}
F32 s, ignore;
mTextureList[te].getOffset(&s, &ignore);
return mTextureList[te].setOffset(s,t);
return mTextureList.setOffsetT(index, t);
}
//===============================================================
S32 LLPrimitive::setTERotation(const U8 te, const F32 r)
S32 LLPrimitive::setTERotation(const U8 index, const F32 r)
{
// if we're asking for a non-existent face, return null
if (te >= mNumTEs)
{
llwarns << "Setting nonexistent face" << llendl;
return 0;
}
return mTextureList[te].setRotation(r);
return mTextureList.setRotation(index, r);
}
//===============================================================
S32 LLPrimitive::setTEBumpShinyFullbright(const U8 te, const U8 bump)
S32 LLPrimitive::setTEBumpShinyFullbright(const U8 index, const U8 bump)
{
// if we're asking for a non-existent face, return null
if (te >= mNumTEs)
{
llwarns << "setting non-existent te " << te << llendl
return 0;
}
return mTextureList[te].setBumpShinyFullbright( bump );
return mTextureList.setBumpShinyFullbright(index, bump);
}
S32 LLPrimitive::setTEMediaTexGen(const U8 te, const U8 media)
S32 LLPrimitive::setTEMediaTexGen(const U8 index, const U8 media)
{
// if we're asking for a non-existent face, return null
if (te >= mNumTEs)
{
llwarns << "setting non-existent te " << te << llendl
return 0;
}
return mTextureList[te].setMediaTexGen( media );
return mTextureList.setMediaTexGen(index, media);
}
S32 LLPrimitive::setTEBumpmap(const U8 te, const U8 bump)
S32 LLPrimitive::setTEBumpmap(const U8 index, const U8 bump)
{
// if we're asking for a non-existent face, return null
if (te >= mNumTEs)
{
llwarns << "setting non-existent te " << te << llendl
return 0;
}
return mTextureList[te].setBumpmap( bump );
return mTextureList.setBumpMap(index, bump);
}
S32 LLPrimitive::setTEBumpShiny(const U8 te, const U8 bump_shiny)
S32 LLPrimitive::setTEBumpShiny(const U8 index, const U8 bump_shiny)
{
// if we're asking for a non-existent face, return null
if (te >= mNumTEs)
{
llwarns << "setting non-existent te " << te << llendl
return 0;
}
return mTextureList[te].setBumpShiny( bump_shiny );
return mTextureList.setBumpShiny(index, bump_shiny);
}
S32 LLPrimitive::setTETexGen(const U8 te, const U8 texgen)
S32 LLPrimitive::setTETexGen(const U8 index, const U8 texgen)
{
// if we're asking for a non-existent face, return null
if (te >= mNumTEs)
{
llwarns << "setting non-existent te " << te << llendl
return 0;
}
return mTextureList[te].setTexGen( texgen );
return mTextureList.setTexGen(index, texgen);
}
S32 LLPrimitive::setTEShiny(const U8 te, const U8 shiny)
S32 LLPrimitive::setTEShiny(const U8 index, const U8 shiny)
{
// if we're asking for a non-existent face, return null
if (te >= mNumTEs)
{
llwarns << "setting non-existent te " << te << llendl
return 0;
}
return mTextureList[te].setShiny( shiny );
return mTextureList.setShiny(index, shiny);
}
S32 LLPrimitive::setTEFullbright(const U8 te, const U8 fullbright)
S32 LLPrimitive::setTEFullbright(const U8 index, const U8 fullbright)
{
// if we're asking for a non-existent face, return null
if (te >= mNumTEs)
{
llwarns << "setting non-existent te " << te << llendl
return 0;
}
return mTextureList[te].setFullbright( fullbright );
return mTextureList.setFullbright(index, fullbright);
}
S32 LLPrimitive::setTEMediaFlags(const U8 te, const U8 media_flags)
S32 LLPrimitive::setTEMediaFlags(const U8 index, const U8 media_flags)
{
// if we're asking for a non-existent face, return null
if (te >= mNumTEs)
{
llwarns << "setting non-existent te " << te << llendl
return 0;
}
return mTextureList[te].setMediaFlags( media_flags );
return mTextureList.setMediaFlags(index, media_flags);
}
S32 LLPrimitive::setTEGlow(const U8 te, const F32 glow)
S32 LLPrimitive::setTEGlow(const U8 index, const F32 glow)
{
// if we're asking for a non-existent face, return null
if (te >= mNumTEs)
{
llwarns << "setting non-existent te " << te << llendl
return 0;
}
return mTextureList[te].setGlow( glow );
return mTextureList.setGlow(index, glow);
}
@ -878,25 +673,18 @@ std::string LLPrimitive::pCodeToString(const LLPCode pcode)
void LLPrimitive::copyTEs(const LLPrimitive *primitivep)
{
U32 i;
if (primitivep->getNumTEs() != getNumTEs())
if (primitivep->getExpectedNumTEs() != getExpectedNumTEs())
{
llwarns << "Primitives don't have same number of TE's" << llendl;
llwarns << "Primitives don't have same expected number of TE's" << llendl;
}
U32 num_tes = llmin(primitivep->getExpectedNumTEs(), getExpectedNumTEs());
if (mTextureList.size() < getExpectedNumTEs())
{
mTextureList.setSize(getExpectedNumTEs());
}
U32 num_tes = llmin(primitivep->getNumTEs(), getNumTEs());
for (i = 0; i < num_tes; i++)
{
const LLTextureEntry *tep = primitivep->getTE(i);
F32 s, t;
setTETexture(i, tep->getID());
setTEColor(i, tep->getColor());
tep->getScale(&s, &t);
setTEScale(i, s, t);
tep->getOffset(&s, &t);
setTEOffset(i, s, t);
setTERotation(i, tep->getRotation());
setTEBumpShinyFullbright(i, tep->getBumpShinyFullbright());
setTEMediaTexGen(i, tep->getMediaTexGen());
setTEGlow(i, tep->getGlow());
mTextureList.copyTexture(i, *(primitivep->getTE(i)));
}
}
@ -962,12 +750,12 @@ BOOL LLPrimitive::setVolume(const LLVolumeParams &volume_params, const S32 detai
sVolumeManager->unrefVolume(mVolumep);
mVolumep = volumep;
U32 new_face_mask = mVolumep->mFaceMask;
U32 new_face_mask = mVolumep->mFaceMask;
if (old_face_mask != new_face_mask)
{
setNumTEs(mVolumep->getNumFaces());
}
}
return TRUE;
}
@ -984,50 +772,6 @@ BOOL LLPrimitive::setMaterial(U8 material)
}
}
void LLPrimitive::setTEArrays(const U8 size,
const LLUUID* image_ids,
const F32* scale_s,
const F32* scale_t)
{
S32 cur_size = size;
if (cur_size > getNumTEs())
{
llwarns << "Trying to set more TEs than exist!" << llendl;
cur_size = getNumTEs();
}
S32 i;
// Copy over image information
for (i = 0; i < cur_size; i++)
{
// This is very BAD!!!!!!
if (image_ids != NULL)
{
setTETexture(i,image_ids[i]);
}
if (scale_s && scale_t)
{
setTEScale(i, scale_s[i], scale_t[i]);
}
}
if (i < getNumTEs())
{
cur_size--;
for (i=i; i < getNumTEs(); i++) // the i=i removes a gcc warning
{
if (image_ids != NULL)
{
setTETexture(i, image_ids[cur_size]);
}
if (scale_s && scale_t)
{
setTEScale(i, scale_s[cur_size], scale_t[cur_size]);
}
}
}
}
const F32 LL_MAX_SCALE_S = 100.0f;
const F32 LL_MAX_SCALE_T = 100.0f;
S32 LLPrimitive::packTEField(U8 *cur_ptr, U8 *data_ptr, U8 data_size, U8 last_face_index, EMsgVariableType type) const
@ -1489,11 +1233,24 @@ S32 LLPrimitive::unpackTEMessage(LLDataPacker &dp)
return retval;
}
void LLPrimitive::setTextureList(LLTextureEntry *listp)
U8 LLPrimitive::getExpectedNumTEs() const
{
LLTextureEntry* old_texture_list = mTextureList;
mTextureList = listp;
delete[] old_texture_list;
U8 expected_face_count = 0;
if (mVolumep)
{
expected_face_count = mVolumep->getNumFaces();
}
return expected_face_count;
}
void LLPrimitive::copyTextureList(const LLPrimTextureList& other_list)
{
mTextureList.copy(other_list);
}
void LLPrimitive::takeTextureList(LLPrimTextureList& other_list)
{
mTextureList.take(other_list);
}
//============================================================================

24
indra/llprimitive/llprimitive.h
View File

@ -40,6 +40,7 @@
#include "llmemory.h"
#include "llvolume.h"
#include "lltextureentry.h"
#include "llprimtexturelist.h"
// Moved to stdtypes.h --JC
// typedef U8 LLPCode;
@ -295,6 +296,8 @@ public:
LLPrimitive();
virtual ~LLPrimitive();
void clearTextureList();
static LLPrimitive *createPrimitive(LLPCode p_code);
void init_primitive(LLPCode p_code);
@ -305,11 +308,11 @@ public:
// Modify texture entry properties
inline BOOL validTE(const U8 te_num) const;
const LLTextureEntry *getTE(const U8 te_num) const;
LLTextureEntry* getTE(const U8 te_num) const;
virtual void setNumTEs(const U8 num_tes);
virtual void setAllTETextures(const LLUUID &tex_id);
virtual void setTE(const U8 index, const LLTextureEntry &te);
virtual void setTE(const U8 index, const LLTextureEntry& te);
virtual S32 setTEColor(const U8 te, const LLColor4 &color);
virtual S32 setTEColor(const U8 te, const LLColor3 &color);
virtual S32 setTEAlpha(const U8 te, const F32 alpha);
@ -332,10 +335,6 @@ public:
virtual S32 setTEGlow(const U8 te, const F32 glow);
virtual BOOL setMaterial(const U8 material); // returns TRUE if material changed
void setTEArrays(const U8 size,
const LLUUID* image_ids,
const F32* scale_s,
const F32* scale_t);
void copyTEs(const LLPrimitive *primitive);
S32 packTEField(U8 *cur_ptr, U8 *data_ptr, U8 data_size, U8 last_face_index, EMsgVariableType type) const;
S32 unpackTEField(U8 *cur_ptr, U8 *buffer_end, U8 *data_ptr, U8 data_size, U8 face_count, EMsgVariableType type);
@ -383,14 +382,21 @@ public:
const LLVector3& getAngularVelocity() const { return mAngularVelocity; }
const LLVector3& getVelocity() const { return mVelocity; }
const LLVector3& getAcceleration() const { return mAcceleration; }
U8 getNumTEs() const { return mNumTEs; }
U8 getNumTEs() const { return mTextureList.size(); }
U8 getExpectedNumTEs() const;
U8 getMaterial() const { return mMaterial; }
void setVolumeType(const U8 code);
U8 getVolumeType();
void setTextureList(LLTextureEntry *listp);
// clears existing textures
// copies the contents of other_list into mEntryList
void copyTextureList(const LLPrimTextureList& other_list);
// clears existing textures
// takes the contents of other_list and clears other_list
void takeTextureList(LLPrimTextureList& other_list);
inline BOOL isAvatar() const;
inline BOOL isSittingAvatar() const;
@ -415,7 +421,7 @@ protected:
LLVector3 mAcceleration; // are we under constant acceleration?
LLVector3 mAngularVelocity; // angular velocity
LLPointer<LLVolume> mVolumep;
LLTextureEntry *mTextureList; // list of texture GUIDs, scales, offsets
LLPrimTextureList mTextureList; // list of texture GUIDs, scales, offsets
U8 mMaterial; // Material code
U8 mNumTEs; // # of faces on the primitve
U32 mMiscFlags; // home for misc bools

414
indra/llprimitive/llprimtexturelist.cpp Normal file
View File

@ -0,0 +1,414 @@
/**
* @file lltexturelist.cpp
* @brief LLPrimTextureList (virtual) base class
*
* $LicenseInfo:firstyear=2008&license=viewergpl$
*
* Copyright (c) 2008-2007, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlife.com/developers/opensource/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at http://secondlife.com/developers/opensource/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "linden_common.h"
#include "llprimtexturelist.h"
#include "lltextureentry.h"
#include "llmemtype.h"
// static
//int (TMyClass::*pt2Member)(float, char, char) = NULL; // C++
LLTextureEntry* (*LLPrimTextureList::sNewTextureEntryCallback)() = &(LLTextureEntry::newTextureEntry);
// static
void LLPrimTextureList::setNewTextureEntryCallback( LLTextureEntry* (*callback)() )
{
if (callback)
{
LLPrimTextureList::sNewTextureEntryCallback = callback;
}
else
{
LLPrimTextureList::sNewTextureEntryCallback = &(LLTextureEntry::newTextureEntry);
}
}
// static
// call this to get a new texture entry
LLTextureEntry* LLPrimTextureList::newTextureEntry()
{
return (*sNewTextureEntryCallback)();
}
LLPrimTextureList::LLPrimTextureList()
{
}
// virtual
LLPrimTextureList::~LLPrimTextureList()
{
clear();
}
void LLPrimTextureList::clear()
{
texture_list_t::iterator itr = mEntryList.begin();
while (itr != mEntryList.end())
{
delete (*itr);
(*itr) = NULL;
++itr;
}
mEntryList.clear();
}
// clears current entries
// copies contents of other_list
// this is somewhat expensive, so it must be called explicitly
void LLPrimTextureList::copy(const LLPrimTextureList& other_list)
{
// compare the sizes
S32 this_size = mEntryList.size();
S32 other_size = other_list.mEntryList.size();
if (this_size > other_size)
{
// remove the extra entries
for (S32 index = this_size; index > other_size; --index)
{
delete mEntryList[index-1];
}
mEntryList.resize(other_size);
this_size = other_size;
}
S32 index = 0;
// copy for the entries that already exist
for ( ; index < this_size; ++index)
{
delete mEntryList[index];
mEntryList[index] = other_list.getTexture(index)->newCopy();
}
// add new entires if needed
for ( ; index < other_size; ++index)
{
mEntryList.push_back( other_list.getTexture(index)->newCopy() );
}
}
// clears current copies
// takes contents of other_list
// clears other_list
void LLPrimTextureList::take(LLPrimTextureList& other_list)
{
clear();
mEntryList = other_list.mEntryList;
other_list.mEntryList.clear();
}
// virtual
// copies LLTextureEntry 'te'
// returns TEM_CHANGE_TEXTURE if successful, otherwise TEM_CHANGE_NONE
S32 LLPrimTextureList::copyTexture(const U8 index, const LLTextureEntry& te)
{
if (S32(index) >= mEntryList.size())
{
// TODO -- assert here
S32 current_size = mEntryList.size();
llerrs << "index = " << S32(index) << " current_size = " << current_size << llendl;
return TEM_CHANGE_NONE;
}
// we're changing an existing entry
llassert(mEntryList[index]);
delete (mEntryList[index]);
if (&te)
{
mEntryList[index] = te.newCopy();
}
else
{
mEntryList[index] = LLPrimTextureList::newTextureEntry();
}
return TEM_CHANGE_TEXTURE;
}
// virtual
// takes ownership of LLTextureEntry* 'te'
// returns TEM_CHANGE_TEXTURE if successful, otherwise TEM_CHANGE_NONE
// IMPORTANT! -- if you use this function you must check the return value
S32 LLPrimTextureList::takeTexture(const U8 index, LLTextureEntry* te)
{
if (S32(index) >= mEntryList.size())
{
return TEM_CHANGE_NONE;
}
// we're changing an existing entry
llassert(mEntryList[index]);
delete (mEntryList[index]);
mEntryList[index] = te;
return TEM_CHANGE_TEXTURE;
}
// returns pointer to texture at 'index' slot
LLTextureEntry* LLPrimTextureList::getTexture(const U8 index) const
{
if (index < mEntryList.size())
{
return mEntryList[index];
}
return NULL;
}
//virtual
//S32 setTE(const U8 index, const LLTextureEntry& te) = 0;
S32 LLPrimTextureList::setID(const U8 index, const LLUUID& id)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setID(id);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setColor(const U8 index, const LLColor3& color)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setColor(color);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setColor(const U8 index, const LLColor4& color)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setColor(color);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setAlpha(const U8 index, const F32 alpha)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setAlpha(alpha);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setScale(const U8 index, const F32 s, const F32 t)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setScale(s, t);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setScaleS(const U8 index, const F32 s)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setScaleS(s);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setScaleT(const U8 index, const F32 t)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setScaleT(t);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setOffset(const U8 index, const F32 s, const F32 t)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setOffset(s, t);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setOffsetS(const U8 index, const F32 s)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setOffsetS(s);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setOffsetT(const U8 index, const F32 t)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setOffsetT(t);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setRotation(const U8 index, const F32 r)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setRotation(r);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setBumpShinyFullbright(const U8 index, const U8 bump)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setBumpShinyFullbright(bump);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setMediaTexGen(const U8 index, const U8 media)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setMediaTexGen(media);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setBumpMap(const U8 index, const U8 bump)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setBumpmap(bump);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setBumpShiny(const U8 index, const U8 bump_shiny)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setBumpShiny(bump_shiny);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setTexGen(const U8 index, const U8 texgen)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setTexGen(texgen);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setShiny(const U8 index, const U8 shiny)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setShiny(shiny);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setFullbright(const U8 index, const U8 fullbright)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setFullbright(fullbright);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setMediaFlags(const U8 index, const U8 media_flags)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setMediaFlags(media_flags);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::setGlow(const U8 index, const F32 glow)
{
if (index < mEntryList.size())
{
return mEntryList[index]->setGlow(glow);
}
return TEM_CHANGE_NONE;
}
S32 LLPrimTextureList::size() const
{
return mEntryList.size();
}
// sets the size of the mEntryList container
void LLPrimTextureList::setSize(S32 new_size)
{
LLMemType m1(LLMemType::MTYPE_PRIMITIVE);
if (new_size < 0)
{
new_size = 0;
}
S32 current_size = mEntryList.size();
if (new_size > current_size)
{
mEntryList.resize(new_size);
for (S32 index = current_size; index < new_size; ++index)
{
LLTextureEntry* new_entry = LLPrimTextureList::newTextureEntry();
mEntryList[index] = new_entry;
}
}
else if (new_size < current_size)
{
for (S32 index = current_size-1; index >= new_size; --index)
{
delete mEntryList[index];
}
mEntryList.resize(new_size);
}
}
void LLPrimTextureList::setAllIDs(const LLUUID& id)
{
texture_list_t::iterator itr = mEntryList.begin();
while (itr != mEntryList.end())
{
(*itr)->setID(id);
++itr;
}
}

126
indra/llprimitive/llprimtexturelist.h Normal file
View File

@ -0,0 +1,126 @@
/**
* @file llprimtexturelist.h
* @brief LLPrimTextureList (virtual) base class
*
* $LicenseInfo:firstyear=2008&license=viewergpl$
*
* Copyright (c) 2008-2007, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlife.com/developers/opensource/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at http://secondlife.com/developers/opensource/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LLPRIMTEXTURELIST_H
#define LL_LLPRIMTEXTURELIST_H
#include <vector>
#include "lluuid.h"
#include "v3color.h"
#include "v4color.h"
class LLTextureEntry;
// this is a list of LLTextureEntry*'s because in practice the list's elements
// are of some derived class: LLFooTextureEntry
typedef std::vector<LLTextureEntry*> texture_list_t;
class LLPrimTextureList
{
public:
// the LLPrimTextureList needs to know what type of LLTextureEntry
// to generate when it needs a new one, so we may need to set a
// callback for generating it, (or else use the base class default:
// static LLPrimTextureEntry::newTextureEntry() )
//typedef LLTextureEntry* (__stdcall *NewTextureEntryFunction)();
//static NewTextureEntryFunction sNewTextureEntryCallback;
static LLTextureEntry* newTextureEntry();
static void setNewTextureEntryCallback( LLTextureEntry* (*callback)() );
static LLTextureEntry* (*sNewTextureEntryCallback)();
LLPrimTextureList();
virtual ~LLPrimTextureList();
void clear();
// clears current entries
// copies contents of other_list
// this is somewhat expensive, so it must be called explicitly
void copy(const LLPrimTextureList& other_list);
// clears current copies
// takes contents of other_list
// clears other_list
void take(LLPrimTextureList& other_list);
// copies LLTextureEntry 'te'
// returns TEM_CHANGE_TEXTURE if successful, otherwise TEM_CHANGE_NONE
S32 copyTexture(const U8 index, const LLTextureEntry& te);
// takes ownership of LLTextureEntry* 'te'
// returns TEM_CHANGE_TEXTURE if successful, otherwise TEM_CHANGE_NONE
// IMPORTANT! -- if you use this function you must check the return value
S32 takeTexture(const U8 index, LLTextureEntry* te);
// // copies contents of 'entry' and stores it in 'index' slot
// void copyTexture(const U8 index, const LLTextureEntry* entry);
// returns pointer to texture at 'index' slot
LLTextureEntry* getTexture(const U8 index) const;
S32 setID(const U8 index, const LLUUID& id);
S32 setColor(const U8 index, const LLColor3& color);
S32 setColor(const U8 index, const LLColor4& color);
S32 setAlpha(const U8 index, const F32 alpha);
S32 setScale(const U8 index, const F32 s, const F32 t);
S32 setScaleS(const U8 index, const F32 s);
S32 setScaleT(const U8 index, const F32 t);
S32 setOffset(const U8 index, const F32 s, const F32 t);
S32 setOffsetS(const U8 index, const F32 s);
S32 setOffsetT(const U8 index, const F32 t);
S32 setRotation(const U8 index, const F32 r);
S32 setBumpShinyFullbright(const U8 index, const U8 bump);
S32 setMediaTexGen(const U8 index, const U8 media);
S32 setBumpMap(const U8 index, const U8 bump);
S32 setBumpShiny(const U8 index, const U8 bump_shiny);
S32 setTexGen(const U8 index, const U8 texgen);
S32 setShiny(const U8 index, const U8 shiny);
S32 setFullbright(const U8 index, const U8 t);
S32 setMediaFlags(const U8 index, const U8 media_flags);
S32 setGlow(const U8 index, const F32 glow);
S32 size() const;
// void forceResize(S32 new_size);
void setSize(S32 new_size);
void setAllIDs(const LLUUID& id);
protected:
texture_list_t mEntryList;
private:
LLPrimTextureList(const LLPrimTextureList& other_list)
{
// private so that it can't be used
}
};
#endif

108
indra/llprimitive/lltextureentry.cpp
View File

@ -39,6 +39,12 @@ const U8 DEFAULT_BUMP_CODE = 0; // no bump or shininess
const LLTextureEntry LLTextureEntry::null;
// static
LLTextureEntry* LLTextureEntry::newTextureEntry()
{
return new LLTextureEntry();
}
//===============================================================
LLTextureEntry::LLTextureEntry()
{
@ -136,20 +142,23 @@ bool LLTextureEntry::operator==(const LLTextureEntry &rhs) const
LLSD LLTextureEntry::asLLSD() const
{
LLSD sd;
asLLSD(sd);
return sd;
}
sd["imageid"] = getID();
sd["colors"] = ll_sd_from_color4(getColor());
void LLTextureEntry::asLLSD(LLSD& sd) const
{
sd["imageid"] = mID;
sd["colors"] = ll_sd_from_color4(mColor);
sd["scales"] = mScaleS;
sd["scalet"] = mScaleT;
sd["offsets"] = mOffsetS;
sd["offsett"] = mOffsetT;
sd["imagerot"] = getRotation();
sd["imagerot"] = mRotation;
sd["bump"] = getBumpShiny();
sd["fullbright"] = getFullbright();
sd["media_flags"] = getMediaTexGen();
sd["glow"] = getGlow();
return sd;
sd["media_flags"] = mMediaFlags;
sd["glow"] = mGlow;
}
bool LLTextureEntry::fromLLSD(LLSD& sd)
@ -208,6 +217,19 @@ fail:
return false;
}
// virtual
// override this method for each derived class
LLTextureEntry* LLTextureEntry::newBlank() const
{
return new LLTextureEntry();
}
// virtual
LLTextureEntry* LLTextureEntry::newCopy() const
{
return new LLTextureEntry(*this);
}
S32 LLTextureEntry::setID(const LLUUID &tex_id)
{
if (mID != tex_id)
@ -215,7 +237,7 @@ S32 LLTextureEntry::setID(const LLUUID &tex_id)
mID = tex_id;
return TEM_CHANGE_TEXTURE;
}
return 0;
return TEM_CHANGE_NONE;
}
S32 LLTextureEntry::setScale(F32 s, F32 t)
@ -233,6 +255,28 @@ S32 LLTextureEntry::setScale(F32 s, F32 t)
return retval;
}
S32 LLTextureEntry::setScaleS(F32 s)
{
S32 retval = TEM_CHANGE_NONE;
if (mScaleS != s)
{
mScaleS = s;
retval = TEM_CHANGE_TEXTURE;
}
return retval;
}
S32 LLTextureEntry::setScaleT(F32 t)
{
S32 retval = TEM_CHANGE_NONE;
if (mScaleT != t)
{
mScaleT = t;
retval = TEM_CHANGE_TEXTURE;
}
return retval;
}
S32 LLTextureEntry::setColor(const LLColor4 &color)
{
if (mColor != color)
@ -240,7 +284,7 @@ S32 LLTextureEntry::setColor(const LLColor4 &color)
mColor = color;
return TEM_CHANGE_COLOR;
}
return 0;
return TEM_CHANGE_NONE;
}
S32 LLTextureEntry::setColor(const LLColor3 &color)
@ -251,7 +295,7 @@ S32 LLTextureEntry::setColor(const LLColor3 &color)
mColor.setVec(color);
return TEM_CHANGE_COLOR;
}
return 0;
return TEM_CHANGE_NONE;
}
S32 LLTextureEntry::setAlpha(const F32 alpha)
@ -261,7 +305,7 @@ S32 LLTextureEntry::setAlpha(const F32 alpha)
mColor.mV[VW] = alpha;
return TEM_CHANGE_COLOR;
}
return 0;
return TEM_CHANGE_NONE;
}
S32 LLTextureEntry::setOffset(F32 s, F32 t)
@ -279,6 +323,28 @@ S32 LLTextureEntry::setOffset(F32 s, F32 t)
return retval;
}
S32 LLTextureEntry::setOffsetS(F32 s)
{
S32 retval = 0;
if (mOffsetS != s)
{
mOffsetS = s;
retval = TEM_CHANGE_TEXTURE;
}
return retval;
}
S32 LLTextureEntry::setOffsetT(F32 t)
{
S32 retval = 0;
if (mOffsetT != t)
{
mOffsetT = t;
retval = TEM_CHANGE_TEXTURE;
}
return retval;
}
S32 LLTextureEntry::setRotation(F32 theta)
{
if (mRotation != theta)
@ -286,7 +352,7 @@ S32 LLTextureEntry::setRotation(F32 theta)
mRotation = theta;
return TEM_CHANGE_TEXTURE;
}
return 0;
return TEM_CHANGE_NONE;
}
S32 LLTextureEntry::setBumpShinyFullbright(U8 bump)
@ -296,7 +362,7 @@ S32 LLTextureEntry::setBumpShinyFullbright(U8 bump)
mBump = bump;
return TEM_CHANGE_TEXTURE;
}
return 0;
return TEM_CHANGE_NONE;
}
S32 LLTextureEntry::setMediaTexGen(U8 media)
@ -306,7 +372,7 @@ S32 LLTextureEntry::setMediaTexGen(U8 media)
mMediaFlags = media;
return TEM_CHANGE_TEXTURE;
}
return 0;
return TEM_CHANGE_NONE;
}
S32 LLTextureEntry::setBumpmap(U8 bump)
@ -318,7 +384,7 @@ S32 LLTextureEntry::setBumpmap(U8 bump)
mBump |= bump;
return TEM_CHANGE_TEXTURE;
}
return 0;
return TEM_CHANGE_NONE;
}
S32 LLTextureEntry::setFullbright(U8 fullbright)
@ -330,7 +396,7 @@ S32 LLTextureEntry::setFullbright(U8 fullbright)
mBump |= fullbright << TEM_FULLBRIGHT_SHIFT;
return TEM_CHANGE_TEXTURE;
}
return 0;
return TEM_CHANGE_NONE;
}
S32 LLTextureEntry::setShiny(U8 shiny)
@ -342,7 +408,7 @@ S32 LLTextureEntry::setShiny(U8 shiny)
mBump |= shiny << TEM_SHINY_SHIFT;
return TEM_CHANGE_TEXTURE;
}
return 0;
return TEM_CHANGE_NONE;
}
S32 LLTextureEntry::setBumpShiny(U8 bump_shiny)
@ -354,7 +420,7 @@ S32 LLTextureEntry::setBumpShiny(U8 bump_shiny)
mBump |= bump_shiny;
return TEM_CHANGE_TEXTURE;
}
return 0;
return TEM_CHANGE_NONE;
}
S32 LLTextureEntry::setMediaFlags(U8 media_flags)
@ -366,7 +432,7 @@ S32 LLTextureEntry::setMediaFlags(U8 media_flags)
mMediaFlags |= media_flags;
return TEM_CHANGE_TEXTURE;
}
return 0;
return TEM_CHANGE_NONE;
}
S32 LLTextureEntry::setTexGen(U8 tex_gen)
@ -378,7 +444,7 @@ S32 LLTextureEntry::setTexGen(U8 tex_gen)
mMediaFlags |= tex_gen;
return TEM_CHANGE_TEXTURE;
}
return 0;
return TEM_CHANGE_NONE;
}
S32 LLTextureEntry::setGlow(F32 glow)
@ -388,5 +454,5 @@ S32 LLTextureEntry::setGlow(F32 glow)
mGlow = glow;
return TEM_CHANGE_TEXTURE;
}
return 0;
return TEM_CHANGE_NONE;
}

14
indra/llprimitive/lltextureentry.h
View File

@ -37,6 +37,7 @@
#include "v4color.h"
#include "llsd.h"
const S32 TEM_CHANGE_NONE = 0x0;
const S32 TEM_CHANGE_COLOR = 0x1;
const S32 TEM_CHANGE_TEXTURE = 0x2;
const S32 TEM_INVALID = 0x4;
@ -68,6 +69,7 @@ const S32 TEM_TEX_GEN_SHIFT = 1;
class LLTextureEntry
{
public:
static LLTextureEntry* newTextureEntry();
typedef enum e_texgen
{
@ -82,15 +84,19 @@ public:
LLTextureEntry(const LLTextureEntry &rhs);
LLTextureEntry &operator=(const LLTextureEntry &rhs);
~LLTextureEntry();
virtual ~LLTextureEntry();
bool operator==(const LLTextureEntry &rhs) const;
bool operator!=(const LLTextureEntry &rhs) const;
LLSD asLLSD() const;
void asLLSD(LLSD& sd) const;
operator LLSD() const { return asLLSD(); }
bool fromLLSD(LLSD& sd);
virtual LLTextureEntry* newBlank() const;
virtual LLTextureEntry* newCopy() const;
void init(const LLUUID& tex_id, F32 scale_s, F32 scale_t, F32 offset_s, F32 offset_t, F32 rotation, U8 bump);
// These return a TEM_ flag from above to indicate if something changed.
@ -99,7 +105,11 @@ public:
S32 setColor(const LLColor3 &color);
S32 setAlpha(const F32 alpha);
S32 setScale(F32 s, F32 t);
S32 setScaleS(F32 s);
S32 setScaleT(F32 t);
S32 setOffset(F32 s, F32 t);
S32 setOffsetS(F32 s);
S32 setOffsetT(F32 t);
S32 setRotation(F32 theta);
S32 setBumpmap(U8 bump);
@ -113,7 +123,7 @@ public:
S32 setMediaTexGen(U8 media);
S32 setGlow(F32 glow);
const LLUUID &getID() const { return mID; }
virtual const LLUUID &getID() const { return mID; }
const LLColor4 &getColor() const { return mColor; }
void getScale(F32 *s, F32 *t) const { *s = mScaleS; *t = mScaleT; }
void getOffset(F32 *s, F32 *t) const { *s = mOffsetS; *t = mOffsetT; }