218 lines
6.6 KiB
C++
218 lines
6.6 KiB
C++
/**
|
|
* @file llvoavatar.h
|
|
* @brief Declaration of LLVOAvatar class which is a derivation fo
|
|
* LLViewerObject
|
|
*
|
|
* $LicenseInfo:firstyear=2001&license=viewergpl$
|
|
*
|
|
* Copyright (c) 2001-2009, 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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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 LLVOAVATAR_DEFINES_H
|
|
#define LLVOAVATAR_DEFINES_H
|
|
|
|
#include <vector>
|
|
#include "llwearable.h"
|
|
#include "llviewerjoint.h"
|
|
|
|
namespace LLVOAvatarDefines
|
|
{
|
|
|
|
extern const S32 SCRATCH_TEX_WIDTH;
|
|
extern const S32 SCRATCH_TEX_HEIGHT;
|
|
extern const S32 IMPOSTOR_PERIOD;
|
|
|
|
//--------------------------------------------------------------------
|
|
// texture entry assignment
|
|
//--------------------------------------------------------------------
|
|
enum ETextureIndex
|
|
{
|
|
TEX_HEAD_BODYPAINT = 0,
|
|
TEX_UPPER_SHIRT,
|
|
TEX_LOWER_PANTS,
|
|
TEX_EYES_IRIS,
|
|
TEX_HAIR,
|
|
TEX_UPPER_BODYPAINT,
|
|
TEX_LOWER_BODYPAINT,
|
|
TEX_LOWER_SHOES,
|
|
TEX_HEAD_BAKED, // Pre-composited
|
|
TEX_UPPER_BAKED, // Pre-composited
|
|
TEX_LOWER_BAKED, // Pre-composited
|
|
TEX_EYES_BAKED, // Pre-composited
|
|
TEX_LOWER_SOCKS,
|
|
TEX_UPPER_JACKET,
|
|
TEX_LOWER_JACKET,
|
|
TEX_UPPER_GLOVES,
|
|
TEX_UPPER_UNDERSHIRT,
|
|
TEX_LOWER_UNDERPANTS,
|
|
TEX_SKIRT,
|
|
TEX_SKIRT_BAKED, // Pre-composited
|
|
TEX_HAIR_BAKED, // Pre-composited
|
|
TEX_LOWER_ALPHA,
|
|
TEX_UPPER_ALPHA,
|
|
TEX_HEAD_ALPHA,
|
|
TEX_EYES_ALPHA,
|
|
TEX_HAIR_ALPHA,
|
|
TEX_HEAD_TATTOO,
|
|
TEX_UPPER_TATTOO,
|
|
TEX_LOWER_TATTOO,
|
|
TEX_NUM_INDICES
|
|
};
|
|
|
|
typedef std::vector<ETextureIndex> texture_vec_t;
|
|
|
|
enum EBakedTextureIndex
|
|
{
|
|
BAKED_HEAD = 0,
|
|
BAKED_UPPER,
|
|
BAKED_LOWER,
|
|
BAKED_EYES,
|
|
BAKED_SKIRT,
|
|
BAKED_HAIR,
|
|
BAKED_NUM_INDICES
|
|
};
|
|
typedef std::vector<EBakedTextureIndex> bakedtexture_vec_t;
|
|
|
|
// Reference IDs for each mesh. Used as indices for vector of joints
|
|
enum EMeshIndex
|
|
{
|
|
MESH_ID_HAIR = 0,
|
|
MESH_ID_HEAD,
|
|
MESH_ID_EYELASH,
|
|
MESH_ID_UPPER_BODY,
|
|
MESH_ID_LOWER_BODY,
|
|
MESH_ID_EYEBALL_LEFT,
|
|
MESH_ID_EYEBALL_RIGHT,
|
|
MESH_ID_SKIRT,
|
|
MESH_ID_NUM_INDICES
|
|
};
|
|
typedef std::vector<EMeshIndex> mesh_vec_t;
|
|
|
|
typedef std::vector<EWearableType> wearables_vec_t;
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// Convenience Functions
|
|
//--------------------------------------------------------------------------------
|
|
|
|
// Convert from baked texture to associated texture; e.g. BAKED_HEAD -> TEX_HEAD_BAKED
|
|
ETextureIndex getTextureIndex(EBakedTextureIndex t);
|
|
|
|
|
|
|
|
//------------------------------------------------------------------------
|
|
// LLVOAvatarDictionary
|
|
//
|
|
// Holds dictionary static entries for textures, baked textures, meshes, etc.; i.e.
|
|
// information that is common to all avatars.
|
|
//
|
|
// This holds const data - it is initialized once and the contents never change after that.
|
|
//------------------------------------------------------------------------
|
|
class LLVOAvatarDictionary : public LLSingleton<LLVOAvatarDictionary>
|
|
{
|
|
public:
|
|
LLVOAvatarDictionary();
|
|
virtual ~LLVOAvatarDictionary();
|
|
|
|
struct TextureDictionaryEntry
|
|
{
|
|
TextureDictionaryEntry(const std::string &name,
|
|
bool is_local_texture,
|
|
EBakedTextureIndex baked_texture_index = BAKED_NUM_INDICES,
|
|
const std::string &default_image_name = "",
|
|
EWearableType wearable_type = WT_INVALID);
|
|
const std::string mName;
|
|
const std::string mDefaultImageName;
|
|
const EWearableType mWearableType;
|
|
// It's either a local texture xor baked
|
|
BOOL mIsLocalTexture;
|
|
BOOL mIsBakedTexture;
|
|
// If it's a local texture, it may be used by a baked texture
|
|
BOOL mIsUsedByBakedTexture;
|
|
EBakedTextureIndex mBakedTextureIndex;
|
|
};
|
|
|
|
struct MeshDictionaryEntry
|
|
{
|
|
MeshDictionaryEntry(EBakedTextureIndex baked_index,
|
|
const std::string &name,
|
|
U8 level,
|
|
LLViewerJoint::PickName pick);
|
|
const std::string mName; // names of mesh types as they are used in avatar_lad.xml
|
|
// Levels of Detail for each mesh. Must match levels of detail present in avatar_lad.xml
|
|
// Otherwise meshes will be unable to be found, or levels of detail will be ignored
|
|
const U8 mLOD;
|
|
const EBakedTextureIndex mBakedID;
|
|
const LLViewerJoint::PickName mPickName;
|
|
};
|
|
|
|
struct BakedDictionaryEntry
|
|
{
|
|
BakedDictionaryEntry(ETextureIndex tex_index,
|
|
const std::string &name,
|
|
U32 num_local_textures, ... );
|
|
const ETextureIndex mTextureIndex;
|
|
const std::string mName;
|
|
texture_vec_t mLocalTextures;
|
|
};
|
|
|
|
struct WearableDictionaryEntry
|
|
{
|
|
WearableDictionaryEntry(const std::string &hash_name,
|
|
U32 num_wearables, ... );
|
|
const LLUUID mHashID;
|
|
wearables_vec_t mWearablesVec;
|
|
};
|
|
|
|
typedef std::map<EBakedTextureIndex, BakedDictionaryEntry*> baked_map_t;
|
|
typedef std::map<ETextureIndex, TextureDictionaryEntry*> texture_map_t;
|
|
typedef std::map<EMeshIndex, MeshDictionaryEntry*> mesh_map_t;
|
|
typedef std::map<EBakedTextureIndex, WearableDictionaryEntry*> wearable_map_t;
|
|
|
|
const MeshDictionaryEntry *getMesh(EMeshIndex index) const;
|
|
const BakedDictionaryEntry *getBakedTexture(EBakedTextureIndex index) const;
|
|
const TextureDictionaryEntry *getTexture(ETextureIndex index) const;
|
|
const WearableDictionaryEntry *getWearable(EBakedTextureIndex index) const;
|
|
|
|
const texture_map_t &getTextures() const { return mTextureMap; }
|
|
const baked_map_t &getBakedTextures() const { return mBakedTextureMap; }
|
|
const mesh_map_t &getMeshes() const { return mMeshMap; }
|
|
const wearable_map_t &getWearables() const { return mWearableMap; }
|
|
|
|
private:
|
|
void initData();
|
|
void createAssociations();
|
|
|
|
texture_map_t mTextureMap;
|
|
baked_map_t mBakedTextureMap;
|
|
mesh_map_t mMeshMap;
|
|
wearable_map_t mWearableMap;
|
|
|
|
}; // End LLVOAvatarDictionary
|
|
|
|
} // End namespace LLVOAvatarDefines
|
|
|
|
#endif
|