path: root/indra/llprimitive/lltextureentry.h

/** 
 * @file lltextureentry.h
 * @brief LLTextureEntry base class
 *
 * $LicenseInfo:firstyear=2001&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, 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$
 */

#ifndef LL_LLTEXTUREENTRY_H
#define LL_LLTEXTUREENTRY_H

#include "lluuid.h"
#include "v4color.h"
#include "llsd.h"
#include "llmaterialid.h"
#include "llmaterial.h"
#include "llgltfmaterial.h"

// These bits are used while unpacking TEM messages to tell which aspects of
// the texture entry changed.
const S32 TEM_CHANGE_NONE = 0x0;
const S32 TEM_CHANGE_COLOR = 0x1;
const S32 TEM_CHANGE_TEXTURE = 0x2;
const S32 TEM_CHANGE_MEDIA = 0x4;
const S32 TEM_INVALID = 0x8;

const S32 TEM_BUMPMAP_COUNT = 32;

// The Bump Shiny Fullbright values are bits in an eight bit field:
// +----------+
// | SSFBBBBB | S = Shiny, F = Fullbright, B = Bumpmap
// | 76543210 |
// +----------+
const S32 TEM_BUMP_MASK 		= 0x1f; // 5 bits
const S32 TEM_FULLBRIGHT_MASK 	= 0x01; // 1 bit
const S32 TEM_SHINY_MASK 		= 0x03; // 2 bits
const S32 TEM_BUMP_SHINY_MASK 	= (0xc0 | 0x1f);
const S32 TEM_FULLBRIGHT_SHIFT 	= 5;
const S32 TEM_SHINY_SHIFT 		= 6;

// The Media Tex Gen values are bits in a bit field:
// +----------+
// | .....TTM | M = Media Flags (web page), T = LLTextureEntry::eTexGen, . = unused
// | 76543210 |
// +----------+
const S32 TEM_MEDIA_MASK		= 0x01;
const S32 TEM_TEX_GEN_MASK		= 0x06;
const S32 TEM_TEX_GEN_SHIFT		= 1;

// forward declarations
class LLMediaEntry;

class LLTextureEntry
{
public:	
	static LLTextureEntry* newTextureEntry();

	typedef enum e_texgen
	{
		TEX_GEN_DEFAULT			= 0x00,
		TEX_GEN_PLANAR			= 0x02,
		TEX_GEN_SPHERICAL		= 0x04,
		TEX_GEN_CYLINDRICAL		= 0x06
	} eTexGen;
    
    
    typedef enum e_renderable_target {
        RT_DISABLED = 0x00,
        RT_MIRROR = 0x02
    } eRenderableTarget;

	LLTextureEntry();
	LLTextureEntry(const LLUUID& tex_id);
	LLTextureEntry(const LLTextureEntry &rhs);

	LLTextureEntry &operator=(const LLTextureEntry &rhs);
    virtual ~LLTextureEntry();

	bool operator==(const LLTextureEntry &rhs) const;
	bool operator!=(const LLTextureEntry &rhs) const;
	
	// Added to allow use with std::map
	//
	bool operator <(const LLTextureEntry &rhs) const;

	LLSD asLLSD() const;
	void asLLSD(LLSD& sd) const;
	operator LLSD() const { return asLLSD(); }
	bool fromLLSD(const 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);

	bool hasPendingMaterialUpdate() const { return mMaterialUpdatePending; }
	bool isSelected() const { return mSelected; }
	bool setSelected(bool sel) { bool prev_sel = mSelected; mSelected = sel; return prev_sel; }

	// These return a TEM_ flag from above to indicate if something changed.
	S32  setID (const LLUUID &tex_id);
	S32  setColor(const LLColor4 &color);
	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);
	S32  setFullbright(U8 bump);
	S32  setShiny(U8 bump);
	S32  setBumpShiny(U8 bump);
 	S32  setBumpShinyFullbright(U8 bump);

	S32  setMediaFlags(U8 media_flags);
	S32	 setTexGen(U8 texGen);
	S32  setMediaTexGen(U8 media);
    S32  setGlow(F32 glow);
	S32  setMaterialID(const LLMaterialID& pMaterialID);
	S32  setMaterialParams(const LLMaterialPtr pMaterialParams);
    
    S32  setRenderableTarget(eRenderableTarget target);
    
	virtual const LLUUID &getID() const { return mID; }
	const LLColor4 &getColor() const { return mColor; }
    const F32 getAlpha() const { return mColor.mV[VALPHA]; }

	void getScale(F32 *s, F32 *t) const { *s = mScaleS; *t = mScaleT; }
	F32  getScaleS() const { return mScaleS; }
	F32  getScaleT() const { return mScaleT; }

	void getOffset(F32 *s, F32 *t) const { *s = mOffsetS; *t = mOffsetT; }
	F32  getOffsetS() const { return mOffsetS; }
	F32  getOffsetT() const { return mOffsetT; }

	F32  getRotation() const { return mRotation; }
	void getRotation(F32 *theta) const { *theta = mRotation; }

	U8	 getBumpmap() const { return mBump & TEM_BUMP_MASK; }
	U8	 getFullbright() const { return (mBump>>TEM_FULLBRIGHT_SHIFT) & TEM_FULLBRIGHT_MASK; }
    eRenderableTarget getRenderableTarget() const { return mRenderableTarget; }
	U8	 getShiny() const { return (mBump>>TEM_SHINY_SHIFT) & TEM_SHINY_MASK; }
	U8	 getBumpShiny() const { return mBump & TEM_BUMP_SHINY_MASK; }
 	U8	 getBumpShinyFullbright() const { return mBump; }

	U8	 getMediaFlags() const { return mMediaFlags & TEM_MEDIA_MASK; }
	LLTextureEntry::e_texgen	 getTexGen() const	{ return LLTextureEntry::e_texgen(mMediaFlags & TEM_TEX_GEN_MASK); }
	U8	 getMediaTexGen() const { return mMediaFlags; }
    F32  getGlow() const { return mGlow; }
	const LLMaterialID& getMaterialID() const { return mMaterialID; };
	const LLMaterialPtr getMaterialParams() const { return mMaterial; };

    // *NOTE: it is possible for hasMedia() to return true, but getMediaData() to return NULL.
    // CONVERSELY, it is also possible for hasMedia() to return false, but getMediaData()
    // to NOT return NULL.  
	bool hasMedia() const { return (bool)(mMediaFlags & MF_HAS_MEDIA); } 
	LLMediaEntry* getMediaData() const { return mMediaEntry; }

    // Completely change the media data on this texture entry.
    void setMediaData(const LLMediaEntry &media_entry);
	// Returns true if media data was updated, false if it was cleared
	bool updateMediaData(const LLSD& media_data);
    // Clears media data, and sets the media flags bit to 0
    void clearMediaData();
    // Merges the given LLSD of media fields with this media entry.
    // Only those fields that are set that match the keys in
    // LLMediaEntry will be affected.  If no fields are set or if
    // the LLSD is undefined, this is a no-op.
    void mergeIntoMediaData(const LLSD& media_fields);

    // Takes a media version string (an empty string or a previously-returned string)
    // and returns a "touched" string, touched by agent_id
    static std::string touchMediaVersionString(const std::string &in_version, const LLUUID &agent_id);
    // Given a media version string, return the version
    static U32 getVersionFromMediaVersionString(const std::string &version_string);
    // Given a media version string, return the UUID of the agent
    static LLUUID getAgentIDFromMediaVersionString(const std::string &version_string);
	// Return whether or not the given string is actually a media version
	static bool isMediaVersionString(const std::string &version_string);
	
	// Media flags
	enum { MF_NONE = 0x0, MF_HAS_MEDIA = 0x1 };

    // GLTF asset
    void setGLTFMaterial(LLGLTFMaterial* material, bool local_origin = true);
    LLGLTFMaterial* getGLTFMaterial() const { return mGLTFMaterial; }

    // GLTF override
    LLGLTFMaterial* getGLTFMaterialOverride() const { return mGLTFMaterialOverrides; }
    S32 setGLTFMaterialOverride(LLGLTFMaterial* mat);
    // Clear most overrides so the render material better matches the material
    // ID (preserve transforms). If the overrides become passthrough, set the
    // overrides to nullptr.
    S32 setBaseMaterial();

    // GLTF render material
    // nuanced behavior here -- if there is no render material, fall back to getGLTFMaterial, but ONLY for the getter, not the setter
    LLGLTFMaterial* getGLTFRenderMaterial() const;
    S32 setGLTFRenderMaterial(LLGLTFMaterial* mat);

public:
	F32                 mScaleS;                // S, T offset
	F32                 mScaleT;                // S, T offset
	F32                 mOffsetS;               // S, T offset
	F32                 mOffsetT;               // S, T offset
	F32                 mRotation;              // anti-clockwise rotation in rad about the bottom left corner

	static const LLTextureEntry null;

	// LLSD key defines
	static const char* OBJECT_ID_KEY;
	static const char* OBJECT_MEDIA_DATA_KEY;
    static const char* MEDIA_VERSION_KEY;
	static const char* TEXTURE_INDEX_KEY;
	static const char* TEXTURE_MEDIA_DATA_KEY;

protected:
	bool                mSelected;
	LLUUID				mID;					// Texture GUID
	LLColor4			mColor;
	U8					mBump;					// Bump map, shiny, and fullbright
	U8					mMediaFlags;			// replace with web page, movie, etc.
    eRenderableTarget   mRenderableTarget;
	F32                 mGlow;
	bool                mMaterialUpdatePending;
	LLMaterialID        mMaterialID;
	LLMaterialPtr		mMaterial;
    
    // Reference to GLTF material asset state
    // On the viewer, this should be the same LLGLTFMaterial instance that exists in LLGLTFMaterialList
    LLPointer<LLGLTFMaterial> mGLTFMaterial;  

    // GLTF material parameter overrides -- the viewer will use this data to override material parameters
    // set by the asset and store the results in mRenderGLTFMaterial
    LLPointer<LLGLTFMaterial> mGLTFMaterialOverrides;

    // GLTF material to use for rendering -- will always be an LLFetchedGLTFMaterial
    LLPointer<LLGLTFMaterial> mGLTFRenderMaterial; 

	// Note the media data is not sent via the same message structure as the rest of the TE
	LLMediaEntry*		mMediaEntry;			// The media data for the face

	// NOTE: when adding new data to this class, in addition to adding it to the serializers asLLSD/fromLLSD and the
	// message packers (e.g. LLPrimitive::packTEMessage) you must also implement its copy in LLPrimitive::copyTEs()

	
};

#endif