807 lines
31 KiB
C++
807 lines
31 KiB
C++
/**
|
|
* @file fspanelface.h
|
|
* @brief Consolidated materials/texture panel in the tools floater
|
|
*
|
|
* $LicenseInfo:firstyear=2001&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2010, Linden Research, Inc.
|
|
* Copyright (C) 2024, Zi Ree@Second Life
|
|
*
|
|
* 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 FS_FSPANELFACE_H
|
|
#define FS_FSPANELFACE_H
|
|
|
|
#include "v4color.h"
|
|
#include "llpanel.h"
|
|
#include "llgltfmaterial.h"
|
|
#include "llmaterial.h"
|
|
#include "llmaterialmgr.h"
|
|
#include "lltextureentry.h"
|
|
#include "llselectmgr.h"
|
|
|
|
#include <memory>
|
|
|
|
class LLButton;
|
|
class LLCheckBoxCtrl;
|
|
class LLColorSwatchCtrl;
|
|
class LLComboBox;
|
|
class LLInventoryItem;
|
|
class LLLineEditor;
|
|
class LLRadioGroup;
|
|
class LLSpinCtrl;
|
|
class LLTextBox;
|
|
class LLTextureCtrl;
|
|
class LLUICtrl;
|
|
class LLViewerObject;
|
|
class LLFloater;
|
|
class LLMaterialID;
|
|
class LLMediaCtrl;
|
|
class LLMenuButton;
|
|
|
|
class PBRPickerAgentListener;
|
|
class PBRPickerObjectListener;
|
|
|
|
class LLTabContainer;
|
|
|
|
// Represents an edit for use in replicating the op across one or more materials in the selection set.
|
|
//
|
|
// The apply function optionally performs the edit which it implements
|
|
// as a functor taking Data that calls member func MaterialFunc taking SetValueType
|
|
// on an instance of the LLMaterial class.
|
|
//
|
|
// boost who?
|
|
//
|
|
template<
|
|
typename DataType,
|
|
typename SetValueType,
|
|
void (LLMaterial::*MaterialEditFunc)(SetValueType data) >
|
|
class FSMaterialEditFunctor
|
|
{
|
|
public:
|
|
FSMaterialEditFunctor(const DataType& data) : _data(data) {}
|
|
virtual ~FSMaterialEditFunctor() {}
|
|
virtual void apply(LLMaterialPtr& material) { (material->*(MaterialEditFunc))(_data); }
|
|
DataType _data;
|
|
};
|
|
|
|
template<
|
|
typename DataType,
|
|
DataType (LLMaterial::*MaterialGetFunc)() >
|
|
class FSMaterialGetFunctor
|
|
{
|
|
public:
|
|
FSMaterialGetFunctor() {}
|
|
virtual DataType get(LLMaterialPtr& material) { return (material->*(MaterialGetFunc)); }
|
|
};
|
|
|
|
template<
|
|
typename DataType,
|
|
DataType (LLTextureEntry::*TEGetFunc)() >
|
|
class FSTEGetFunctor
|
|
{
|
|
public:
|
|
FSTEGetFunctor() {}
|
|
virtual DataType get(LLTextureEntry* entry) { return (entry*(TEGetFunc)); }
|
|
};
|
|
|
|
//
|
|
// main class
|
|
//
|
|
|
|
class FSPanelFace : public LLPanel
|
|
{
|
|
public:
|
|
FSPanelFace();
|
|
virtual ~FSPanelFace();
|
|
|
|
virtual bool postBuild();
|
|
|
|
void refresh();
|
|
void refreshMedia();
|
|
void unloadMedia();
|
|
void changePrecision(S32 decimal_precision); // <FS:CR> Adjustable decimal precision
|
|
|
|
static void onMaterialOverrideReceived(const LLUUID& object_id, S32 side);
|
|
|
|
/*virtual*/ void onVisibilityChange(bool new_visibility);
|
|
/*virtual*/ void draw();
|
|
|
|
LLMaterialPtr createDefaultMaterial(LLMaterialPtr current_material);
|
|
|
|
LLRender::eTexIndex getTextureChannelToEdit();
|
|
LLRender::eTexIndex getTextureDropChannel();
|
|
|
|
LLGLTFMaterial::TextureInfo getPBRDropChannel();
|
|
|
|
protected:
|
|
void navigateToTitleMedia(const std::string url);
|
|
bool selectedMediaEditable();
|
|
void clearMediaSettings();
|
|
void updateMediaSettings();
|
|
void updateMediaTitle();
|
|
|
|
void getState();
|
|
|
|
void sendTexture(); // applies and sends texture
|
|
void sendTextureInfo(); // applies and sends texture scale, offset, etc.
|
|
void sendColor(); // applies and sends color
|
|
void sendAlpha(); // applies and sends transparency
|
|
void sendBump(U32 bumpiness); // applies and sends bump map
|
|
void sendTexGen(); // applies and sends bump map
|
|
void sendShiny(U32 shininess); // applies and sends shininess
|
|
void sendFullbright(); // applies and sends full bright
|
|
void sendGlow();
|
|
void alignTextureLayer();
|
|
|
|
void updateCopyTexButton();
|
|
|
|
//
|
|
// UI Callbacks
|
|
//
|
|
|
|
// common controls and parameters for Blinn-Phong and PBR
|
|
void onCopyFaces(); // <FS> Extended copy & paste buttons
|
|
void onPasteFaces();
|
|
void onCommitGlow();
|
|
void onCommitRepeatsPerMeter();
|
|
|
|
// Blinn-Phong alpha parameters
|
|
void onCommitAlpha();
|
|
void onCommitAlphaMode();
|
|
void onCommitMaterialMaskCutoff();
|
|
void onCommitFullbright();
|
|
|
|
// Blinn-Phong texture transforms and controls
|
|
void onCommitTexGen();
|
|
void onCommitPlanarAlign();
|
|
void onCommitBump();
|
|
void onCommitShiny();
|
|
void onCommitTextureScaleX();
|
|
void onCommitTextureScaleY();
|
|
void onCommitTextureOffsetX();
|
|
void onCommitTextureOffsetY();
|
|
void onCommitTextureRot();
|
|
void onCommitMaterialBumpyScaleX();
|
|
void onCommitMaterialBumpyScaleY();
|
|
void onCommitMaterialBumpyOffsetX();
|
|
void onCommitMaterialBumpyOffsetY();
|
|
void onCommitMaterialBumpyRot();
|
|
void onCommitMaterialShinyScaleX();
|
|
void onCommitMaterialShinyScaleY();
|
|
void onCommitMaterialShinyOffsetX();
|
|
void onCommitMaterialShinyOffsetY();
|
|
void onCommitMaterialShinyRot();
|
|
void onCommitMaterialGloss();
|
|
void onCommitMaterialEnv();
|
|
|
|
// Blinn-Phong Diffuse tint color swatch
|
|
void onCommitColor();
|
|
void onCancelColor();
|
|
void onSelectColor();
|
|
|
|
// Blinn-Phong Diffuse texture swatch
|
|
void onCommitTexture(const LLUICtrl* ctrl, const LLSD& data);
|
|
void onCancelTexture();
|
|
bool onDragTexture(LLInventoryItem* item); // this function is to return true if the drag should succeed.
|
|
void onCloseTexturePicker(const LLSD& data);
|
|
|
|
// Blinn-Phong Normal texture swatch
|
|
void onCommitNormalTexture(const LLUICtrl* ctrl, const LLSD& data);
|
|
void onCancelNormalTexture();
|
|
|
|
// Blinn-Phong Specular texture swatch
|
|
void onCommitSpecularTexture(const LLUICtrl* ctrl, const LLSD& data);
|
|
void onCancelSpecularTexture();
|
|
|
|
// Blinn-Phong Specular tint color swatch
|
|
void onCommitShinyColor();
|
|
void onCancelShinyColor();
|
|
void onSelectShinyColor();
|
|
|
|
// Texture alignment and maps synchronization
|
|
void onClickAutoFix();
|
|
void onAlignTexture();
|
|
void onClickMapsSync();
|
|
|
|
/*
|
|
* Checks whether the selected texture from the LLFloaterTexturePicker can be applied to the currently selected object.
|
|
* If agent selects texture which is not allowed to be applied for the currently selected object,
|
|
* all controls of the floater texture picker which allow to apply the texture will be disabled.
|
|
*/
|
|
void onTextureSelectionChanged(const std::string& which_control);
|
|
|
|
// Media
|
|
void onClickBtnEditMedia();
|
|
void onClickBtnDeleteMedia();
|
|
void onClickBtnAddMedia();
|
|
|
|
void alignMaterialsProperties();
|
|
|
|
//
|
|
// PBR
|
|
//
|
|
|
|
// PBR Material
|
|
void onCommitPbr();
|
|
void onCancelPbr();
|
|
void onSelectPbr();
|
|
bool onDragPbr(LLInventoryItem* item); // this function is to return true if the drag should succeed.
|
|
|
|
void onPbrSelectionChanged(LLInventoryItem* itemp);
|
|
void onClickBtnSavePBR();
|
|
|
|
void updatePBROverrideDisplay();
|
|
|
|
// PBR texture maps
|
|
void onCommitPbr(const LLUICtrl* pbr_ctrl);
|
|
void onCancelPbr(const LLUICtrl* pbr_ctrl);
|
|
void onSelectPbr(const LLUICtrl* pbr_ctrl);
|
|
|
|
void getGLTFMaterial(LLGLTFMaterial* mat);
|
|
|
|
//
|
|
// other
|
|
//
|
|
|
|
bool deleteMediaConfirm(const LLSD& notification, const LLSD& response);
|
|
bool multipleFacesSelectedConfirm(const LLSD& notification, const LLSD& response);
|
|
|
|
// Make UI reflect state of currently selected material (refresh)
|
|
// and UI mode (e.g. editing normal map v diffuse map)
|
|
//
|
|
// @param force_set_values forces spinners to set value even if they are focused
|
|
void updateUI(bool force_set_values = false);
|
|
|
|
// Convenience func to determine if all faces in selection have
|
|
// identical planar texgen settings during edits
|
|
//
|
|
bool isIdenticalPlanarTexgen();
|
|
|
|
// Callback funcs for individual controls
|
|
//
|
|
static void syncRepeatX(FSPanelFace* self, F32 scaleU);
|
|
static void syncRepeatY(FSPanelFace* self, F32 scaleV);
|
|
static void syncOffsetX(FSPanelFace* self, F32 offsetU);
|
|
static void syncOffsetY(FSPanelFace* self, F32 offsetV);
|
|
static void syncMaterialRot(FSPanelFace* self, F32 rot, int te = -1);
|
|
|
|
// unify all GLTF spinners with no switching around required -Zi
|
|
void onCommitGLTFUVSpinner(const LLUICtrl* ctrl, const LLSD& user_data);
|
|
|
|
void onClickBtnSelectSameTexture(const LLUICtrl* ctrl, const LLSD& user_data); // Find all faces with same texture
|
|
void onShowFindAllButton(LLUICtrl* ctrl, const LLSD& user_data); // Find all faces with same texture
|
|
void onHideFindAllButton(LLUICtrl* ctrl, const LLSD& user_data); // Find all faces with same texture
|
|
|
|
public: // needs to be accessible to selection manager
|
|
void onCopyColor(); // records all selected faces
|
|
void onPasteColor(); // to specific face
|
|
void onPasteColor(LLViewerObject* objectp, S32 te); // to specific face
|
|
void onCopyTexture();
|
|
void onPasteTexture();
|
|
void onPasteTexture(LLViewerObject* objectp, S32 te);
|
|
|
|
protected:
|
|
//
|
|
// Constant definitions for tabs and combo boxes
|
|
// Must match the commbobox definitions in panel_tools_texture.xml // Not anymore -Zi
|
|
//
|
|
static constexpr S32 MATMEDIA_MATERIAL = 0; // Material
|
|
static constexpr S32 MATMEDIA_PBR = 1; // PBR
|
|
static constexpr S32 MATMEDIA_MEDIA = 2; // Media
|
|
|
|
static constexpr S32 MATTYPE_DIFFUSE = 0; // Diffuse material texture
|
|
static constexpr S32 MATTYPE_NORMAL = 1; // Normal map
|
|
static constexpr S32 MATTYPE_SPECULAR = 2; // Specular map
|
|
|
|
static constexpr S32 BUMPY_TEXTURE = 18; // use supplied normal map (index of "Use Texture" in combo box)
|
|
static constexpr S32 SHINY_TEXTURE = 4; // use supplied specular map (index of "Use Texture" in combo box)
|
|
|
|
static constexpr S32 PBRTYPE_RENDER_MATERIAL_ID = 0; // Render Material ID
|
|
static constexpr S32 PBRTYPE_BASE_COLOR = 1; // PBR Base Color
|
|
static constexpr S32 PBRTYPE_METALLIC_ROUGHNESS = 2; // PBR Metallic
|
|
static constexpr S32 PBRTYPE_EMISSIVE = 3; // PBR Emissive
|
|
static constexpr S32 PBRTYPE_NORMAL = 4; // PBR Normal
|
|
static constexpr S32 PBRTYPE_COUNT = 5; // number of PBR map types
|
|
|
|
public:
|
|
// public because ... functors? -Zi
|
|
void onCommitFlip(const LLSD& user_data);
|
|
|
|
// Blinn-Phong texture transforms and controls
|
|
// public because ... functors? -Zi
|
|
LLSpinCtrl* mCtrlTexScaleU;
|
|
LLSpinCtrl* mCtrlTexScaleV;
|
|
LLSpinCtrl* mCtrlBumpyScaleU;
|
|
LLSpinCtrl* mCtrlBumpyScaleV;
|
|
LLSpinCtrl* mCtrlShinyScaleU;
|
|
LLSpinCtrl* mCtrlShinyScaleV;
|
|
LLSpinCtrl* mCtrlTexOffsetU;
|
|
LLSpinCtrl* mCtrlTexOffsetV;
|
|
LLSpinCtrl* mCtrlBumpyOffsetU;
|
|
LLSpinCtrl* mCtrlBumpyOffsetV;
|
|
LLSpinCtrl* mCtrlShinyOffsetU;
|
|
LLSpinCtrl* mCtrlShinyOffsetV;
|
|
LLSpinCtrl* mCtrlTexRot;
|
|
LLSpinCtrl* mCtrlBumpyRot;
|
|
LLSpinCtrl* mCtrlShinyRot;
|
|
|
|
// Blinn-Phong texture transforms and controls
|
|
// public to give functors access -Zi
|
|
LLComboBox* mComboTexGen;
|
|
LLCheckBoxCtrl* mCheckPlanarAlign;
|
|
|
|
// Tab controls
|
|
// public to give functors access -Zi
|
|
LLTabContainer* mTabsMatChannel;
|
|
void onMatTabChange();
|
|
|
|
private:
|
|
bool isAlpha() { return mIsAlpha; }
|
|
|
|
// Update visibility of controls to match current UI mode
|
|
// (e.g. materials vs media editing)
|
|
//
|
|
// Do NOT call updateUI from within this function.
|
|
//
|
|
void updateVisibility(LLViewerObject* objectp = nullptr);
|
|
|
|
// Convenience funcs to keep the visual flack to a minimum
|
|
//
|
|
LLUUID getCurrentNormalMap();
|
|
LLUUID getCurrentSpecularMap();
|
|
U32 getCurrentShininess();
|
|
U32 getCurrentBumpiness();
|
|
U8 getCurrentDiffuseAlphaMode();
|
|
U8 getCurrentAlphaMaskCutoff();
|
|
U8 getCurrentEnvIntensity();
|
|
U8 getCurrentGlossiness();
|
|
F32 getCurrentBumpyRot();
|
|
F32 getCurrentBumpyScaleU();
|
|
F32 getCurrentBumpyScaleV();
|
|
F32 getCurrentBumpyOffsetU();
|
|
F32 getCurrentBumpyOffsetV();
|
|
F32 getCurrentShinyRot();
|
|
F32 getCurrentShinyScaleU();
|
|
F32 getCurrentShinyScaleV();
|
|
F32 getCurrentShinyOffsetU();
|
|
F32 getCurrentShinyOffsetV();
|
|
|
|
// <FS:Zi> map tab states to various values
|
|
// TODO: should be done with tab-change signals and flags, really
|
|
S32 getCurrentMaterialType() const;
|
|
S32 getCurrentMatChannel() const;
|
|
S32 getCurrentPBRChannel() const;
|
|
void selectMaterialType(S32 material_type);
|
|
void selectMatChannel(S32 mat_channel);
|
|
void selectPBRChannel(S32 pbr_channel);
|
|
|
|
F32 getCurrentTextureRot();
|
|
F32 getCurrentTextureScaleU();
|
|
F32 getCurrentTextureScaleV();
|
|
F32 getCurrentTextureOffsetU();
|
|
F32 getCurrentTextureOffsetV();
|
|
|
|
//
|
|
// Build tool controls
|
|
//
|
|
|
|
// private Tab controls
|
|
LLTabContainer* mTabsPBRMatMedia;
|
|
LLTabContainer* mTabsPBRChannel;
|
|
|
|
// common controls and parameters for Blinn-Phong and PBR
|
|
LLButton* mBtnCopyFaces;
|
|
LLButton* mBtnPasteFaces;
|
|
LLSpinCtrl* mCtrlGlow;
|
|
LLSpinCtrl* mCtrlRpt;
|
|
|
|
// Blinn-Phong alpha parameters
|
|
LLSpinCtrl* mCtrlColorTransp; // transparency = 1 - alpha
|
|
LLView* mColorTransPercent;
|
|
LLTextBox* mLabelAlphaMode;
|
|
LLComboBox* mComboAlphaMode;
|
|
LLSpinCtrl* mCtrlMaskCutoff;
|
|
LLCheckBoxCtrl* mCheckFullbright;
|
|
|
|
// private Blinn-Phong texture transforms and controls
|
|
LLView* mLabelTexGen;
|
|
LLView* mLabelBumpiness;
|
|
LLComboBox* mComboBumpiness;
|
|
LLView* mLabelShininess;
|
|
LLComboBox* mComboShininess;
|
|
// others are above in the public section
|
|
LLSpinCtrl* mCtrlGlossiness;
|
|
LLSpinCtrl* mCtrlEnvironment;
|
|
|
|
// Blinn-Phong Diffuse tint color swatch
|
|
LLColorSwatchCtrl* mColorSwatch;
|
|
|
|
// Blinn-Phong Diffuse texture swatch
|
|
LLTextureCtrl* mTextureCtrl;
|
|
|
|
// Blinn-Phong Normal texture swatch
|
|
LLTextureCtrl* mBumpyTextureCtrl;
|
|
|
|
// Blinn-Phong Specular texture swatch
|
|
LLTextureCtrl* mShinyTextureCtrl;
|
|
|
|
// Blinn-Phong Specular tint color swatch
|
|
LLColorSwatchCtrl* mShinyColorSwatch;
|
|
|
|
// Texture alignment and maps synchronization
|
|
LLButton* mBtnAlignMedia;
|
|
LLButton* mBtnAlignTextures;
|
|
LLCheckBoxCtrl* mCheckSyncMaterials;
|
|
|
|
// Media
|
|
LLButton* mBtnDeleteMedia;
|
|
LLButton* mBtnAddMedia;
|
|
LLMediaCtrl* mTitleMedia;
|
|
LLTextBox* mTitleMediaText;
|
|
|
|
// PBR
|
|
LLTextureCtrl* mMaterialCtrlPBR;
|
|
LLColorSwatchCtrl* mBaseTintPBR;
|
|
LLTextureCtrl* mBaseTexturePBR;
|
|
LLTextureCtrl* mNormalTexturePBR;
|
|
LLTextureCtrl* mORMTexturePBR;
|
|
LLTextureCtrl* mEmissiveTexturePBR;
|
|
LLColorSwatchCtrl* mEmissiveTintPBR;
|
|
LLCheckBoxCtrl* mCheckDoubleSidedPBR;
|
|
LLSpinCtrl* mAlphaPBR;
|
|
LLTextBox* mLabelAlphaModePBR;
|
|
LLComboBox* mAlphaModePBR;
|
|
LLSpinCtrl* mMaskCutoffPBR;
|
|
LLSpinCtrl* mMetallicFactorPBR;
|
|
LLSpinCtrl* mRoughnessFactorPBR;
|
|
LLButton* mBtnSavePBR;
|
|
|
|
struct
|
|
{
|
|
std::array<LLUUID, LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT> mMap;
|
|
LLColor4 mBaseColorTint;
|
|
F32 mMetallic;
|
|
F32 mRoughness;
|
|
LLColor4 mEmissiveTint;
|
|
LLGLTFMaterial::AlphaMode mAlphaMode;
|
|
F32 mAlphaCutoff;
|
|
bool mDoubleSided;
|
|
} mPBRBaseMaterialParams;
|
|
|
|
// map PBR material map types to glTF material types
|
|
LLGLTFMaterial::TextureInfo mPBRChannelToTextureInfo[PBRTYPE_COUNT] =
|
|
{
|
|
LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT, // PBRTYPE_RENDER_MATERIAL_ID
|
|
LLGLTFMaterial::GLTF_TEXTURE_INFO_BASE_COLOR, // PBRTYPE_BASE_COLOR
|
|
LLGLTFMaterial::GLTF_TEXTURE_INFO_METALLIC_ROUGHNESS, // PBRTYPE_METALLIC_ROUGHNESS
|
|
LLGLTFMaterial::GLTF_TEXTURE_INFO_EMISSIVE, // PBRTYPE_EMISSIVE
|
|
LLGLTFMaterial::GLTF_TEXTURE_INFO_NORMAL // PBRTYPE_NORMAL
|
|
};
|
|
|
|
// Dirty flags - taken from llmaterialeditor.cpp ... LL please put this in a .h! -Zi
|
|
U32 mUnsavedChanges; // flags to indicate individual changed parameters
|
|
|
|
// Hey look everyone, a type-safe alternative to copy and paste! :)
|
|
//
|
|
|
|
// Update material parameters by applying 'edit_func' to selected TEs
|
|
//
|
|
template<
|
|
typename DataType,
|
|
typename SetValueType,
|
|
void (LLMaterial::*MaterialEditFunc)(SetValueType data) >
|
|
static void edit(FSPanelFace* p, DataType data, int te = -1, const LLUUID &only_for_object_id = LLUUID())
|
|
{
|
|
FSMaterialEditFunctor< DataType, SetValueType, MaterialEditFunc > edit(data);
|
|
struct LLSelectedTEEditMaterial : public LLSelectedTEMaterialFunctor
|
|
{
|
|
LLSelectedTEEditMaterial(FSPanelFace* panel, FSMaterialEditFunctor< DataType, SetValueType, MaterialEditFunc >* editp, const LLUUID &only_for_object_id) : _panel(panel), _edit(editp), _only_for_object_id(only_for_object_id) {}
|
|
virtual ~LLSelectedTEEditMaterial() {};
|
|
virtual LLMaterialPtr apply(LLViewerObject* object, S32 face, LLTextureEntry* tep, LLMaterialPtr& current_material)
|
|
{
|
|
if (_edit && (_only_for_object_id.isNull() || _only_for_object_id == object->getID()))
|
|
{
|
|
LLMaterialPtr new_material = _panel->createDefaultMaterial(current_material);
|
|
llassert_always(new_material);
|
|
|
|
// Determine correct alpha mode for current diffuse texture
|
|
// (i.e. does it have an alpha channel that makes alpha mode useful)
|
|
//
|
|
// _panel->isAlpha() "lies" when one face has alpha and the rest do not (NORSPEC-329)
|
|
// need to get per-face answer to this question for sane alpha mode retention on updates.
|
|
//
|
|
bool is_alpha_face = object->isImageAlphaBlended(face);
|
|
|
|
// need to keep this original answer for valid comparisons in logic below
|
|
//
|
|
U8 original_default_alpha_mode = is_alpha_face ? LLMaterial::DIFFUSE_ALPHA_MODE_BLEND : LLMaterial::DIFFUSE_ALPHA_MODE_NONE;
|
|
|
|
U8 default_alpha_mode = original_default_alpha_mode;
|
|
|
|
if (!current_material.isNull())
|
|
{
|
|
default_alpha_mode = current_material->getDiffuseAlphaMode();
|
|
}
|
|
|
|
// Insure we don't inherit the default of blend by accident...
|
|
// this will be stomped by a legit request to change the alpha mode by the apply() below
|
|
//
|
|
new_material->setDiffuseAlphaMode(default_alpha_mode);
|
|
|
|
// Do "It"!
|
|
//
|
|
_edit->apply(new_material);
|
|
|
|
U32 new_alpha_mode = new_material->getDiffuseAlphaMode();
|
|
LLUUID new_normal_map_id = new_material->getNormalID();
|
|
LLUUID new_spec_map_id = new_material->getSpecularID();
|
|
|
|
if ((new_alpha_mode == LLMaterial::DIFFUSE_ALPHA_MODE_BLEND) && !is_alpha_face)
|
|
{
|
|
new_alpha_mode = LLMaterial::DIFFUSE_ALPHA_MODE_NONE;
|
|
new_material->setDiffuseAlphaMode(LLMaterial::DIFFUSE_ALPHA_MODE_NONE);
|
|
}
|
|
|
|
bool is_default_blend_mode = (new_alpha_mode == original_default_alpha_mode);
|
|
bool is_need_material = !is_default_blend_mode || !new_normal_map_id.isNull() || !new_spec_map_id.isNull();
|
|
|
|
if (!is_need_material)
|
|
{
|
|
LL_DEBUGS("Materials") << "Removing material from object " << object->getID() << " face " << face << LL_ENDL;
|
|
LLMaterialMgr::getInstance()->remove(object->getID(),face);
|
|
new_material = NULL;
|
|
}
|
|
else
|
|
{
|
|
LL_DEBUGS("Materials") << "Putting material on object " << object->getID() << " face " << face << ", material: " << new_material->asLLSD() << LL_ENDL;
|
|
LLMaterialMgr::getInstance()->put(object->getID(),face,*new_material);
|
|
}
|
|
|
|
object->setTEMaterialParams(face, new_material);
|
|
return new_material;
|
|
}
|
|
return NULL;
|
|
}
|
|
FSMaterialEditFunctor< DataType, SetValueType, MaterialEditFunc >* _edit;
|
|
FSPanelFace *_panel;
|
|
const LLUUID & _only_for_object_id;
|
|
} editor(p, &edit, only_for_object_id);
|
|
LLSelectMgr::getInstance()->selectionSetMaterialParams(&editor, te);
|
|
}
|
|
|
|
template<
|
|
typename DataType,
|
|
typename ReturnType,
|
|
ReturnType (LLMaterial::* const MaterialGetFunc)() const >
|
|
static void getTEMaterialValue(DataType& data_to_return, bool& identical,DataType default_value, bool has_tolerance = false, DataType tolerance = DataType())
|
|
{
|
|
DataType data_value = default_value;
|
|
struct GetTEMaterialVal : public LLSelectedTEGetFunctor<DataType>
|
|
{
|
|
GetTEMaterialVal(DataType default_value) : _default(default_value) {}
|
|
virtual ~GetTEMaterialVal() {}
|
|
|
|
DataType get(LLViewerObject* object, S32 face)
|
|
{
|
|
DataType ret = _default;
|
|
LLMaterialPtr material_ptr;
|
|
LLTextureEntry* tep = object ? object->getTE(face) : NULL;
|
|
if (tep)
|
|
{
|
|
material_ptr = tep->getMaterialParams();
|
|
if (!material_ptr.isNull())
|
|
{
|
|
ret = (material_ptr->*(MaterialGetFunc))();
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
DataType _default;
|
|
} GetFunc(default_value);
|
|
identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &GetFunc, data_value, has_tolerance, tolerance);
|
|
data_to_return = data_value;
|
|
}
|
|
|
|
template<
|
|
typename DataType,
|
|
typename ReturnType, // some kids just have to different...
|
|
ReturnType (LLTextureEntry::* const TEGetFunc)() const >
|
|
static void getTEValue(DataType& data_to_return, bool& identical, DataType default_value, bool has_tolerance = false, DataType tolerance = DataType())
|
|
{
|
|
DataType data_value = default_value;
|
|
struct GetTEVal : public LLSelectedTEGetFunctor<DataType>
|
|
{
|
|
GetTEVal(DataType default_value) : _default(default_value) {}
|
|
virtual ~GetTEVal() {}
|
|
|
|
DataType get(LLViewerObject* object, S32 face) {
|
|
LLTextureEntry* tep = object ? object->getTE(face) : NULL;
|
|
return tep ? ((tep->*(TEGetFunc))()) : _default;
|
|
}
|
|
DataType _default;
|
|
} GetTEValFunc(default_value);
|
|
identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &GetTEValFunc, data_value, has_tolerance, tolerance );
|
|
data_to_return = data_value;
|
|
}
|
|
|
|
// Update vis and enabling of specific subsets of controls based on material params
|
|
// (e.g. hide the spec controls if no spec texture is applied)
|
|
//
|
|
void updateShinyControls(bool is_setting_texture = false, bool mess_with_combobox = false);
|
|
void updateBumpyControls(bool is_setting_texture = false, bool mess_with_combobox = false);
|
|
void updateAlphaControls();
|
|
void updateUIGLTF(LLViewerObject* objectp, bool& has_pbr_material, bool& has_faces_without_pbr, bool force_set_values);
|
|
|
|
void updateSelectedGLTFMaterials(std::function<void(LLGLTFMaterial*)> func);
|
|
void updateGLTFTextureTransform(float value, U32 pbr_type, std::function<void(LLGLTFMaterial::TextureTransform*)> edit);
|
|
|
|
void setMaterialOverridesFromSelection();
|
|
|
|
bool mIsAlpha;
|
|
|
|
LLSD mClipboardParams;
|
|
|
|
LLSD mMediaSettings;
|
|
bool mNeedMediaTitle;
|
|
|
|
class Selection
|
|
{
|
|
public:
|
|
void connect();
|
|
|
|
// Returns true if the selected objects or sides have changed since
|
|
// this was last called, and no object update is pending
|
|
bool update();
|
|
|
|
// Prevents update() returning true until the provided object is
|
|
// updated. Necessary to prevent controls updating when the mouse is
|
|
// held down.
|
|
void setDirty() { mChanged = true; };
|
|
|
|
// Callbacks
|
|
void onSelectionChanged() { mNeedsSelectionCheck = true; }
|
|
void onSelectedObjectUpdated(const LLUUID &object_id, S32 side);
|
|
|
|
protected:
|
|
bool compareSelection();
|
|
|
|
bool mChanged = false;
|
|
|
|
boost::signals2::scoped_connection mSelectConnection;
|
|
bool mNeedsSelectionCheck = true;
|
|
S32 mSelectedObjectCount = 0;
|
|
S32 mSelectedTECount = 0;
|
|
LLUUID mSelectedObjectID;
|
|
S32 mLastSelectedSide = -1;
|
|
};
|
|
|
|
static Selection sMaterialOverrideSelection;
|
|
|
|
std::unique_ptr<PBRPickerAgentListener> mAgentInventoryListener;
|
|
std::unique_ptr<PBRPickerObjectListener> mVOInventoryListener;
|
|
|
|
public:
|
|
#if defined(FS_DEF_GET_MAT_STATE)
|
|
#undef FS_DEF_GET_MAT_STATE
|
|
#endif
|
|
|
|
#if defined(FS_DEF_GET_TE_STATE)
|
|
#undef FS_DEF_GET_TE_STATE
|
|
#endif
|
|
|
|
#if defined(FS_DEF_EDIT_MAT_STATE)
|
|
FS_DEF_EDIT_MAT_STATE
|
|
#endif
|
|
|
|
// Accessors for selected TE material state
|
|
//
|
|
#define FS_DEF_GET_MAT_STATE(DataType,ReturnType,MaterialMemberFunc,DefaultValue,HasTolerance,Tolerance) \
|
|
static void MaterialMemberFunc(DataType& data, bool& identical, bool has_tolerance = HasTolerance, DataType tolerance = Tolerance) \
|
|
{ \
|
|
getTEMaterialValue< DataType, ReturnType, &LLMaterial::MaterialMemberFunc >(data, identical, DefaultValue, has_tolerance, tolerance); \
|
|
}
|
|
|
|
// Mutators for selected TE material
|
|
//
|
|
#define FS_DEF_EDIT_MAT_STATE(DataType,ReturnType,MaterialMemberFunc) \
|
|
static void MaterialMemberFunc(FSPanelFace* p, DataType data, int te = -1, const LLUUID &only_for_object_id = LLUUID()) \
|
|
{ \
|
|
edit< DataType, ReturnType, &LLMaterial::MaterialMemberFunc >(p, data, te, only_for_object_id); \
|
|
}
|
|
|
|
// Accessors for selected TE state proper (legacy settings etc)
|
|
//
|
|
#define FS_DEF_GET_TE_STATE(DataType,ReturnType,TexEntryMemberFunc,DefaultValue,HasTolerance,Tolerance) \
|
|
static void TexEntryMemberFunc(DataType& data, bool& identical, bool has_tolerance = HasTolerance, DataType tolerance = Tolerance) \
|
|
{ \
|
|
getTEValue< DataType, ReturnType, &LLTextureEntry::TexEntryMemberFunc >(data, identical, DefaultValue, has_tolerance, tolerance); \
|
|
}
|
|
|
|
class LLSelectedTEMaterial
|
|
{
|
|
public:
|
|
static void getCurrent(LLMaterialPtr& material_ptr, bool& identical_material);
|
|
static void getMaxSpecularRepeats(F32& repeats, bool& identical);
|
|
static void getMaxNormalRepeats(F32& repeats, bool& identical);
|
|
static void getCurrentDiffuseAlphaMode(U8& diffuse_alpha_mode, bool& identical, bool diffuse_texture_has_alpha);
|
|
|
|
FS_DEF_GET_MAT_STATE(LLUUID,const LLUUID&,getNormalID,LLUUID::null, false, LLUUID::null)
|
|
FS_DEF_GET_MAT_STATE(LLUUID,const LLUUID&,getSpecularID,LLUUID::null, false, LLUUID::null)
|
|
FS_DEF_GET_MAT_STATE(F32,F32,getSpecularRepeatX,1.0f, true, 0.001f)
|
|
FS_DEF_GET_MAT_STATE(F32,F32,getSpecularRepeatY,1.0f, true, 0.001f)
|
|
FS_DEF_GET_MAT_STATE(F32,F32,getSpecularOffsetX,0.0f, true, 0.001f)
|
|
FS_DEF_GET_MAT_STATE(F32,F32,getSpecularOffsetY,0.0f, true, 0.001f)
|
|
FS_DEF_GET_MAT_STATE(F32,F32,getSpecularRotation,0.0f, true, 0.001f)
|
|
|
|
FS_DEF_GET_MAT_STATE(F32,F32,getNormalRepeatX,1.0f, true, 0.001f)
|
|
FS_DEF_GET_MAT_STATE(F32,F32,getNormalRepeatY,1.0f, true, 0.001f)
|
|
FS_DEF_GET_MAT_STATE(F32,F32,getNormalOffsetX,0.0f, true, 0.001f)
|
|
FS_DEF_GET_MAT_STATE(F32,F32,getNormalOffsetY,0.0f, true, 0.001f)
|
|
FS_DEF_GET_MAT_STATE(F32,F32,getNormalRotation,0.0f, true, 0.001f)
|
|
|
|
FS_DEF_EDIT_MAT_STATE(U8,U8,setDiffuseAlphaMode);
|
|
FS_DEF_EDIT_MAT_STATE(U8,U8,setAlphaMaskCutoff);
|
|
|
|
FS_DEF_EDIT_MAT_STATE(F32,F32,setNormalOffsetX);
|
|
FS_DEF_EDIT_MAT_STATE(F32,F32,setNormalOffsetY);
|
|
FS_DEF_EDIT_MAT_STATE(F32,F32,setNormalRepeatX);
|
|
FS_DEF_EDIT_MAT_STATE(F32,F32,setNormalRepeatY);
|
|
FS_DEF_EDIT_MAT_STATE(F32,F32,setNormalRotation);
|
|
|
|
FS_DEF_EDIT_MAT_STATE(F32,F32,setSpecularOffsetX);
|
|
FS_DEF_EDIT_MAT_STATE(F32,F32,setSpecularOffsetY);
|
|
FS_DEF_EDIT_MAT_STATE(F32,F32,setSpecularRepeatX);
|
|
FS_DEF_EDIT_MAT_STATE(F32,F32,setSpecularRepeatY);
|
|
FS_DEF_EDIT_MAT_STATE(F32,F32,setSpecularRotation);
|
|
|
|
FS_DEF_EDIT_MAT_STATE(U8,U8,setEnvironmentIntensity);
|
|
FS_DEF_EDIT_MAT_STATE(U8,U8,setSpecularLightExponent);
|
|
|
|
FS_DEF_EDIT_MAT_STATE(LLUUID,const LLUUID&,setNormalID);
|
|
FS_DEF_EDIT_MAT_STATE(LLUUID,const LLUUID&,setSpecularID);
|
|
FS_DEF_EDIT_MAT_STATE(LLColor4U, const LLColor4U&,setSpecularLightColor);
|
|
};
|
|
|
|
class LLSelectedTE
|
|
{
|
|
public:
|
|
static void getFace(class LLFace*& face_to_return, bool& identical_face);
|
|
static void getImageFormat(LLGLenum& image_format_to_return, bool& identical_face);
|
|
static void getTexId(LLUUID& id, bool& identical);
|
|
static void getObjectScaleS(F32& scale_s, bool& identical);
|
|
static void getObjectScaleT(F32& scale_t, bool& identical);
|
|
static void getMaxDiffuseRepeats(F32& repeats, bool& identical);
|
|
|
|
FS_DEF_GET_TE_STATE(U8,U8,getBumpmap,0, false, 0)
|
|
FS_DEF_GET_TE_STATE(U8,U8,getShiny,0, false, 0)
|
|
FS_DEF_GET_TE_STATE(U8,U8,getFullbright,0, false, 0)
|
|
FS_DEF_GET_TE_STATE(F32,F32,getRotation,0.0f, true, 0.001f)
|
|
FS_DEF_GET_TE_STATE(F32,F32,getOffsetS,0.0f, true, 0.001f)
|
|
FS_DEF_GET_TE_STATE(F32,F32,getOffsetT,0.0f, true, 0.001f)
|
|
FS_DEF_GET_TE_STATE(F32,F32,getScaleS,1.0f, true, 0.001f)
|
|
FS_DEF_GET_TE_STATE(F32,F32,getScaleT,1.0f, true, 0.001f)
|
|
FS_DEF_GET_TE_STATE(F32,F32,getGlow,0.0f, true, 0.001f)
|
|
FS_DEF_GET_TE_STATE(LLTextureEntry::e_texgen,LLTextureEntry::e_texgen,getTexGen,LLTextureEntry::TEX_GEN_DEFAULT, false, LLTextureEntry::TEX_GEN_DEFAULT)
|
|
FS_DEF_GET_TE_STATE(LLColor4,const LLColor4&,getColor,LLColor4::white, false, LLColor4::black);
|
|
};
|
|
};
|
|
|
|
#endif
|