From 6618cff96c75bd0183b173c30ec818404038c2dd Mon Sep 17 00:00:00 2001 From: Kitty Barnett Date: Thu, 29 Nov 2012 00:00:18 +0100 Subject: Encapsulate material definitions in LLMaterial and refactor LLFloaterDebugMaterials to use the new class --- indra/llprimitive/llmaterial.cpp | 147 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 147 insertions(+) create mode 100644 indra/llprimitive/llmaterial.cpp (limited to 'indra/llprimitive/llmaterial.cpp') diff --git a/indra/llprimitive/llmaterial.cpp b/indra/llprimitive/llmaterial.cpp new file mode 100644 index 0000000000..36d958ede5 --- /dev/null +++ b/indra/llprimitive/llmaterial.cpp @@ -0,0 +1,147 @@ +/** + * @file llmaterial.cpp + * @brief Material definition + * + * $LicenseInfo:firstyear=2006&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$ + */ + +#include "linden_common.h" + +#include "llmaterial.h" + +/** + * Materials cap parameters + */ +#define MATERIALS_CAP_NORMAL_MAP_FIELD "NormMap" +#define MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD "NormOffsetX" +#define MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD "NormOffsetY" +#define MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD "NormRepeatX" +#define MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD "NormRepeatY" +#define MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD "NormRotation" + +#define MATERIALS_CAP_SPECULAR_MAP_FIELD "SpecMap" +#define MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD "SpecOffsetX" +#define MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD "SpecOffsetY" +#define MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD "SpecRepeatX" +#define MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD "SpecRepeatY" +#define MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD "SpecRotation" + +#define MATERIALS_CAP_SPECULAR_COLOR_FIELD "SpecColor" +#define MATERIALS_CAP_SPECULAR_EXP_FIELD "SpecExp" +#define MATERIALS_CAP_ENV_INTENSITY_FIELD "EnvIntensity" +#define MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD "AlphaMaskCutoff" +#define MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD "DiffuseAlphaMode" + +/** + * Materials constants + */ + +const LLColor4U MATERIALS_DEFAULT_SPECULAR_COLOR = LLColor4U(255, 255, 255, 255); +const U8 MATERIALS_DEFAULT_SPECULAR_EXP = 128; +const U8 MATERIALS_DEFAULT_ENV_INTENSITY = 128; +const U8 MATERIALS_DEFAULT_DIFFUSE_ALPHA_MODE = 0; +const U8 MATERIALS_DEFAULT_ALPHA_MASK_CUTOFF = 128; + +const F32 MATERIALS_MULT_OFFSETREPEAT = 10000.f; +const F32 MATERIALS_MULT_ROTATION = 1000.f; + +/** + * Helper functions + */ + +template T getMaterialField(const LLSD& data, const std::string& field, const LLSD::Type field_type) +{ + if ( (data.has(field)) && (field_type == data[field].type()) ) + { + return (T)data[field]; + } + llerrs << "Missing or mistyped field '" << field << "' in material definition" << llendl; + return (T)LLSD(); +} + +/** + * LLMaterial class + */ + +LLMaterial::LLMaterial() + : mSpecularLightColor(MATERIALS_DEFAULT_SPECULAR_COLOR) + , mSpecularLightExponent(MATERIALS_DEFAULT_SPECULAR_EXP) + , mEnvironmentIntensity(MATERIALS_DEFAULT_ENV_INTENSITY) + , mDiffuseAlphaMode(MATERIALS_DEFAULT_DIFFUSE_ALPHA_MODE) + , mAlphaMaskCutoff(MATERIALS_DEFAULT_ALPHA_MASK_CUTOFF) +{ +} + +LLMaterial::LLMaterial(const LLSD& material_data) +{ + fromLLSD(material_data); +} + +LLSD LLMaterial::asLLSD() const +{ + LLSD material_data; + + material_data[MATERIALS_CAP_NORMAL_MAP_FIELD] = mNormalID; + material_data[MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD] = llround(mNormalOffsetX * MATERIALS_MULT_OFFSETREPEAT); + material_data[MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD] = llround(mNormalOffsetY * MATERIALS_MULT_OFFSETREPEAT); + material_data[MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD] = llround(mNormalRepeatX * MATERIALS_MULT_OFFSETREPEAT); + material_data[MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD] = llround(mNormalRepeatY * MATERIALS_MULT_OFFSETREPEAT); + material_data[MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD] = llround(mNormalRotation * MATERIALS_MULT_ROTATION); + + material_data[MATERIALS_CAP_SPECULAR_MAP_FIELD] = mSpecularID; + material_data[MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD] = llround(mSpecularOffsetX * MATERIALS_MULT_OFFSETREPEAT); + material_data[MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD] = llround(mSpecularOffsetY * MATERIALS_MULT_OFFSETREPEAT); + material_data[MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD] = llround(mSpecularRepeatX * MATERIALS_MULT_OFFSETREPEAT); + material_data[MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD] = llround(mSpecularRepeatY * MATERIALS_MULT_OFFSETREPEAT); + material_data[MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD] = llround(mSpecularRotation * MATERIALS_MULT_ROTATION); + + material_data[MATERIALS_CAP_SPECULAR_COLOR_FIELD] = mSpecularLightColor.getValue(); + material_data[MATERIALS_CAP_SPECULAR_EXP_FIELD] = mSpecularLightExponent; + material_data[MATERIALS_CAP_ENV_INTENSITY_FIELD] = mEnvironmentIntensity; + material_data[MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD] = mDiffuseAlphaMode; + material_data[MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD] = mAlphaMaskCutoff; + + return material_data; +} + +void LLMaterial::fromLLSD(const LLSD& material_data) +{ + mNormalID = getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_FIELD, LLSD::TypeUUID); + mNormalOffsetX = (F32)getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_OFFSETREPEAT; + mNormalOffsetY = (F32)getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_OFFSETREPEAT; + mNormalRepeatX = (F32)getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_OFFSETREPEAT; + mNormalRepeatY = (F32)getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_OFFSETREPEAT; + mNormalRotation = (F32)getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_ROTATION; + + mSpecularID = getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_FIELD, LLSD::TypeUUID); + mSpecularOffsetX = (F32)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_OFFSETREPEAT; + mSpecularOffsetY = (F32)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_OFFSETREPEAT; + mSpecularRepeatX = (F32)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_OFFSETREPEAT; + mSpecularRepeatY = (F32)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_OFFSETREPEAT; + mSpecularRotation = (F32)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_ROTATION; + + mSpecularLightColor.setValue(getMaterialField(material_data, MATERIALS_CAP_SPECULAR_COLOR_FIELD, LLSD::TypeArray)); + mSpecularLightExponent = (U8)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_EXP_FIELD, LLSD::TypeInteger); + mEnvironmentIntensity = (U8)getMaterialField(material_data, MATERIALS_CAP_ENV_INTENSITY_FIELD, LLSD::TypeInteger); + mDiffuseAlphaMode = (U8)getMaterialField(material_data, MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD, LLSD::TypeInteger); + mAlphaMaskCutoff = (U8)getMaterialField(material_data, MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD, LLSD::TypeInteger); +} -- cgit v1.3 From 2feac960904b0b94d05253e4c345f1853ed3bbbf Mon Sep 17 00:00:00 2001 From: Kitty Barnett Date: Sun, 2 Dec 2012 01:04:56 +0100 Subject: Fixed two minor issues (mDiffuseAlphaMode and mAlphaMaskCutoff were reversed; specular rotation had wrong format specifier) --- indra/llprimitive/llmaterial.cpp | 4 ++-- indra/newview/llfloaterdebugmaterials.cpp | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) (limited to 'indra/llprimitive/llmaterial.cpp') diff --git a/indra/llprimitive/llmaterial.cpp b/indra/llprimitive/llmaterial.cpp index 36d958ede5..b07b4ce72d 100644 --- a/indra/llprimitive/llmaterial.cpp +++ b/indra/llprimitive/llmaterial.cpp @@ -142,6 +142,6 @@ void LLMaterial::fromLLSD(const LLSD& material_data) mSpecularLightColor.setValue(getMaterialField(material_data, MATERIALS_CAP_SPECULAR_COLOR_FIELD, LLSD::TypeArray)); mSpecularLightExponent = (U8)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_EXP_FIELD, LLSD::TypeInteger); mEnvironmentIntensity = (U8)getMaterialField(material_data, MATERIALS_CAP_ENV_INTENSITY_FIELD, LLSD::TypeInteger); - mDiffuseAlphaMode = (U8)getMaterialField(material_data, MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD, LLSD::TypeInteger); - mAlphaMaskCutoff = (U8)getMaterialField(material_data, MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD, LLSD::TypeInteger); + mDiffuseAlphaMode = (U8)getMaterialField(material_data, MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD, LLSD::TypeInteger); + mAlphaMaskCutoff = (U8)getMaterialField(material_data, MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD, LLSD::TypeInteger); } diff --git a/indra/newview/llfloaterdebugmaterials.cpp b/indra/newview/llfloaterdebugmaterials.cpp index e86777bfe0..026fd1a28c 100644 --- a/indra/newview/llfloaterdebugmaterials.cpp +++ b/indra/newview/llfloaterdebugmaterials.cpp @@ -1104,7 +1104,7 @@ void LLFloaterDebugMaterials::parseGetResponse() specularMapRowParams.columns.add(cellParams); cellParams.column = "specular_map_list_rotation"; - cellParams.value = llformat("%d", material.getSpecularRotation()); + cellParams.value = llformat("%f", material.getSpecularRotation()); specularMapRowParams.columns.add(cellParams); const LLColor4U& specularColor = material.getSpecularLightColor(); -- cgit v1.3 From 1e26dbdcd27a1f29fe249cc7e074e5ede284bac8 Mon Sep 17 00:00:00 2001 From: Kitty Barnett Date: Mon, 3 Dec 2012 01:46:26 +0100 Subject: Started LLMaterialMgr to handle viewer<->region materials communication * refactored LLFloaterDebugMaterials::requestPutMaterials() to use LLMaterialMgr instead * replaced "Object editing" results list with information about the active selection instead --- indra/llprimitive/llmaterial.cpp | 18 +- indra/llprimitive/llmaterial.h | 3 + indra/newview/CMakeLists.txt | 2 + indra/newview/llfloaterdebugmaterials.cpp | 182 +++++--------- indra/newview/llfloaterdebugmaterials.h | 4 +- indra/newview/llmaterialmgr.cpp | 270 +++++++++++++++++++++ indra/newview/llmaterialmgr.h | 53 ++++ .../default/xui/en/floater_debug_materials.xml | 8 +- 8 files changed, 402 insertions(+), 138 deletions(-) create mode 100644 indra/newview/llmaterialmgr.cpp create mode 100644 indra/newview/llmaterialmgr.h (limited to 'indra/llprimitive/llmaterial.cpp') diff --git a/indra/llprimitive/llmaterial.cpp b/indra/llprimitive/llmaterial.cpp index b07b4ce72d..da518b6916 100644 --- a/indra/llprimitive/llmaterial.cpp +++ b/indra/llprimitive/llmaterial.cpp @@ -82,6 +82,8 @@ template T getMaterialField(const LLSD& data, const std::string& fie * LLMaterial class */ +const LLMaterial LLMaterial::null; + LLMaterial::LLMaterial() : mSpecularLightColor(MATERIALS_DEFAULT_SPECULAR_COLOR) , mSpecularLightExponent(MATERIALS_DEFAULT_SPECULAR_EXP) @@ -117,8 +119,8 @@ LLSD LLMaterial::asLLSD() const material_data[MATERIALS_CAP_SPECULAR_COLOR_FIELD] = mSpecularLightColor.getValue(); material_data[MATERIALS_CAP_SPECULAR_EXP_FIELD] = mSpecularLightExponent; material_data[MATERIALS_CAP_ENV_INTENSITY_FIELD] = mEnvironmentIntensity; - material_data[MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD] = mDiffuseAlphaMode; - material_data[MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD] = mAlphaMaskCutoff; + material_data[MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD] = mDiffuseAlphaMode; + material_data[MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD] = mAlphaMaskCutoff; return material_data; } @@ -142,6 +144,14 @@ void LLMaterial::fromLLSD(const LLSD& material_data) mSpecularLightColor.setValue(getMaterialField(material_data, MATERIALS_CAP_SPECULAR_COLOR_FIELD, LLSD::TypeArray)); mSpecularLightExponent = (U8)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_EXP_FIELD, LLSD::TypeInteger); mEnvironmentIntensity = (U8)getMaterialField(material_data, MATERIALS_CAP_ENV_INTENSITY_FIELD, LLSD::TypeInteger); - mDiffuseAlphaMode = (U8)getMaterialField(material_data, MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD, LLSD::TypeInteger); - mAlphaMaskCutoff = (U8)getMaterialField(material_data, MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD, LLSD::TypeInteger); + mDiffuseAlphaMode = (U8)getMaterialField(material_data, MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD, LLSD::TypeInteger); + mAlphaMaskCutoff = (U8)getMaterialField(material_data, MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD, LLSD::TypeInteger); +} + +bool LLMaterial::isNull() const +{ + // *TODO: find a better way of defining a 'null' material? + return + (mNormalID.isNull()) && (.0f == mNormalOffsetX) && (.0f == mNormalOffsetY) && (.0f == mNormalRepeatX) && (.0f == mNormalRepeatY) && + (mSpecularID.isNull()) && (.0f == mSpecularOffsetX) && (.0f == mSpecularOffsetY) && (.0f == mSpecularRepeatX) && (.0f == mSpecularRepeatY); } diff --git a/indra/llprimitive/llmaterial.h b/indra/llprimitive/llmaterial.h index d50ab30195..42e3dd04b9 100644 --- a/indra/llprimitive/llmaterial.h +++ b/indra/llprimitive/llmaterial.h @@ -69,6 +69,9 @@ public: U8 getAlphaMaskCutoff() const { return mAlphaMaskCutoff; } void setAlphaMaskCutoff(U8 cutoff) { mAlphaMaskCutoff = cutoff; } + bool isNull() const; + static const LLMaterial null; + protected: LLUUID mNormalID; F32 mNormalOffsetX; diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt index 746703db66..3e99bd2551 100755 --- a/indra/newview/CMakeLists.txt +++ b/indra/newview/CMakeLists.txt @@ -335,6 +335,7 @@ set(viewer_SOURCE_FILES llmaniptranslate.cpp llmarketplacefunctions.cpp llmarketplacenotifications.cpp + llmaterialmgr.cpp llmediactrl.cpp llmediadataclient.cpp llmemoryview.cpp @@ -913,6 +914,7 @@ set(viewer_HEADER_FILES llmaniptranslate.h llmarketplacefunctions.h llmarketplacenotifications.h + llmaterialmgr.h llmediactrl.h llmediadataclient.h llmemoryview.h diff --git a/indra/newview/llfloaterdebugmaterials.cpp b/indra/newview/llfloaterdebugmaterials.cpp index 7b3ad7aa13..f69dd6214c 100644 --- a/indra/newview/llfloaterdebugmaterials.cpp +++ b/indra/newview/llfloaterdebugmaterials.cpp @@ -48,6 +48,7 @@ #include "lllineeditor.h" #include "llmaterial.h" #include "llmaterialid.h" +#include "llmaterialmgr.h" #include "llresmgr.h" #include "llscrolllistcell.h" #include "llscrolllistctrl.h" @@ -76,11 +77,8 @@ #define MATERIALS_CAP_ZIP_FIELD "Zipped" -#define MATERIALS_CAP_FULL_PER_FACE_FIELD "FullMaterialsPerFace" -#define MATERIALS_CAP_FACE_FIELD "Face" #define MATERIALS_CAP_MATERIAL_FIELD "Material" #define MATERIALS_CAP_OBJECT_ID_FIELD "ID" -#define MATERIALS_CAP_MATERIAL_ID_FIELD "MaterialID" #define MULTI_MATERIALS_STATUS_FIELD "status" #define MULTI_MATERIALS_DATA_FIELD "data" @@ -292,7 +290,6 @@ void LLFloaterDebugMaterials::onOpen(const LLSD& pKey) checkRegionMaterialStatus(); resetObjectEditInputs(); clearGetResults(); - clearPutResults(); clearViewableObjectsResults(); clearPostResults(); } @@ -301,7 +298,6 @@ void LLFloaterDebugMaterials::onClose(bool pIsAppQuitting) { resetObjectEditInputs(); clearGetResults(); - clearPutResults(); clearViewableObjectsResults(); clearPostResults(); @@ -333,6 +329,10 @@ void LLFloaterDebugMaterials::draw() { parseQueryViewableObjects(); } + if (LLSelectMgr::instance().getSelection().notNull()) + { + refreshObjectEdit(); + } LLFloater::draw(); } @@ -446,7 +446,6 @@ void LLFloaterDebugMaterials::onRegionCross() { checkRegionMaterialStatus(); clearGetResults(); - clearPutResults(); clearViewableObjectsResults(); clearPostResults(); } @@ -580,19 +579,6 @@ void LLFloaterDebugMaterials::onGetResponse(bool pRequestStatus, const LLSD& pCo } } -void LLFloaterDebugMaterials::onPutResponse(bool pRequestStatus, const LLSD& pContent) -{ - if (pRequestStatus) - { - setState(kRequestCompleted); - parsePutResponse(pContent); - } - else - { - setState(kError); - } -} - void LLFloaterDebugMaterials::onPostResponse(bool pRequestStatus, const LLSD& pContent) { if (pRequestStatus) @@ -717,16 +703,9 @@ void LLFloaterDebugMaterials::requestPutMaterials(bool pIsDoSet) } else { - setState(kRequestStarted); + setState(kReady); - LLSD facesData = LLSD::emptyArray(); - - LLSD materialData = LLSD::emptyMap(); - if (pIsDoSet) - { - LLMaterial material = getMaterial(); - materialData = material.asLLSD(); - } + LLMaterial material = (pIsDoSet) ? getMaterial() : LLMaterial::null; LLObjectSelectionHandle selectionHandle = LLSelectMgr::getInstance()->getEditSelection(); for (LLObjectSelection::valid_iterator objectIter = selectionHandle->valid_begin(); @@ -747,41 +726,13 @@ void LLFloaterDebugMaterials::requestPutMaterials(bool pIsDoSet) { if (objectNode->isTESelected(curTEIndex)) { - LLSD faceData = LLSD::emptyMap(); - faceData[MATERIALS_CAP_FACE_FIELD] = static_cast(curTEIndex); - faceData[MATERIALS_CAP_OBJECT_ID_FIELD] = static_cast(viewerObject->getLocalID()); - if (pIsDoSet) - { - faceData[MATERIALS_CAP_MATERIAL_FIELD] = materialData; - } - facesData.append(faceData); + LLMaterialMgr::instance().put(viewerObject->getID(), curTEIndex, material); } } } } - LLSD materialsData = LLSD::emptyMap(); - materialsData[MATERIALS_CAP_FULL_PER_FACE_FIELD] = facesData; - - std::string materialString = zip_llsd(materialsData); - S32 materialSize = materialString.size(); - - if (materialSize <= 0) - { - LL_ERRS("debugMaterials") << "cannot zip LLSD binary content" << LL_ENDL; - } - else - { - LLSD::Binary materialBinary; - materialBinary.resize(materialSize); - memcpy(materialBinary.data(), materialString.data(), materialSize); - - LLSD putData = LLSD::emptyMap(); - putData[MATERIALS_CAP_ZIP_FIELD] = materialBinary; - - LLHTTPClient::ResponderPtr materialsResponder = new MaterialsResponder("PUT", capURL, boost::bind(&LLFloaterDebugMaterials::onPutResponse, this, _1, _2)); - LLHTTPClient::put(capURL, putData, materialsResponder); - } + LLMaterialMgr::instance().processPutQueue(); } } } @@ -1149,70 +1100,6 @@ void LLFloaterDebugMaterials::parseGetResponse() } } -void LLFloaterDebugMaterials::parsePutResponse(const LLSD& pContent) -{ - clearPutResults(); - - LLScrollListCell::Params cellParams; - LLScrollListItem::Params rowParams; - - llassert(pContent.isMap()); - llassert(pContent.has(MATERIALS_CAP_ZIP_FIELD)); - llassert(pContent.get(MATERIALS_CAP_ZIP_FIELD).isBinary()); - - LLSD::Binary responseBinary = pContent.get(MATERIALS_CAP_ZIP_FIELD).asBinary(); - S32 responseSize = static_cast(responseBinary.size()); - std::string responseString(reinterpret_cast(responseBinary.data()), responseSize); - - std::istringstream responseStream(responseString); - - LLSD responseContent; - if (!unzip_llsd(responseContent, responseStream, responseSize)) - { - LL_ERRS("debugMaterials") << "cannot unzip LLSD binary content" << LL_ENDL; - } - else - { - llassert(responseContent.isArray()); - for (LLSD::array_const_iterator faceIter = responseContent.beginArray(); faceIter != responseContent.endArray(); - ++faceIter) - { - const LLSD &face = *faceIter; - llassert(face.isMap()); - - llassert(face.has(MATERIALS_CAP_FACE_FIELD)); - llassert(face.get(MATERIALS_CAP_FACE_FIELD).isInteger()); - S32 faceId = face.get(MATERIALS_CAP_FACE_FIELD).asInteger(); - - llassert(face.has(MATERIALS_CAP_OBJECT_ID_FIELD)); - llassert(face.get(MATERIALS_CAP_OBJECT_ID_FIELD).isInteger()); - S32 objectId = face.get(MATERIALS_CAP_OBJECT_ID_FIELD).asInteger(); - - llassert(face.has(MATERIALS_CAP_MATERIAL_ID_FIELD)); - llassert(face.get(MATERIALS_CAP_MATERIAL_ID_FIELD).isBinary()); - std::string materialIDString = convertToPrintableMaterialID(face.get(MATERIALS_CAP_MATERIAL_ID_FIELD)); - - cellParams.font = LLFontGL::getFontMonospace(); - - cellParams.column = "material_id"; - cellParams.value = materialIDString; - rowParams.columns.add(cellParams); - - cellParams.font = LLFontGL::getFontSansSerif(); - - cellParams.column = "object_id"; - cellParams.value = llformat("%d", objectId); - rowParams.columns.add(cellParams); - - cellParams.column = "face_index"; - cellParams.value = llformat("%d", faceId); - rowParams.columns.add(cellParams); - - mPutScrollList->addRow(rowParams); - } - } -} - void LLFloaterDebugMaterials::parsePostResponse(const LLSD& pMultiContent) { clearPostResults(); @@ -1374,6 +1261,52 @@ void LLFloaterDebugMaterials::setState(EState pState) updateControls(); } +void LLFloaterDebugMaterials::refreshObjectEdit() +{ + mPutScrollList->deleteAllItems(); + + LLScrollListCell::Params cellParams; + LLScrollListItem::Params rowParams; + + LLObjectSelectionHandle selectionHandle = LLSelectMgr::getInstance()->getEditSelection(); + for (LLObjectSelection::valid_iterator objectIter = selectionHandle->valid_begin(); + objectIter != selectionHandle->valid_end(); ++objectIter) + { + LLSelectNode* nodep = *objectIter; + + LLViewerObject* objectp = nodep->getObject(); + if (objectp != NULL) + { + S32 numTEs = llmin(static_cast(objectp->getNumTEs()), objectp->getNumFaces()); + for (S32 curTEIndex = 0; curTEIndex < numTEs; ++curTEIndex) + { + if (nodep->isTESelected(curTEIndex)) + { + const LLTextureEntry* tep = objectp->getTE(curTEIndex); + + cellParams.font = LLFontGL::getFontMonospace(); + + cellParams.column = "material_id"; + cellParams.value = tep->getMaterialID().asString(); + rowParams.columns.add(cellParams); + + cellParams.font = LLFontGL::getFontSansSerif(); + + cellParams.column = "object_id"; + cellParams.value = objectp->getID().asString(); + rowParams.columns.add(cellParams); + + cellParams.column = "face_index"; + cellParams.value = llformat("%d", curTEIndex); + rowParams.columns.add(cellParams); + + mPutScrollList->addRow(rowParams); + } + } + } + } +} + void LLFloaterDebugMaterials::resetObjectEditInputs() { const LLSD zeroValue = static_cast(0); @@ -1409,11 +1342,6 @@ void LLFloaterDebugMaterials::clearGetResults() clearUnparsedGetData(); } -void LLFloaterDebugMaterials::clearPutResults() -{ - mPutScrollList->deleteAllItems(); -} - void LLFloaterDebugMaterials::clearPostResults() { mPostNormalMapScrollList->deleteAllItems(); diff --git a/indra/newview/llfloaterdebugmaterials.h b/indra/newview/llfloaterdebugmaterials.h index 572b17af27..920bc4ae6d 100644 --- a/indra/newview/llfloaterdebugmaterials.h +++ b/indra/newview/llfloaterdebugmaterials.h @@ -96,7 +96,6 @@ private: void onDeferredRequestGetMaterials(LLUUID regionId); void onDeferredRequestPutMaterials(LLUUID regionId, bool pIsDoSet); void onGetResponse(bool pRequestStatus, const LLSD& pContent); - void onPutResponse(bool pRequestStatus, const LLSD& pContent); void onPostResponse(bool pRequestStatus, const LLSD& pContent); void checkRegionMaterialStatus(); @@ -111,16 +110,15 @@ private: void requestPostMaterials(); void parseGetResponse(); - void parsePutResponse(const LLSD& pContent); void parseQueryViewableObjects(); void parsePostResponse(const LLSD& pMultiContent); void setState(EState pState); inline EState getState() const; + void refreshObjectEdit(); void resetObjectEditInputs(); void clearGetResults(); - void clearPutResults(); void clearPostResults(); void clearViewableObjectsResults(); diff --git a/indra/newview/llmaterialmgr.cpp b/indra/newview/llmaterialmgr.cpp new file mode 100644 index 0000000000..5ba7ad5a05 --- /dev/null +++ b/indra/newview/llmaterialmgr.cpp @@ -0,0 +1,270 @@ +/** + * @file llmaterialmgr.cpp + * @brief Material manager + * + * $LicenseInfo:firstyear=2006&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$ + */ + +#include "llviewerprecompiledheaders.h" + +#include "llsdserialize.h" + +#include "llmaterialmgr.h" +#include "llviewerobject.h" +#include "llviewerobjectlist.h" +#include "llviewerregion.h" + +/** + * Materials cap parameters + */ + +#define MATERIALS_CAPABILITY_NAME "RenderMaterials" + +#define MATERIALS_CAP_ZIP_FIELD "Zipped" + +#define MATERIALS_CAP_FULL_PER_FACE_FIELD "FullMaterialsPerFace" +#define MATERIALS_CAP_FACE_FIELD "Face" +#define MATERIALS_CAP_MATERIAL_FIELD "Material" +#define MATERIALS_CAP_OBJECT_ID_FIELD "ID" +#define MATERIALS_CAP_MATERIAL_ID_FIELD "MaterialID" + +/** + * LLMaterialsResponder helper class + */ + +class LLMaterialsResponder : public LLHTTPClient::Responder +{ +public: + typedef boost::function CallbackFunction; + + LLMaterialsResponder(const std::string& pMethod, const std::string& pCapabilityURL, CallbackFunction pCallback); + virtual ~LLMaterialsResponder(); + + virtual void result(const LLSD& pContent); + virtual void error(U32 pStatus, const std::string& pReason); + +private: + std::string mMethod; + std::string mCapabilityURL; + CallbackFunction mCallback; +}; + +LLMaterialsResponder::LLMaterialsResponder(const std::string& pMethod, const std::string& pCapabilityURL, CallbackFunction pCallback) + : LLHTTPClient::Responder() + , mMethod(pMethod) + , mCapabilityURL(pCapabilityURL) + , mCallback(pCallback) +{ +} + +LLMaterialsResponder::~LLMaterialsResponder() +{ +} + +void LLMaterialsResponder::result(const LLSD& pContent) +{ + mCallback(true, pContent); +} + +void LLMaterialsResponder::error(U32 pStatus, const std::string& pReason) +{ + LL_WARNS("debugMaterials") << "--------------------------------------------------------------------------" << LL_ENDL; + LL_WARNS("debugMaterials") << mMethod << " Error[" << pStatus << "] cannot access cap '" << MATERIALS_CAPABILITY_NAME + << "' with url '" << mCapabilityURL << "' because " << pReason << LL_ENDL; + LL_WARNS("debugMaterials") << "--------------------------------------------------------------------------" << LL_ENDL; + + LLSD emptyResult; + mCallback(false, emptyResult); +} + +/** + * LLMaterialMgr class + */ + +LLMaterialMgr::LLMaterialMgr() +{ +} + +LLMaterialMgr::~LLMaterialMgr() +{ +} + +void LLMaterialMgr::put(const LLUUID& object_id, const U8 te, const LLMaterial& material) +{ + put_queue_t::iterator itQueue = mPutQueue.find(object_id); + if (mPutQueue.end() == itQueue) + { + mPutQueue.insert(std::pair(object_id, facematerial_map_t())); + itQueue = mPutQueue.find(object_id); + } + + facematerial_map_t::iterator itFace = itQueue->second.find(te); + if (itQueue->second.end() == itFace) + { + itQueue->second.insert(std::pair(te, material)); + } + else + { + itFace->second = material; + } +} + +void LLMaterialMgr::onPutResponse(bool success, const LLSD& content, const LLUUID& object_id) +{ + if (!success) + { + // *TODO: is there any kind of error handling we can do here? + return; + } + + LLViewerObject* objectp = gObjectList.findObject(object_id); + if (!objectp) + { + LL_WARNS("debugMaterials") << "Received PUT response for unknown object" << LL_ENDL; + return; + } + + llassert(content.isMap()); + llassert(content.has(MATERIALS_CAP_ZIP_FIELD)); + llassert(content.get(MATERIALS_CAP_ZIP_FIELD).isBinary()); + + LLSD::Binary content_binary = content.get(MATERIALS_CAP_ZIP_FIELD).asBinary(); + std::string content_string(reinterpret_cast(content_binary.data()), content_binary.size()); + std::istringstream content_stream(content_string); + + LLSD response_data; + if (!unzip_llsd(response_data, content_stream, content_binary.size())) + { + LL_ERRS("debugMaterials") << "Cannot unzip LLSD binary content" << LL_ENDL; + return; + } + else + { + llassert(response_data.isArray()); + + for (LLSD::array_const_iterator faceIter = response_data.beginArray(); faceIter != response_data.endArray(); ++faceIter) + { + const LLSD& face_data = *faceIter; + llassert(face_data.isMap()); + + llassert(face_data.has(MATERIALS_CAP_OBJECT_ID_FIELD)); + llassert(face_data.get(MATERIALS_CAP_OBJECT_ID_FIELD).isInteger()); + U32 local_id = face_data.get(MATERIALS_CAP_OBJECT_ID_FIELD).asInteger(); + if (objectp->getLocalID() != local_id) + { + LL_ERRS("debugMaterials") << "Received PUT response for wrong object" << LL_ENDL; + continue; + } + + llassert(face_data.has(MATERIALS_CAP_FACE_FIELD)); + llassert(face_data.get(MATERIALS_CAP_FACE_FIELD).isInteger()); + S32 te = face_data.get(MATERIALS_CAP_FACE_FIELD).asInteger(); + + llassert(face_data.has(MATERIALS_CAP_MATERIAL_ID_FIELD)); + llassert(face_data.get(MATERIALS_CAP_MATERIAL_ID_FIELD).isBinary()); + LLMaterialID material_id(face_data.get(MATERIALS_CAP_MATERIAL_ID_FIELD).asBinary()); + + LL_INFOS("debugMaterials") << "Setting material '" << material_id.asString() << "' on object '" << local_id + << "' face " << te << LL_ENDL; + + objectp->setTEMaterialID(te, material_id); + } + } +} + +void LLMaterialMgr::processPutQueue() +{ + put_queue_t::iterator itQueue = mPutQueue.begin(); + while (itQueue != mPutQueue.end()) + { + put_queue_t::iterator curQueue = itQueue++; + + const LLUUID& object_id = curQueue->first; + const LLViewerObject* objectp = gObjectList.findObject(object_id); + if ( (!objectp) || (!objectp->getRegion()) ) + { + LL_WARNS("debugMaterials") << "Object or object region is NULL" << LL_ENDL; + + mPutQueue.erase(curQueue); + continue; + } + + const LLViewerRegion* regionp = objectp->getRegion(); + if (!regionp->capabilitiesReceived()) + { + continue; + } + + std::string capURL = regionp->getCapability(MATERIALS_CAPABILITY_NAME); + if (capURL.empty()) + { + LL_WARNS("debugMaterials") << "Capability '" << MATERIALS_CAPABILITY_NAME + << "' is not defined on region '" << regionp->getName() << "'" << LL_ENDL; + + mPutQueue.erase(curQueue); + continue; + } + + LLSD facesData = LLSD::emptyArray(); + for (facematerial_map_t::const_iterator itFace = curQueue->second.begin(); itFace != curQueue->second.end(); ++itFace) + { + LLSD faceData = LLSD::emptyMap(); + faceData[MATERIALS_CAP_FACE_FIELD] = static_cast(itFace->first); + faceData[MATERIALS_CAP_OBJECT_ID_FIELD] = static_cast(objectp->getLocalID()); + if (!itFace->second.isNull()) + { + faceData[MATERIALS_CAP_MATERIAL_FIELD] = itFace->second.asLLSD(); + } + facesData.append(faceData); + + LL_INFOS("debugMaterials") << "Requesting material change on object '" << faceData[MATERIALS_CAP_OBJECT_ID_FIELD].asInteger() + << "' face " << faceData[MATERIALS_CAP_FACE_FIELD].asInteger() << LL_ENDL; + } + + LLSD materialsData = LLSD::emptyMap(); + materialsData[MATERIALS_CAP_FULL_PER_FACE_FIELD] = facesData; + + std::string materialString = zip_llsd(materialsData); + + S32 materialSize = materialString.size(); + if (materialSize <= 0) + { + LL_ERRS("debugMaterials") << "cannot zip LLSD binary content" << LL_ENDL; + + mPutQueue.erase(curQueue); + continue; + } + else + { + LLSD::Binary materialBinary; + materialBinary.resize(materialSize); + memcpy(materialBinary.data(), materialString.data(), materialSize); + + LLSD putData = LLSD::emptyMap(); + putData[MATERIALS_CAP_ZIP_FIELD] = materialBinary; + + // *HACK: the viewer can't lookup the local object id the cap returns so we'll pass the object's uuid along + LLHTTPClient::ResponderPtr materialsResponder = new LLMaterialsResponder("PUT", capURL, boost::bind(&LLMaterialMgr::onPutResponse, this, _1, _2, object_id)); + LLHTTPClient::put(capURL, putData, materialsResponder); + } + } +} diff --git a/indra/newview/llmaterialmgr.h b/indra/newview/llmaterialmgr.h new file mode 100644 index 0000000000..c4e1c01389 --- /dev/null +++ b/indra/newview/llmaterialmgr.h @@ -0,0 +1,53 @@ +/** + * @file llmaterialmgr.h + * @brief Material manager + * + * $LicenseInfo:firstyear=2006&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_LLMATERIALMGR_H +#define LL_LLMATERIALMGR_H + +#include "llmaterial.h" +#include "llsingleton.h" + +class LLMaterialMgr : public LLSingleton +{ + friend LLSingleton; +protected: + LLMaterialMgr(); + virtual ~LLMaterialMgr(); + +public: + void put(const LLUUID& object_id, const U8 te, const LLMaterial& material); + void processPutQueue(); + +protected: + void onPutResponse(bool success, const LLSD& content, const LLUUID& object_id); + +protected: + typedef std::map facematerial_map_t; + typedef std::map put_queue_t; + put_queue_t mPutQueue; +}; + +#endif // LL_LLMATERIALMGR_H diff --git a/indra/newview/skins/default/xui/en/floater_debug_materials.xml b/indra/newview/skins/default/xui/en/floater_debug_materials.xml index b6c105e19a..3a450fdeff 100644 --- a/indra/newview/skins/default/xui/en/floater_debug_materials.xml +++ b/indra/newview/skins/default/xui/en/floater_debug_materials.xml @@ -720,24 +720,24 @@ left="0" top_pad="0" width="160"> - Results + Active selection + width="600"> + width="225" /> Date: Fri, 7 Dec 2012 17:04:21 +0100 Subject: Use a single multiplier value for all material fields --- indra/llprimitive/llmaterial.cpp | 44 +++++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 23 deletions(-) (limited to 'indra/llprimitive/llmaterial.cpp') diff --git a/indra/llprimitive/llmaterial.cpp b/indra/llprimitive/llmaterial.cpp index da518b6916..982136128e 100644 --- a/indra/llprimitive/llmaterial.cpp +++ b/indra/llprimitive/llmaterial.cpp @@ -60,9 +60,7 @@ const U8 MATERIALS_DEFAULT_SPECULAR_EXP = 128; const U8 MATERIALS_DEFAULT_ENV_INTENSITY = 128; const U8 MATERIALS_DEFAULT_DIFFUSE_ALPHA_MODE = 0; const U8 MATERIALS_DEFAULT_ALPHA_MASK_CUTOFF = 128; - -const F32 MATERIALS_MULT_OFFSETREPEAT = 10000.f; -const F32 MATERIALS_MULT_ROTATION = 1000.f; +const F32 MATERIALS_MULTIPLIER = 10000.f; /** * Helper functions @@ -103,18 +101,18 @@ LLSD LLMaterial::asLLSD() const LLSD material_data; material_data[MATERIALS_CAP_NORMAL_MAP_FIELD] = mNormalID; - material_data[MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD] = llround(mNormalOffsetX * MATERIALS_MULT_OFFSETREPEAT); - material_data[MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD] = llround(mNormalOffsetY * MATERIALS_MULT_OFFSETREPEAT); - material_data[MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD] = llround(mNormalRepeatX * MATERIALS_MULT_OFFSETREPEAT); - material_data[MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD] = llround(mNormalRepeatY * MATERIALS_MULT_OFFSETREPEAT); - material_data[MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD] = llround(mNormalRotation * MATERIALS_MULT_ROTATION); + material_data[MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD] = llround(mNormalOffsetX * MATERIALS_MULTIPLIER); + material_data[MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD] = llround(mNormalOffsetY * MATERIALS_MULTIPLIER); + material_data[MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD] = llround(mNormalRepeatX * MATERIALS_MULTIPLIER); + material_data[MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD] = llround(mNormalRepeatY * MATERIALS_MULTIPLIER); + material_data[MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD] = llround(mNormalRotation * MATERIALS_MULTIPLIER); material_data[MATERIALS_CAP_SPECULAR_MAP_FIELD] = mSpecularID; - material_data[MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD] = llround(mSpecularOffsetX * MATERIALS_MULT_OFFSETREPEAT); - material_data[MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD] = llround(mSpecularOffsetY * MATERIALS_MULT_OFFSETREPEAT); - material_data[MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD] = llround(mSpecularRepeatX * MATERIALS_MULT_OFFSETREPEAT); - material_data[MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD] = llround(mSpecularRepeatY * MATERIALS_MULT_OFFSETREPEAT); - material_data[MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD] = llround(mSpecularRotation * MATERIALS_MULT_ROTATION); + material_data[MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD] = llround(mSpecularOffsetX * MATERIALS_MULTIPLIER); + material_data[MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD] = llround(mSpecularOffsetY * MATERIALS_MULTIPLIER); + material_data[MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD] = llround(mSpecularRepeatX * MATERIALS_MULTIPLIER); + material_data[MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD] = llround(mSpecularRepeatY * MATERIALS_MULTIPLIER); + material_data[MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD] = llround(mSpecularRotation * MATERIALS_MULTIPLIER); material_data[MATERIALS_CAP_SPECULAR_COLOR_FIELD] = mSpecularLightColor.getValue(); material_data[MATERIALS_CAP_SPECULAR_EXP_FIELD] = mSpecularLightExponent; @@ -128,18 +126,18 @@ LLSD LLMaterial::asLLSD() const void LLMaterial::fromLLSD(const LLSD& material_data) { mNormalID = getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_FIELD, LLSD::TypeUUID); - mNormalOffsetX = (F32)getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_OFFSETREPEAT; - mNormalOffsetY = (F32)getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_OFFSETREPEAT; - mNormalRepeatX = (F32)getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_OFFSETREPEAT; - mNormalRepeatY = (F32)getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_OFFSETREPEAT; - mNormalRotation = (F32)getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_ROTATION; + mNormalOffsetX = (F32)getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; + mNormalOffsetY = (F32)getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; + mNormalRepeatX = (F32)getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; + mNormalRepeatY = (F32)getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; + mNormalRotation = (F32)getMaterialField(material_data, MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; mSpecularID = getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_FIELD, LLSD::TypeUUID); - mSpecularOffsetX = (F32)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_OFFSETREPEAT; - mSpecularOffsetY = (F32)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_OFFSETREPEAT; - mSpecularRepeatX = (F32)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_OFFSETREPEAT; - mSpecularRepeatY = (F32)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_OFFSETREPEAT; - mSpecularRotation = (F32)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD, LLSD::TypeInteger) / MATERIALS_MULT_ROTATION; + mSpecularOffsetX = (F32)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; + mSpecularOffsetY = (F32)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; + mSpecularRepeatX = (F32)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; + mSpecularRepeatY = (F32)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; + mSpecularRotation = (F32)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; mSpecularLightColor.setValue(getMaterialField(material_data, MATERIALS_CAP_SPECULAR_COLOR_FIELD, LLSD::TypeArray)); mSpecularLightExponent = (U8)getMaterialField(material_data, MATERIALS_CAP_SPECULAR_EXP_FIELD, LLSD::TypeInteger); -- cgit v1.3 From ca790f7320c9fc6c43e8c6022c9e511a85fd1c9d Mon Sep 17 00:00:00 2001 From: Kitty Barnett Date: Tue, 18 Dec 2012 21:52:41 +0100 Subject: Bypass GCC template stumble by specializing getMaterialField for LLUUID --- indra/llprimitive/llmaterial.cpp | 11 +++++++++++ 1 file changed, 11 insertions(+) (limited to 'indra/llprimitive/llmaterial.cpp') diff --git a/indra/llprimitive/llmaterial.cpp b/indra/llprimitive/llmaterial.cpp index 982136128e..645fcf7b46 100644 --- a/indra/llprimitive/llmaterial.cpp +++ b/indra/llprimitive/llmaterial.cpp @@ -76,6 +76,17 @@ template T getMaterialField(const LLSD& data, const std::string& fie return (T)LLSD(); } +// GCC didn't like the generic form above for some reason +template<> LLUUID getMaterialField(const LLSD& data, const std::string& field, const LLSD::Type field_type) +{ + if ( (data.has(field)) && (field_type == data[field].type()) ) + { + return data[field].asUUID(); + } + llerrs << "Missing or mistyped field '" << field << "' in material definition" << llendl; + return LLUUID::null; +} + /** * LLMaterial class */ -- cgit v1.3 From fbf8e51c6059791b12f60602b4dda0d72dc2d847 Mon Sep 17 00:00:00 2001 From: Kitty Barnett Date: Mon, 25 Feb 2013 00:16:14 +0100 Subject: Added LLMaterialMgr::remove() to remove material information from a face --- indra/llprimitive/llmaterial.cpp | 43 ++++++++++++++++++++++++++++------------ indra/llprimitive/llmaterial.h | 3 +++ indra/newview/llmaterialmgr.cpp | 5 +++++ indra/newview/llmaterialmgr.h | 1 + 4 files changed, 39 insertions(+), 13 deletions(-) (limited to 'indra/llprimitive/llmaterial.cpp') diff --git a/indra/llprimitive/llmaterial.cpp b/indra/llprimitive/llmaterial.cpp index 645fcf7b46..f6fd8e557a 100644 --- a/indra/llprimitive/llmaterial.cpp +++ b/indra/llprimitive/llmaterial.cpp @@ -55,11 +55,6 @@ * Materials constants */ -const LLColor4U MATERIALS_DEFAULT_SPECULAR_COLOR = LLColor4U(255, 255, 255, 255); -const U8 MATERIALS_DEFAULT_SPECULAR_EXP = 128; -const U8 MATERIALS_DEFAULT_ENV_INTENSITY = 128; -const U8 MATERIALS_DEFAULT_DIFFUSE_ALPHA_MODE = 0; -const U8 MATERIALS_DEFAULT_ALPHA_MASK_CUTOFF = 128; const F32 MATERIALS_MULTIPLIER = 10000.f; /** @@ -94,11 +89,20 @@ template<> LLUUID getMaterialField(const LLSD& data, const std::string& field, c const LLMaterial LLMaterial::null; LLMaterial::LLMaterial() - : mSpecularLightColor(MATERIALS_DEFAULT_SPECULAR_COLOR) - , mSpecularLightExponent(MATERIALS_DEFAULT_SPECULAR_EXP) - , mEnvironmentIntensity(MATERIALS_DEFAULT_ENV_INTENSITY) - , mDiffuseAlphaMode(MATERIALS_DEFAULT_DIFFUSE_ALPHA_MODE) - , mAlphaMaskCutoff(MATERIALS_DEFAULT_ALPHA_MASK_CUTOFF) + : mNormalOffsetX(.0f) + , mNormalOffsetY(.0f) + , mNormalRepeatX(.0f) + , mNormalRepeatY(.0f) + , mNormalRotation(.0f) + , mSpecularOffsetX(.0f) + , mSpecularOffsetY(.0f) + , mSpecularRepeatX(.0f) + , mSpecularRepeatY(.0f) + , mSpecularRotation(.0f) + , mSpecularLightExponent(0) + , mEnvironmentIntensity(0) + , mDiffuseAlphaMode(0) + , mAlphaMaskCutoff(0) { } @@ -159,8 +163,21 @@ void LLMaterial::fromLLSD(const LLSD& material_data) bool LLMaterial::isNull() const { - // *TODO: find a better way of defining a 'null' material? + return (*this == null); +} + +bool LLMaterial::operator == (const LLMaterial& rhs) const +{ return - (mNormalID.isNull()) && (.0f == mNormalOffsetX) && (.0f == mNormalOffsetY) && (.0f == mNormalRepeatX) && (.0f == mNormalRepeatY) && - (mSpecularID.isNull()) && (.0f == mSpecularOffsetX) && (.0f == mSpecularOffsetY) && (.0f == mSpecularRepeatX) && (.0f == mSpecularRepeatY); + (mNormalID == rhs.mNormalID) && (mNormalOffsetX == rhs.mNormalOffsetX) && (mNormalOffsetY == rhs.mNormalOffsetY) && + (mNormalRepeatX == rhs.mNormalRepeatX) && (mNormalRepeatY == rhs.mNormalRepeatY) && (mNormalRotation == rhs.mNormalRotation) && + (mSpecularID == rhs.mSpecularID) && (mSpecularOffsetX == rhs.mSpecularOffsetX) && (mSpecularOffsetY == rhs.mSpecularOffsetY) && + (mSpecularRepeatX == rhs.mSpecularRepeatX) && (mSpecularRepeatY == rhs.mSpecularRepeatY) && (mSpecularRotation == rhs.mSpecularRotation) && + (mSpecularLightColor == rhs.mSpecularLightColor) && (mSpecularLightExponent == rhs.mSpecularLightExponent) && + (mEnvironmentIntensity == rhs.mEnvironmentIntensity) && (mDiffuseAlphaMode == rhs.mDiffuseAlphaMode) && (mAlphaMaskCutoff == rhs.mAlphaMaskCutoff); +} + +bool LLMaterial::operator != (const LLMaterial& rhs) const +{ + return !(*this == rhs); } diff --git a/indra/llprimitive/llmaterial.h b/indra/llprimitive/llmaterial.h index 6f94cfda17..5b56d11cd2 100644 --- a/indra/llprimitive/llmaterial.h +++ b/indra/llprimitive/llmaterial.h @@ -74,6 +74,9 @@ public: bool isNull() const; static const LLMaterial null; + bool operator == (const LLMaterial& rhs) const; + bool operator != (const LLMaterial& rhs) const; + protected: LLUUID mNormalID; F32 mNormalOffsetX; diff --git a/indra/newview/llmaterialmgr.cpp b/indra/newview/llmaterialmgr.cpp index de82ec80c8..253b0c124e 100644 --- a/indra/newview/llmaterialmgr.cpp +++ b/indra/newview/llmaterialmgr.cpp @@ -246,6 +246,11 @@ void LLMaterialMgr::put(const LLUUID& object_id, const U8 te, const LLMaterial& } } +void LLMaterialMgr::remove(const LLUUID& object_id, const U8 te) +{ + put(object_id, te, LLMaterial::null); +} + const LLMaterialPtr LLMaterialMgr::setMaterial(const LLUUID& region_id, const LLMaterialID& material_id, const LLSD& material_data) { LL_DEBUGS("Materials") << "region " << region_id << " material id " << material_id << LL_ENDL; diff --git a/indra/newview/llmaterialmgr.h b/indra/newview/llmaterialmgr.h index 1672d11d38..6f444309d3 100644 --- a/indra/newview/llmaterialmgr.h +++ b/indra/newview/llmaterialmgr.h @@ -50,6 +50,7 @@ public: void getAll(const LLUUID& region_id); boost::signals2::connection getAll(const LLUUID& region_id, getall_callback_t::slot_type cb); void put(const LLUUID& object_id, const U8 te, const LLMaterial& material); + void remove(const LLUUID& object_id, const U8 te); protected: void clearGetQueues(const LLUUID& region_id); -- cgit v1.3 From 6300f4f768de13823a754831797cb34022f87b60 Mon Sep 17 00:00:00 2001 From: Dave Parks Date: Wed, 27 Mar 2013 21:59:14 -0500 Subject: NORSPEC-61 Hook up material parameters to shaders. --- indra/llprimitive/llmaterial.cpp | 33 +++++ indra/llprimitive/llmaterial.h | 16 +++ .../shaders/class1/deferred/materialF.glsl | 54 ++++++-- .../shaders/class1/deferred/materialV.glsl | 11 ++ .../shaders/class1/deferred/softenLightF.glsl | 2 +- .../shaders/class2/deferred/softenLightF.glsl | 6 +- indra/newview/lldrawpool.h | 17 ++- indra/newview/lldrawpoolmaterials.cpp | 149 ++++++++------------- indra/newview/lldrawpoolmaterials.h | 8 +- indra/newview/llviewerdisplay.cpp | 2 +- indra/newview/llviewershadermgr.cpp | 144 ++++---------------- indra/newview/llviewershadermgr.h | 11 +- indra/newview/llvovolume.cpp | 58 +++++--- indra/newview/pipeline.cpp | 2 +- indra/newview/pipeline.h | 2 +- 15 files changed, 254 insertions(+), 261 deletions(-) (limited to 'indra/llprimitive/llmaterial.cpp') diff --git a/indra/llprimitive/llmaterial.cpp b/indra/llprimitive/llmaterial.cpp index f6fd8e557a..7d1ce4ab86 100644 --- a/indra/llprimitive/llmaterial.cpp +++ b/indra/llprimitive/llmaterial.cpp @@ -181,3 +181,36 @@ bool LLMaterial::operator != (const LLMaterial& rhs) const { return !(*this == rhs); } + + +U32 LLMaterial::getShaderMask() +{ //NEVER incorporate this value into the message system -- this function will vary depending on viewer implementation + U32 ret = 0; + + //two least significant bits are "diffuse alpha mode" + ret = getDiffuseAlphaMode(); + + llassert(ret < SHADER_COUNT); + + //next bit is whether or not specular map is present + const U32 SPEC_BIT = 0x4; + + if (getSpecularID().notNull()) + { + ret |= SPEC_BIT; + } + + llassert(ret < SHADER_COUNT); + + //next bit is whether or not normal map is present + const U32 NORM_BIT = 0x8; + if (getNormalID().notNull()) + { + ret |= NORM_BIT; + } + + llassert(ret < SHADER_COUNT); + + return ret; +} + diff --git a/indra/llprimitive/llmaterial.h b/indra/llprimitive/llmaterial.h index 5b56d11cd2..fd35045e45 100644 --- a/indra/llprimitive/llmaterial.h +++ b/indra/llprimitive/llmaterial.h @@ -36,6 +36,20 @@ class LLMaterial { public: + + typedef enum + { + DIFFUSE_ALPHA_MODE_NONE = 0, + DIFFUSE_ALPHA_MODE_BLEND = 1, + DIFFUSE_ALPHA_MODE_MASK = 2, + DIFFUSE_ALPHA_MODE_EMISSIVE = 3 + } eDiffuseAlphaMode; + + typedef enum + { + SHADER_COUNT = 16 + } eShaderCount; + LLMaterial(); LLMaterial(const LLSD& material_data); @@ -77,6 +91,8 @@ public: bool operator == (const LLMaterial& rhs) const; bool operator != (const LLMaterial& rhs) const; + U32 getShaderMask(); + protected: LLUUID mNormalID; F32 mNormalOffsetX; diff --git a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl index 4f7fc6a411..5392466b25 100644 --- a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl +++ b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl @@ -23,6 +23,12 @@ * $/LicenseInfo$ */ +#define DIFFUSE_ALPHA_MODE_IGNORE 0 +#define DIFFUSE_ALPHA_MODE_BLEND 1 +#define DIFFUSE_ALPHA_MODE_MASK 2 +#define DIFFUSE_ALPHA_MODE_GLOW 3 + + #ifdef DEFINE_GL_FRAGCOLOR out vec4 frag_data[3]; #else @@ -31,36 +37,52 @@ out vec4 frag_data[3]; uniform sampler2D diffuseMap; +#if HAS_NORMAL_MAP uniform sampler2D bumpMap; +#endif +#if HAS_SPECULAR_MAP uniform sampler2D specularMap; uniform float env_intensity; +#endif + uniform vec4 specular_color; -#ifdef ALPHA_TEST +#if DIFFUSE_ALPHA_MODE == DIFFUSE_ALPHA_MODE_MASK uniform float minimum_alpha; #endif +#if HAS_NORMAL_MAP VARYING vec3 vary_mat0; VARYING vec3 vary_mat1; VARYING vec3 vary_mat2; +#else +VARYING vec3 vary_normal; +#endif VARYING vec4 vertex_color; VARYING vec2 vary_texcoord0; + void main() { - vec4 col = texture2D(diffuseMap, vary_texcoord0.xy) * vertex_color; + vec4 col = texture2D(diffuseMap, vary_texcoord0.xy); + col.rgb *= vertex_color.rgb; - #ifdef ALPHA_TEST +#if DIFFUSE_ALPHA_MODE == DIFFUSE_ALPHA_MODE_MASK if (col.a < minimum_alpha) { discard; } - #endif - +#endif + +#if HAS_SPECULAR_MAP vec4 spec = texture2D(specularMap, vary_texcoord0.xy); +#else + vec4 spec = specular_color; +#endif +#if HAS_NORMAL_MAP vec4 norm = texture2D(bumpMap, vary_texcoord0.xy); norm.xyz = norm.xyz * 2 - 1; @@ -68,19 +90,29 @@ void main() vec3 tnorm = vec3(dot(norm.xyz,vary_mat0), dot(norm.xyz,vary_mat1), dot(norm.xyz,vary_mat2)); +#else + vec4 norm = vec4(0,0,0,1.0); + vec3 tnorm = vary_normal; +#endif vec4 final_color = col; - final_color.rgb *= 1 - spec.a * env_intensity; - - #ifndef EMISSIVE_MASK + +#if DIFFUSE_ALPHA_MODE != DIFFUSE_ALPHA_MODE_GLOW final_color.a = 0; - #endif +#endif vec4 final_specular = spec; +#if HAS_SPECULAR_MAP + //final_color.rgb *= 1 - spec.a * env_intensity; final_specular.rgb *= specular_color.rgb; - final_specular.a = specular_color.a * norm.a; - + vec4 final_normal = vec4(normalize(tnorm), spec.a * env_intensity); + final_specular.a = specular_color.a * spec.a; +#else + vec4 final_normal = vec4(normalize(tnorm), 0.0); + final_specular.a = spec.a; +#endif + final_normal.xyz = final_normal.xyz * 0.5 + 0.5; frag_data[0] = final_color; diff --git a/indra/newview/app_settings/shaders/class1/deferred/materialV.glsl b/indra/newview/app_settings/shaders/class1/deferred/materialV.glsl index c8d38bb8f7..f92ad63100 100644 --- a/indra/newview/app_settings/shaders/class1/deferred/materialV.glsl +++ b/indra/newview/app_settings/shaders/class1/deferred/materialV.glsl @@ -31,11 +31,17 @@ ATTRIBUTE vec3 position; ATTRIBUTE vec4 diffuse_color; ATTRIBUTE vec3 normal; ATTRIBUTE vec2 texcoord0; + +#if HAS_NORMAL_MAP ATTRIBUTE vec3 binormal; VARYING vec3 vary_mat0; VARYING vec3 vary_mat1; VARYING vec3 vary_mat2; +#else +VARYING vec3 vary_normal; +#endif + VARYING vec4 vertex_color; VARYING vec2 vary_texcoord0; @@ -45,13 +51,18 @@ void main() gl_Position = modelview_projection_matrix * vec4(position.xyz, 1.0); vary_texcoord0 = (texture_matrix0 * vec4(texcoord0,0,1)).xy; + vec3 n = normalize(normal_matrix * normal); +#if HAS_NORMAL_MAP vec3 b = normalize(normal_matrix * binormal); vec3 t = cross(b, n); vary_mat0 = vec3(t.x, b.x, n.x); vary_mat1 = vec3(t.y, b.y, n.y); vary_mat2 = vec3(t.z, b.z, n.z); +#else + vary_normal = n; +#endif vertex_color = diffuse_color; } diff --git a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl index 2905cc91b6..f50935c1a8 100644 --- a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl +++ b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl @@ -310,7 +310,7 @@ void main() //add environmentmap vec3 env_vec = env_mat * refnormpersp; col = mix(col.rgb, textureCube(environmentMap, env_vec).rgb, - max(spec.a-diffuse.a*2.0, 0.0)); + max(norm.a-diffuse.a*2.0, 0.0)); } col = atmosLighting(col); diff --git a/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl index 9df9d75905..ff20b63972 100644 --- a/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl +++ b/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl @@ -278,8 +278,8 @@ void main() vec2 tc = vary_fragcoord.xy; float depth = texture2DRect(depthMap, tc.xy).r; vec3 pos = getPosition_d(tc, depth).xyz; - vec3 norm = texture2DRect(normalMap, tc).xyz; - norm = (norm.xyz-0.5)*2.0; // unpack norm + vec4 norm = texture2DRect(normalMap, tc); + norm.xyz = (norm.xyz-0.5)*2.0; // unpack norm float da = max(dot(norm.xyz, sun_dir.xyz), 0.0); @@ -319,7 +319,7 @@ void main() //add environmentmap vec3 env_vec = env_mat * refnormpersp; col = mix(col.rgb, textureCube(environmentMap, env_vec).rgb, - max(spec.a-diffuse.a*2.0, 0.0)); + max(norm.a-diffuse.a*2.0, 0.0)); } col = atmosLighting(col); diff --git a/indra/newview/lldrawpool.h b/indra/newview/lldrawpool.h index caa57ad583..77067cc1ec 100644 --- a/indra/newview/lldrawpool.h +++ b/indra/newview/lldrawpool.h @@ -134,7 +134,22 @@ public: PASS_SHINY, PASS_BUMP, PASS_POST_BUMP, - PASS_MATERIALS, + PASS_MATERIAL, + PASS_MATERIAL_ALPHA, + PASS_MATERIAL_ALPHA_MASK, + PASS_MATERIAL_ALPHA_GLOW, + PASS_SPECMAP, + PASS_SPECMAP_BLEND, + PASS_SPECMAP_MASK, + PASS_SPECMAP_GLOW, + PASS_NORMMAP, + PASS_NORMMAP_BLEND, + PASS_NORMMAP_MASK, + PASS_NORMMAP_GLOW, + PASS_NORMSPEC, + PASS_NORMSPEC_BLEND, + PASS_NORMSPEC_MASK, + PASS_NORMSPEC_GLOW, PASS_GLOW, PASS_ALPHA, PASS_ALPHA_MASK, diff --git a/indra/newview/lldrawpoolmaterials.cpp b/indra/newview/lldrawpoolmaterials.cpp index f0e1221f15..b126dc3b4a 100644 --- a/indra/newview/lldrawpoolmaterials.cpp +++ b/indra/newview/lldrawpoolmaterials.cpp @@ -44,20 +44,75 @@ void LLDrawPoolMaterials::prerender() mVertexShaderLevel = LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_OBJECT); } +S32 LLDrawPoolMaterials::getNumDeferredPasses() +{ + return 12; +} + void LLDrawPoolMaterials::beginDeferredPass(S32 pass) { + U32 shader_idx[] = + { + 0, //LLRenderPass::PASS_MATERIAL, + //1, //LLRenderPass::PASS_MATERIAL_ALPHA, + 2, //LLRenderPass::PASS_MATERIAL_ALPHA_MASK, + 3, //LLRenderPass::PASS_MATERIAL_ALPHA_GLOW, + 4, //LLRenderPass::PASS_SPECMAP, + //5, //LLRenderPass::PASS_SPECMAP_BLEND, + 6, //LLRenderPass::PASS_SPECMAP_MASK, + 7, //LLRenderPass::PASS_SPECMAP_GLOW, + 8, //LLRenderPass::PASS_NORMMAP, + //9, //LLRenderPass::PASS_NORMMAP_BLEND, + 10, //LLRenderPass::PASS_NORMMAP_MASK, + 11, //LLRenderPass::PASS_NORMMAP_GLOW, + 12, //LLRenderPass::PASS_NORMSPEC, + //13, //LLRenderPass::PASS_NORMSPEC_BLEND, + 14, //LLRenderPass::PASS_NORMSPEC_MASK, + 15, //LLRenderPass::PASS_NORMSPEC_GLOW, + }; + + mShader = &(gDeferredMaterialProgram[shader_idx[pass]]); + mShader->bind(); + + diffuse_channel = mShader->enableTexture(LLShaderMgr::DIFFUSE_MAP); + LLFastTimer t(FTM_RENDER_MATERIALS); } void LLDrawPoolMaterials::endDeferredPass(S32 pass) { LLFastTimer t(FTM_RENDER_MATERIALS); + + mShader->unbind(); + LLRenderPass::endRenderPass(pass); } void LLDrawPoolMaterials::renderDeferred(S32 pass) { - U32 type = LLRenderPass::PASS_MATERIALS; + U32 type_list[] = + { + LLRenderPass::PASS_MATERIAL, + //LLRenderPass::PASS_MATERIAL_ALPHA, + LLRenderPass::PASS_MATERIAL_ALPHA_MASK, + LLRenderPass::PASS_MATERIAL_ALPHA_GLOW, + LLRenderPass::PASS_SPECMAP, + //LLRenderPass::PASS_SPECMAP_BLEND, + LLRenderPass::PASS_SPECMAP_MASK, + LLRenderPass::PASS_SPECMAP_GLOW, + LLRenderPass::PASS_NORMMAP, + //LLRenderPass::PASS_NORMMAP_BLEND, + LLRenderPass::PASS_NORMMAP_MASK, + LLRenderPass::PASS_NORMMAP_GLOW, + LLRenderPass::PASS_NORMSPEC, + //LLRenderPass::PASS_NORMSPEC_BLEND, + LLRenderPass::PASS_NORMSPEC_MASK, + LLRenderPass::PASS_NORMSPEC_GLOW, + }; + + llassert(pass < sizeof(type_list)/sizeof(U32)); + + U32 type = type_list[pass]; LLCullResult::drawinfo_iterator begin = gPipeline.beginRenderMap(type); LLCullResult::drawinfo_iterator end = gPipeline.endRenderMap(type); @@ -65,27 +120,6 @@ void LLDrawPoolMaterials::renderDeferred(S32 pass) { LLDrawInfo& params = **i; - switch (params.mDiffuseAlphaMode) - { - case 0: - mShader = &gDeferredMaterialShinyNormal; - mShader->bind(); - break; - case 1: // Alpha blending not supported in the opaque draw pool. - return; - case 2: - mShader = &gDeferredMaterialShinyNormalAlphaTest; - mShader->bind(); - mShader->setMinimumAlpha(params.mAlphaMaskCutoff); - break; - case 3: - mShader = &gDeferredMaterialShinyNormalEmissive; - mShader->bind(); - break; - }; - - - mShader->uniform4f(LLShaderMgr::SPECULAR_COLOR, params.mSpecColor.mV[0], params.mSpecColor.mV[1], params.mSpecColor.mV[2], params.mSpecColor.mV[3]); mShader->uniform1f(LLShaderMgr::ENVIRONMENT_INTENSITY, params.mEnvIntensity); @@ -101,10 +135,9 @@ void LLDrawPoolMaterials::renderDeferred(S32 pass) bindSpecularMap(params.mSpecularMap); } - diffuse_channel = mShader->enableTexture(LLShaderMgr::DIFFUSE_MAP); + mShader->setMinimumAlpha(params.mAlphaMaskCutoff); + pushBatch(params, VERTEX_DATA_MASK, TRUE); - mShader->disableTexture(LLShaderMgr::DIFFUSE_MAP); - mShader->unbind(); } } @@ -118,72 +151,6 @@ void LLDrawPoolMaterials::bindNormalMap(LLViewerTexture* tex) mShader->bindTexture(LLShaderMgr::BUMP_MAP, tex); } -void LLDrawPoolMaterials::beginRenderPass(S32 pass) -{ - LLFastTimer t(FTM_RENDER_MATERIALS); - - // Materials isn't supported under forward rendering. - // Use the simple shaders to handle it instead. - // This is basically replicated from LLDrawPoolSimple. - - if (LLPipeline::sUnderWaterRender) - { - mShader = &gObjectSimpleWaterProgram; - } - else - { - mShader = &gObjectSimpleProgram; - } - - if (mVertexShaderLevel > 0) - { - mShader->bind(); - } - else - { - // don't use shaders! - if (gGLManager.mHasShaderObjects) - { - LLGLSLShader::bindNoShader(); - } - } -} - -void LLDrawPoolMaterials::endRenderPass(S32 pass) -{ - LLFastTimer t(FTM_RENDER_MATERIALS); - stop_glerror(); - LLRenderPass::endRenderPass(pass); - stop_glerror(); - if (mVertexShaderLevel > 0) - { - mShader->unbind(); - } -} - -void LLDrawPoolMaterials::render(S32 pass) -{ - LLGLDisable blend(GL_BLEND); - - { //render simple - LLFastTimer t(FTM_RENDER_MATERIALS); - gPipeline.enableLightsDynamic(); - - if (mVertexShaderLevel > 0) - { - U32 mask = getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX; - - pushBatches(LLRenderPass::PASS_MATERIALS, mask, TRUE, TRUE); - } - else - { - LLGLDisable alpha_test(GL_ALPHA_TEST); - renderTexture(LLRenderPass::PASS_MATERIALS, getVertexDataMask()); - } - } -} - - void LLDrawPoolMaterials::pushBatch(LLDrawInfo& params, U32 mask, BOOL texture, BOOL batch_textures) { applyModelMatrix(params); diff --git a/indra/newview/lldrawpoolmaterials.h b/indra/newview/lldrawpoolmaterials.h index e8838c64d6..1f5565afc8 100644 --- a/indra/newview/lldrawpoolmaterials.h +++ b/indra/newview/lldrawpoolmaterials.h @@ -55,13 +55,11 @@ public: /*virtual*/ U32 getVertexDataMask() { return VERTEX_DATA_MASK; } - /*virtual*/ void render(S32 pass = 0); - /*virtual*/ void beginRenderPass( S32 pass ); - /*virtual*/ void endRenderPass( S32 pass ); - /*virtual*/ S32 getNumPasses() {return 1;} + /*virtual*/ void render(S32 pass = 0) { } + /*virtual*/ S32 getNumPasses() {return 0;} /*virtual*/ void prerender(); - /*virtual*/ S32 getNumDeferredPasses() {return 1;} + /*virtual*/ S32 getNumDeferredPasses(); /*virtual*/ void beginDeferredPass(S32 pass); /*virtual*/ void endDeferredPass(S32 pass); /*virtual*/ void renderDeferred(S32 pass); diff --git a/indra/newview/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp index cef07984e0..71cd87cc85 100644 --- a/indra/newview/llviewerdisplay.cpp +++ b/indra/newview/llviewerdisplay.cpp @@ -1087,7 +1087,7 @@ void render_hud_attachments() gPipeline.toggleRenderType(LLPipeline::RENDER_TYPE_PASS_ALPHA); gPipeline.toggleRenderType(LLPipeline::RENDER_TYPE_PASS_ALPHA_MASK); gPipeline.toggleRenderType(LLPipeline::RENDER_TYPE_PASS_BUMP); - gPipeline.toggleRenderType(LLPipeline::RENDER_TYPE_PASS_MATERIALS); + gPipeline.toggleRenderType(LLPipeline::RENDER_TYPE_PASS_MATERIAL); gPipeline.toggleRenderType(LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT); gPipeline.toggleRenderType(LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT_ALPHA_MASK); gPipeline.toggleRenderType(LLPipeline::RENDER_TYPE_PASS_FULLBRIGHT_SHINY); diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp index 17bfc24f43..4e38d2f7e9 100644 --- a/indra/newview/llviewershadermgr.cpp +++ b/indra/newview/llviewershadermgr.cpp @@ -208,15 +208,7 @@ LLGLSLShader gDeferredStarProgram; LLGLSLShader gNormalMapGenProgram; // Deferred materials shaders -LLGLSLShader gDeferredMaterialShiny; -LLGLSLShader gDeferredMaterialNormal; -LLGLSLShader gDeferredMaterialShinyNormal; -LLGLSLShader gDeferredMaterialShinyAlphaTest; -LLGLSLShader gDeferredMaterialNormalAlphaTest; -LLGLSLShader gDeferredMaterialShinyNormalAlphaTest; -LLGLSLShader gDeferredMaterialShinyEmissive; -LLGLSLShader gDeferredMaterialNormalEmissive; -LLGLSLShader gDeferredMaterialShinyNormalEmissive; +LLGLSLShader gDeferredMaterialProgram[LLMaterial::SHADER_COUNT]; LLViewerShaderMgr::LLViewerShaderMgr() : mVertexShaderLevel(SHADER_COUNT, 0), @@ -1116,12 +1108,10 @@ BOOL LLViewerShaderMgr::loadShadersDeferred() gDeferredWLCloudProgram.unload(); gDeferredStarProgram.unload(); gNormalMapGenProgram.unload(); - gDeferredMaterialShiny.unload(); - gDeferredMaterialNormal.unload(); - gDeferredMaterialShinyAlphaTest.unload(); - gDeferredMaterialNormalAlphaTest.unload(); - gDeferredMaterialShinyEmissive.unload(); - gDeferredMaterialNormalEmissive.unload(); + for (U32 i = 0; i < LLMaterial::SHADER_COUNT; ++i) + { + gDeferredMaterialProgram[i].unload(); + } return TRUE; } @@ -1236,114 +1226,28 @@ BOOL LLViewerShaderMgr::loadShadersDeferred() success = gDeferredBumpProgram.createShader(NULL, NULL); } - if (success) - { - gDeferredMaterialShiny.mName = "Deferred Shiny Material Shader"; - gDeferredMaterialShiny.mShaderFiles.clear(); - gDeferredMaterialShiny.mShaderFiles.push_back(make_pair("deferred/materialV.glsl", GL_VERTEX_SHADER_ARB)); - gDeferredMaterialShiny.mShaderFiles.push_back(make_pair("deferred/materialF.glsl", GL_FRAGMENT_SHADER_ARB)); - gDeferredMaterialShiny.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED]; - gDeferredMaterialShiny.addPermutation("SHINY_MATERIAL", "1"); - success = gDeferredMaterialShiny.createShader(NULL, NULL); - } - - if (success) - { - gDeferredMaterialNormal.mName = "Deferred Normal Mapped Material Shader"; - gDeferredMaterialNormal.mShaderFiles.clear(); - gDeferredMaterialNormal.mShaderFiles.push_back(make_pair("deferred/materialV.glsl", GL_VERTEX_SHADER_ARB)); - gDeferredMaterialNormal.mShaderFiles.push_back(make_pair("deferred/materialF.glsl", GL_FRAGMENT_SHADER_ARB)); - gDeferredMaterialNormal.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED]; - gDeferredMaterialNormal.addPermutation("NORMAL_MATERIAL", "1"); - success = gDeferredMaterialNormal.createShader(NULL, NULL); - } - - if (success) - { - gDeferredMaterialShinyNormal.mName = "Deferred Normal Mapped Shiny Material Shader"; - gDeferredMaterialShinyNormal.mShaderFiles.clear(); - gDeferredMaterialShinyNormal.mShaderFiles.push_back(make_pair("deferred/materialV.glsl", GL_VERTEX_SHADER_ARB)); - gDeferredMaterialShinyNormal.mShaderFiles.push_back(make_pair("deferred/materialF.glsl", GL_FRAGMENT_SHADER_ARB)); - gDeferredMaterialShinyNormal.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED]; - gDeferredMaterialShinyNormal.addPermutation("NORMAL_MATERIAL", "1"); - gDeferredMaterialShinyNormal.addPermutation("SHINY_MATERIAL", "1"); - success = gDeferredMaterialShinyNormal.createShader(NULL, NULL); - } - - if (success) - { - gDeferredMaterialShinyAlphaTest.mName = "Deferred Alpha Tested Shiny Material Shader"; - gDeferredMaterialShinyAlphaTest.mShaderFiles.clear(); - gDeferredMaterialShinyAlphaTest.mShaderFiles.push_back(make_pair("deferred/materialV.glsl", GL_VERTEX_SHADER_ARB)); - gDeferredMaterialShinyAlphaTest.mShaderFiles.push_back(make_pair("deferred/materialF.glsl", GL_FRAGMENT_SHADER_ARB)); - gDeferredMaterialShinyAlphaTest.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED]; - gDeferredMaterialShinyAlphaTest.addPermutation("SHINY_MATERIAL", "1"); - gDeferredMaterialShinyAlphaTest.addPermutation("ALPHA_TEST", "1"); - success = gDeferredMaterialShinyAlphaTest.createShader(NULL, NULL); - } - - if (success) - { - gDeferredMaterialNormalAlphaTest.mName = "Deferred Alpha Tested Normal Mapped Material Shader"; - gDeferredMaterialNormalAlphaTest.mShaderFiles.clear(); - gDeferredMaterialNormalAlphaTest.mShaderFiles.push_back(make_pair("deferred/materialV.glsl", GL_VERTEX_SHADER_ARB)); - gDeferredMaterialNormalAlphaTest.mShaderFiles.push_back(make_pair("deferred/materialF.glsl", GL_FRAGMENT_SHADER_ARB)); - gDeferredMaterialNormalAlphaTest.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED]; - gDeferredMaterialNormalAlphaTest.addPermutation("NORMAL_MATERIAL", "1"); - gDeferredMaterialNormalAlphaTest.addPermutation("ALPHA_TEST", "1"); - success = gDeferredMaterialNormalAlphaTest.createShader(NULL, NULL); - } - - if (success) - { - gDeferredMaterialNormalAlphaTest.mName = "Deferred Alpha Tested Shiny Normal Mapped Material Shader"; - gDeferredMaterialShinyNormalAlphaTest.mShaderFiles.clear(); - gDeferredMaterialShinyNormalAlphaTest.mShaderFiles.push_back(make_pair("deferred/materialV.glsl", GL_VERTEX_SHADER_ARB)); - gDeferredMaterialShinyNormalAlphaTest.mShaderFiles.push_back(make_pair("deferred/materialF.glsl", GL_FRAGMENT_SHADER_ARB)); - gDeferredMaterialShinyNormalAlphaTest.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED]; - gDeferredMaterialShinyNormalAlphaTest.addPermutation("NORMAL_MATERIAL", "1"); - gDeferredMaterialShinyNormalAlphaTest.addPermutation("SHINY_MATERIAL", "1"); - gDeferredMaterialShinyNormalAlphaTest.addPermutation("ALPHA_TEST", "1"); - success = gDeferredMaterialShinyNormalAlphaTest.createShader(NULL, NULL); - } - - if (success) - { - gDeferredMaterialShinyEmissive.mName = "Deferred Emissive Mask Shiny Material Shader"; - gDeferredMaterialShinyEmissive.mShaderFiles.clear(); - gDeferredMaterialShinyEmissive.mShaderFiles.push_back(make_pair("deferred/materialV.glsl", GL_VERTEX_SHADER_ARB)); - gDeferredMaterialShinyEmissive.mShaderFiles.push_back(make_pair("deferred/materialF.glsl", GL_FRAGMENT_SHADER_ARB)); - gDeferredMaterialShinyEmissive.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED]; - gDeferredMaterialShinyEmissive.addPermutation("SHINY_MATERIAL", "1"); - gDeferredMaterialShinyEmissive.addPermutation("EMISSIVE_MASK", "1"); - success = gDeferredMaterialShinyEmissive.createShader(NULL, NULL); - } - - if (success) - { - gDeferredMaterialNormalEmissive.mName = "Deferred Emissive Mask Normal Mapped Material Shader"; - gDeferredMaterialNormalEmissive.mShaderFiles.clear(); - gDeferredMaterialNormalEmissive.mShaderFiles.push_back(make_pair("deferred/materialV.glsl", GL_VERTEX_SHADER_ARB)); - gDeferredMaterialNormalEmissive.mShaderFiles.push_back(make_pair("deferred/materialF.glsl", GL_FRAGMENT_SHADER_ARB)); - gDeferredMaterialNormalEmissive.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED]; - gDeferredMaterialNormalEmissive.addPermutation("NORMAL_MATERIAL", "1"); - gDeferredMaterialNormalEmissive.addPermutation("EMISSIVE_MASK", "1"); - success = gDeferredMaterialNormalEmissive.createShader(NULL, NULL); - } - - if (success) + + for (U32 i = 0; i < LLMaterial::SHADER_COUNT; ++i) { - gDeferredMaterialShinyNormalEmissive.mName = "Deferred Emissive Mask Normal Mapped Material Shader"; - gDeferredMaterialShinyNormalEmissive.mShaderFiles.clear(); - gDeferredMaterialShinyNormalEmissive.mShaderFiles.push_back(make_pair("deferred/materialV.glsl", GL_VERTEX_SHADER_ARB)); - gDeferredMaterialShinyNormalEmissive.mShaderFiles.push_back(make_pair("deferred/materialF.glsl", GL_FRAGMENT_SHADER_ARB)); - gDeferredMaterialShinyNormalEmissive.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED]; - gDeferredMaterialShinyNormalEmissive.addPermutation("NORMAL_MATERIAL", "1"); - gDeferredMaterialShinyNormalEmissive.addPermutation("SHINY_MATERIAL", "1"); - gDeferredMaterialShinyNormalEmissive.addPermutation("EMISSIVE_MASK", "1"); - success = gDeferredMaterialShinyNormalEmissive.createShader(NULL, NULL); + if (success) + { + gDeferredMaterialProgram[i].mName = llformat("Deferred Material Shader %d", i); + + U32 alpha_mode = i & 0x3; + + gDeferredMaterialProgram[i].mShaderFiles.clear(); + gDeferredMaterialProgram[i].mShaderFiles.push_back(make_pair("deferred/materialV.glsl", GL_VERTEX_SHADER_ARB)); + gDeferredMaterialProgram[i].mShaderFiles.push_back(make_pair("deferred/materialF.glsl", GL_FRAGMENT_SHADER_ARB)); + gDeferredMaterialProgram[i].mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED]; + gDeferredMaterialProgram[i].addPermutation("HAS_NORMAL_MAP", i & 0x8? "1" : "0"); + gDeferredMaterialProgram[i].addPermutation("HAS_SPECULAR_MAP", i & 0x4 ? "1" : "0"); + gDeferredMaterialProgram[i].addPermutation("DIFFUSE_ALPHA_MODE", llformat("%d", alpha_mode)); + + success = gDeferredMaterialProgram[i].createShader(NULL, NULL); + } } + if (success) { gDeferredTreeProgram.mName = "Deferred Tree Shader"; diff --git a/indra/newview/llviewershadermgr.h b/indra/newview/llviewershadermgr.h index 15bff6882e..f0bf352e75 100644 --- a/indra/newview/llviewershadermgr.h +++ b/indra/newview/llviewershadermgr.h @@ -28,6 +28,7 @@ #define LL_VIEWER_SHADER_MGR_H #include "llshadermgr.h" +#include "llmaterial.h" class LLViewerShaderMgr: public LLShaderMgr { @@ -363,14 +364,6 @@ extern LLGLSLShader gDeferredStarProgram; extern LLGLSLShader gNormalMapGenProgram; // Deferred materials shaders -extern LLGLSLShader gDeferredMaterialShiny; -extern LLGLSLShader gDeferredMaterialNormal; -extern LLGLSLShader gDeferredMaterialShinyNormal; -extern LLGLSLShader gDeferredMaterialShinyAlphaTest; -extern LLGLSLShader gDeferredMaterialNormalAlphaTest; -extern LLGLSLShader gDeferredMaterialShinyNormalAlphaTest; -extern LLGLSLShader gDeferredMaterialShinyEmissive; -extern LLGLSLShader gDeferredMaterialNormalEmissive; -extern LLGLSLShader gDeferredMaterialShinyNormalEmissive; +extern LLGLSLShader gDeferredMaterialProgram[LLMaterial::SHADER_COUNT]; #endif diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp index 44eefd3c4a..f149c50884 100644 --- a/indra/newview/llvovolume.cpp +++ b/indra/newview/llvovolume.cpp @@ -4143,16 +4143,16 @@ void LLVolumeGeometryManager::registerFace(LLSpatialGroup* group, LLFace* facep, // We have a material. Update our draw info accordingly. draw_info->mMaterialID = &facep->getTextureEntry()->getMaterialID(); LLVector4 specColor; - specColor.mV[0] = facep->getTextureEntry()->getMaterialParams()->getSpecularLightColor().mV[0] * (1.0 / 255); - specColor.mV[1] = facep->getTextureEntry()->getMaterialParams()->getSpecularLightColor().mV[1] * (1.0 / 255); - specColor.mV[2] = facep->getTextureEntry()->getMaterialParams()->getSpecularLightColor().mV[2] * (1.0 / 255); - specColor.mV[3] = facep->getTextureEntry()->getMaterialParams()->getSpecularLightExponent() * (1.0 / 255); + specColor.mV[0] = facep->getTextureEntry()->getMaterialParams()->getSpecularLightColor().mV[0] * (1.f / 255.f); + specColor.mV[1] = facep->getTextureEntry()->getMaterialParams()->getSpecularLightColor().mV[1] * (1.f / 255.f); + specColor.mV[2] = facep->getTextureEntry()->getMaterialParams()->getSpecularLightColor().mV[2] * (1.f / 255.f); + specColor.mV[3] = facep->getTextureEntry()->getMaterialParams()->getSpecularLightExponent() * (1.f / 255.f); draw_info->mSpecColor = specColor; - draw_info->mEnvIntensity = facep->getTextureEntry()->getMaterialParams()->getEnvironmentIntensity() * (1.0 / 255); - draw_info->mAlphaMaskCutoff = facep->getTextureEntry()->getMaterialParams()->getAlphaMaskCutoff() * (1.0 / 255); + draw_info->mEnvIntensity = facep->getTextureEntry()->getMaterialParams()->getEnvironmentIntensity() * (1.f / 255.f); + draw_info->mAlphaMaskCutoff = facep->getTextureEntry()->getMaterialParams()->getAlphaMaskCutoff() * (1.f / 255.f); draw_info->mDiffuseAlphaMode = facep->getTextureEntry()->getMaterialParams()->getDiffuseAlphaMode(); - draw_info->mNormalMap = facep->getViewerObject()->getTENormalMap(facep->getTextureIndex()); - draw_info->mSpecularMap = facep->getViewerObject()->getTESpecularMap(facep->getTextureIndex()); + draw_info->mNormalMap = facep->getViewerObject()->getTENormalMap(facep->getTEOffset()); + draw_info->mSpecularMap = facep->getViewerObject()->getTESpecularMap(facep->getTEOffset()); } } else { U8 shiny = facep->getTextureEntry()->getShiny(); @@ -5151,7 +5151,39 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, std:: BOOL is_alpha = (facep->getPoolType() == LLDrawPool::POOL_ALPHA) ? TRUE : FALSE; - if (is_alpha) + LLMaterial* mat = te->getMaterialParams().get(); + + if (mat && LLPipeline::sRenderDeferred && !hud_group) + { + U32 pass[] = + { + LLRenderPass::PASS_MATERIAL, + LLRenderPass::PASS_ALPHA, //LLRenderPass::PASS_MATERIAL_ALPHA, + LLRenderPass::PASS_MATERIAL_ALPHA_MASK, + LLRenderPass::PASS_MATERIAL_ALPHA_GLOW, + LLRenderPass::PASS_SPECMAP, + LLRenderPass::PASS_ALPHA, //LLRenderPass::PASS_SPECMAP_BLEND, + LLRenderPass::PASS_SPECMAP_MASK, + LLRenderPass::PASS_SPECMAP_GLOW, + LLRenderPass::PASS_NORMMAP, + LLRenderPass::PASS_ALPHA, //LLRenderPass::PASS_NORMMAP_BLEND, + LLRenderPass::PASS_NORMMAP_MASK, + LLRenderPass::PASS_NORMMAP_GLOW, + LLRenderPass::PASS_NORMSPEC, + LLRenderPass::PASS_ALPHA, //LLRenderPass::PASS_NORMSPEC_BLEND, + LLRenderPass::PASS_NORMSPEC_MASK, + LLRenderPass::PASS_NORMSPEC_GLOW, + }; + + U32 mask = mat->getShaderMask(); + + llassert(mask < sizeof(pass)/sizeof(U32)); + + mask = llmin(mask, sizeof(pass)/sizeof(U32)-1); + + registerFace(group, facep, pass[mask]); + } + else if (is_alpha) { // can we safely treat this as an alpha mask? if (facep->getFaceColor().mV[3] <= 0.f) @@ -5197,10 +5229,6 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, std:: { //register in deferred bump pass registerFace(group, facep, LLRenderPass::PASS_BUMP); } - else if (te->getMaterialParams()) - { - registerFace(group, facep, LLRenderPass::PASS_MATERIALS); - } else { //register in deferred simple pass (deferred simple includes shiny) llassert(mask & LLVertexBuffer::MAP_NORMAL); @@ -5236,10 +5264,6 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, std:: { //non-shiny or fullbright deferred bump registerFace(group, facep, LLRenderPass::PASS_BUMP); } - else if (te->getMaterialParams()) - { - registerFace(group, facep, LLRenderPass::PASS_MATERIALS); - } else { //all around simple llassert(mask & LLVertexBuffer::MAP_NORMAL); diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp index d8f7f8350a..c5fedab8c0 100644 --- a/indra/newview/pipeline.cpp +++ b/indra/newview/pipeline.cpp @@ -399,7 +399,7 @@ void validate_framebuffer_object(); bool addDeferredAttachments(LLRenderTarget& target) { return target.addColorAttachment(GL_RGBA) && //specular - target.addColorAttachment(GL_RGB10_A2); //normal+z + target.addColorAttachment(GL_RGBA); //normal+z } LLPipeline::LLPipeline() : diff --git a/indra/newview/pipeline.h b/indra/newview/pipeline.h index 22a0ca6a2f..fd4813e415 100644 --- a/indra/newview/pipeline.h +++ b/indra/newview/pipeline.h @@ -437,7 +437,7 @@ public: RENDER_TYPE_PASS_SHINY = LLRenderPass::PASS_SHINY, RENDER_TYPE_PASS_BUMP = LLRenderPass::PASS_BUMP, RENDER_TYPE_PASS_POST_BUMP = LLRenderPass::PASS_POST_BUMP, - RENDER_TYPE_PASS_MATERIALS = LLRenderPass::PASS_MATERIALS, + RENDER_TYPE_PASS_MATERIAL = LLRenderPass::PASS_MATERIAL, RENDER_TYPE_PASS_GLOW = LLRenderPass::PASS_GLOW, RENDER_TYPE_PASS_ALPHA = LLRenderPass::PASS_ALPHA, RENDER_TYPE_PASS_ALPHA_MASK = LLRenderPass::PASS_ALPHA_MASK, -- cgit v1.3 From 9e3155c368fba6cb877c55ad4e0c90258a6e9ba9 Mon Sep 17 00:00:00 2001 From: "Graham Madarasz (Graham)" Date: Mon, 8 Apr 2013 11:40:10 -0700 Subject: NORSPEC-82 NORSPEC-85 More UI shenanigans --- indra/llprimitive/llmaterial.cpp | 6 +- indra/llprimitive/llmaterial.h | 4 + indra/newview/llpanelface.cpp | 305 +++++++++++++++++++++++++-------------- indra/newview/llpanelface.h | 5 +- 4 files changed, 207 insertions(+), 113 deletions(-) (limited to 'indra/llprimitive/llmaterial.cpp') diff --git a/indra/llprimitive/llmaterial.cpp b/indra/llprimitive/llmaterial.cpp index 7d1ce4ab86..1e92847b38 100644 --- a/indra/llprimitive/llmaterial.cpp +++ b/indra/llprimitive/llmaterial.cpp @@ -51,6 +51,8 @@ #define MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD "AlphaMaskCutoff" #define MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD "DiffuseAlphaMode" +const LLColor4U LLMaterial::DEFAULT_SPECULAR_LIGHT_COLOR = LLColor4U::white; + /** * Materials constants */ @@ -99,7 +101,8 @@ LLMaterial::LLMaterial() , mSpecularRepeatX(.0f) , mSpecularRepeatY(.0f) , mSpecularRotation(.0f) - , mSpecularLightExponent(0) + , mSpecularLightColor(LLMaterial::DEFAULT_SPECULAR_LIGHT_COLOR) + , mSpecularLightExponent(LLMaterial::DEFAULT_SPECULAR_LIGHT_EXPONENT) , mEnvironmentIntensity(0) , mDiffuseAlphaMode(0) , mAlphaMaskCutoff(0) @@ -214,3 +217,4 @@ U32 LLMaterial::getShaderMask() return ret; } + diff --git a/indra/llprimitive/llmaterial.h b/indra/llprimitive/llmaterial.h index dc3484309c..bedfc8f8c2 100644 --- a/indra/llprimitive/llmaterial.h +++ b/indra/llprimitive/llmaterial.h @@ -52,6 +52,9 @@ public: SHADER_COUNT = 16 } eShaderCount; + static const U8 DEFAULT_SPECULAR_LIGHT_EXPONENT = ((U8)(0.2f * 255)); + static const LLColor4U DEFAULT_SPECULAR_LIGHT_COLOR; + LLMaterial(); LLMaterial(const LLSD& material_data); @@ -120,3 +123,4 @@ protected: typedef LLPointer LLMaterialPtr; #endif // LL_LLMATERIAL_H + diff --git a/indra/newview/llpanelface.cpp b/indra/newview/llpanelface.cpp index 3853cfde9e..7e1f797471 100644 --- a/indra/newview/llpanelface.cpp +++ b/indra/newview/llpanelface.cpp @@ -638,6 +638,7 @@ void LLPanelFace::getState() llwarns << "failed getChild for 'combobox mattype'" << llendl; } getChildView("combobox mattype")->setEnabled(editable); + onCommitMaterialsMedia(NULL, this); //if ( LLMediaEngine::getInstance()->getMediaRenderer () ) @@ -879,8 +880,8 @@ void LLPanelFace::getState() } else { - shinytexture_ctrl->setTentative( TRUE ); - shinytexture_ctrl->setEnabled( editable ); + shinytexture_ctrl->setTentative( TRUE ); + shinytexture_ctrl->setEnabled( editable ); shinytexture_ctrl->setImageAssetID( specmap_id ); } } @@ -888,7 +889,7 @@ void LLPanelFace::getState() if (bumpytexture_ctrl) { if (identical_norm) - { + { bumpytexture_ctrl->setTentative( FALSE ); bumpytexture_ctrl->setEnabled( editable ); bumpytexture_ctrl->setImageAssetID( normmap_id ); @@ -897,16 +898,16 @@ void LLPanelFace::getState() { bumpytexture_ctrl->setTentative( FALSE ); bumpytexture_ctrl->setEnabled( FALSE ); - bumpytexture_ctrl->setImageAssetID( LLUUID::null ); - } + bumpytexture_ctrl->setImageAssetID( LLUUID::null ); + } else { - bumpytexture_ctrl->setTentative( TRUE ); - bumpytexture_ctrl->setEnabled( editable ); + bumpytexture_ctrl->setTentative( TRUE ); + bumpytexture_ctrl->setEnabled( editable ); bumpytexture_ctrl->setImageAssetID( normmap_id ); - } } } + } // planar align bool align_planar = false; @@ -945,6 +946,26 @@ void LLPanelFace::getState() } } + // Needs to be public and before tex scale settings below to properly reflect + // behavior when in planar vs default texgen modes in the + // NORSPEC-84 et al + // + LLTextureEntry::e_texgen selected_texgen = LLTextureEntry::TEX_GEN_DEFAULT; + bool identical_texgen = true; + bool identical_planar_texgen = false; + + { + struct f11 : public LLSelectedTEGetFunctor + { + LLTextureEntry::e_texgen get(LLViewerObject* object, S32 face) + { + return (LLTextureEntry::e_texgen)(object->getTE(face)->getTexGen()); + } + } func; + identical_texgen = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, selected_texgen ); + identical_planar_texgen = (identical_texgen && (selected_texgen == LLTextureEntry::TEX_GEN_PLANAR)); + } + // Texture scale { F32 scale_s = 1.f; @@ -958,7 +979,11 @@ void LLPanelFace::getState() identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, scale_s ); identical = align_planar ? identical_planar_aligned : identical; - getChild("TexScaleU")->setValue(editable ? scale_s : 0); + + F32 scale_u = editable ? scale_s : 0; + scale_u *= identical_planar_texgen ? 2.0f : 1.0f; + + getChild("TexScaleU")->setValue(scale_u); getChild("TexScaleU")->setTentative(LLSD((BOOL)(!identical))); getChildView("TexScaleU")->setEnabled(editable); @@ -981,7 +1006,10 @@ void LLPanelFace::getState() identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &shiny_func, scale_s ); identical = align_planar ? identical_planar_aligned : identical; - getChild("shinyScaleU")->setValue(editable ? scale_s : 0); + F32 scale_s_value = editable ? scale_s : 0; + scale_s_value *= identical_planar_texgen ? 2.0f : 1.0f; + + getChild("shinyScaleU")->setValue(scale_s_value); getChild("shinyScaleU")->setTentative(LLSD((BOOL)(!identical))); getChildView("shinyScaleU")->setEnabled(editable && specmap_id.notNull()); @@ -1004,9 +1032,10 @@ void LLPanelFace::getState() identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &bump_func, scale_s ); identical = align_planar ? identical_planar_aligned : identical; - + scale_s_value = editable ? scale_s : 0; + scale_s_value *= identical_planar_texgen ? 2.0f : 1.0f; - getChild("bumpyScaleU")->setValue(editable ? scale_s : 0); + getChild("bumpyScaleU")->setValue(scale_s_value); getChild("bumpyScaleU")->setTentative(LLSD((BOOL)(!identical))); getChildView("bumpyScaleU")->setEnabled(editable && normmap_id.notNull()); } @@ -1023,7 +1052,10 @@ void LLPanelFace::getState() identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, scale_t ); identical = align_planar ? identical_planar_aligned : identical; - getChild("TexScaleV")->setValue(editable ? scale_t : 0); + F32 scale_t_value = editable ? scale_t : 0; + scale_t_value *= identical_planar_texgen ? 2.0f : 1.0f; + + getChild("TexScaleV")->setValue(scale_t_value); getChild("TexScaleV")->setTentative(LLSD((BOOL)(!identical))); getChildView("TexScaleV")->setEnabled(editable); @@ -1045,7 +1077,11 @@ void LLPanelFace::getState() identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &shiny_func, scale_t ); identical = align_planar ? identical_planar_aligned : identical; - getChild("shinyScaleV")->setValue(editable ? scale_t : 0); + + scale_t_value = editable ? scale_t : 0; + scale_t_value *= identical_planar_texgen ? 2.0f : 1.0f; + + getChild("shinyScaleV")->setValue(scale_t_value); getChild("shinyScaleV")->setTentative(LLSD((BOOL)(!identical))); getChildView("shinyScaleV")->setEnabled(editable && specmap_id.notNull()); @@ -1068,7 +1104,10 @@ void LLPanelFace::getState() identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &bump_func, scale_t ); identical = align_planar ? identical_planar_aligned : identical; - getChild("bumpyScaleV")->setValue(editable ? scale_t : 0); + scale_t_value = editable ? scale_t : 0.0f; + scale_t_value *= identical_planar_texgen ? 2.0f : 1.0f; + + getChild("bumpyScaleV")->setValue(scale_t_value); getChild("bumpyScaleV")->setTentative(LLSD((BOOL)(!identical))); getChildView("bumpyScaleV")->setEnabled(editable && normmap_id.notNull()); @@ -1096,7 +1135,7 @@ void LLPanelFace::getState() { F32 get(LLViewerObject* object, S32 face) { - F32 s = 1.f, t = 1.f; + F32 s = 0.f, t = 0.f; LLMaterial* mat = object->getTE(face)->getMaterialParams().get(); if (mat) @@ -1118,7 +1157,7 @@ void LLPanelFace::getState() { F32 get(LLViewerObject* object, S32 face) { - F32 s = 1.f, t = 1.f; + F32 s = 0.f, t = 0.f; LLMaterial* mat = object->getTE(face)->getMaterialParams().get(); if (mat) @@ -1318,20 +1357,20 @@ void LLPanelFace::getState() // Shiny { - F32 shinyf = 0.f; - struct f9 : public LLSelectedTEGetFunctor + U8 shiny = 0; + struct f9 : public LLSelectedTEGetFunctor { - F32 get(LLViewerObject* object, S32 face) + U8 get(LLViewerObject* object, S32 face) { - return (F32)(object->getTE(face)->getShiny()); + return (U8)(object->getTE(face)->getShiny()); } } func; - identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, shinyf ); + identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, shiny ); LLCtrlSelectionInterface* combobox_shininess = childGetSelectionInterface("combobox shininess"); if (combobox_shininess) { - combobox_shininess->selectNthItem((S32)shinyf); + combobox_shininess->selectNthItem((S32)shiny); } else { @@ -1353,20 +1392,20 @@ void LLPanelFace::getState() // Bumpy { - F32 bumpf = 0.f; - struct f10 : public LLSelectedTEGetFunctor + U8 bumpy = 0; + struct f10 : public LLSelectedTEGetFunctor { - F32 get(LLViewerObject* object, S32 face) + U8 get(LLViewerObject* object, S32 face) { - return (F32)(object->getTE(face)->getBumpmap()); + return object->getTE(face)->getBumpmap(); } } func; - identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, bumpf ); + identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, bumpy ); LLCtrlSelectionInterface* combobox_bumpiness = childGetSelectionInterface("combobox bumpiness"); if (combobox_bumpiness) { - combobox_bumpiness->selectNthItem((S32)bumpf); + combobox_bumpiness->selectNthItem((S32)bumpy); } else { @@ -1377,22 +1416,12 @@ void LLPanelFace::getState() getChildView("label bumpiness")->setEnabled(editable); } - { - F32 genf = 0.f; - struct f11 : public LLSelectedTEGetFunctor - { - F32 get(LLViewerObject* object, S32 face) - { - return (F32)(object->getTE(face)->getTexGen()); - } - } func; - identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, genf ); - S32 selected_texgen = ((S32) genf) >> TEM_TEX_GEN_SHIFT; + { LLCtrlSelectionInterface* combobox_texgen = childGetSelectionInterface("combobox texgen"); if (combobox_texgen) { - combobox_texgen->selectNthItem(selected_texgen); + combobox_texgen->selectNthItem(((S32)selected_texgen) >> 1); // Maps from enum to combobox entry index } else { @@ -1402,37 +1431,30 @@ void LLPanelFace::getState() getChild("combobox texgen")->setTentative(!identical); getChildView("tex gen")->setEnabled(editable); - if (selected_texgen == 1) + if (selected_texgen == LLTextureEntry::TEX_GEN_PLANAR) { - getChild("TexScaleU")->setValue(2.0f * getChild("TexScaleU")->getValue().asReal() ); - getChild("TexScaleV")->setValue(2.0f * getChild("TexScaleV")->getValue().asReal() ); - getChild("shinyScaleU")->setValue(2.0f * getChild("shinyScaleU")->getValue().asReal() ); - getChild("shinyScaleV")->setValue(2.0f * getChild("shinyScaleV")->getValue().asReal() ); - getChild("bumpyScaleU")->setValue(2.0f * getChild("bumpScaleU")->getValue().asReal() ); - getChild("bumpyScaleV")->setValue(2.0f * getChild("bumpScaleV")->getValue().asReal() ); - // EXP-1507 (change label based on the mapping mode) getChild("rpt")->setValue(getString("string repeats per meter")); } else - if (selected_texgen == 0) // FIXME: should not be magic numbers + if (selected_texgen == LLTextureEntry::TEX_GEN_DEFAULT) { getChild("rpt")->setValue(getString("string repeats per face")); } } { - F32 fullbrightf = 0.f; - struct f12 : public LLSelectedTEGetFunctor + U8 fullbright_flag = 0; + struct f12 : public LLSelectedTEGetFunctor { - F32 get(LLViewerObject* object, S32 face) + U8 get(LLViewerObject* object, S32 face) { - return (F32)(object->getTE(face)->getFullbright()); + return object->getTE(face)->getFullbright(); } } func; - identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, fullbrightf ); + identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, fullbright_flag ); - getChild("checkbox fullbright")->setValue((S32)fullbrightf); + getChild("checkbox fullbright")->setValue((S32)(fullbright_flag != 0)); getChildView("checkbox fullbright")->setEnabled(editable); getChild("checkbox fullbright")->setTentative(!identical); } @@ -1556,7 +1578,8 @@ void LLPanelFace::onMaterialLoaded(const LLMaterialID& material_id, const LLMate //make a local copy of the material for editing // (prevents local edits from overwriting client state on shared materials) - mMaterial = new LLMaterial(*material); + mMaterial = new LLMaterial(*material); + mMaterialID = material_id; // Alpha LLCtrlSelectionInterface* combobox_alphamode = @@ -1572,6 +1595,20 @@ void LLPanelFace::onMaterialLoaded(const LLMaterialID& material_id, const LLMate getChild("maskcutoff")->setValue(material->getAlphaMaskCutoff()); updateAlphaControls(getChild("combobox alphamode"),this); + LLTextureEntry::e_texgen selected_texgen = LLTextureEntry::TEX_GEN_DEFAULT; + bool identical_texgen = true; + bool identical_planar_texgen = false; + + struct f44 : public LLSelectedTEGetFunctor + { + LLTextureEntry::e_texgen get(LLViewerObject* object, S32 face) + { + return (LLTextureEntry::e_texgen)(object->getTE(face)->getTexGen()); + } + } func; + identical_texgen = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, selected_texgen ); + identical_planar_texgen = (identical_texgen && (selected_texgen == LLTextureEntry::TEX_GEN_PLANAR)); + // Shiny (specular) F32 offset_x, offset_y, repeat_x, repeat_y, rot; LLTextureCtrl* texture_ctrl = getChild("shinytexture control"); @@ -1581,6 +1618,13 @@ void LLPanelFace::onMaterialLoaded(const LLMaterialID& material_id, const LLMate { material->getSpecularOffset(offset_x,offset_y); material->getSpecularRepeat(repeat_x,repeat_y); + + if (identical_planar_texgen) + { + repeat_x *= 2.0f; + repeat_y *= 2.0f; + } + rot = material->getSpecularRotation(); getChild("shinyScaleU")->setValue(repeat_x); getChild("shinyScaleV")->setValue(repeat_y); @@ -1592,7 +1636,7 @@ void LLPanelFace::onMaterialLoaded(const LLMaterialID& material_id, const LLMate getChild("glossiness")->setValue((F32)(material->getSpecularLightExponent())/255.0); getChild("environment")->setValue((F32)(material->getEnvironmentIntensity())/255.0); } - updateShinyControls(combobox_shininess,this); + updateShinyControls(combobox_shininess,this, true); // Bumpy (normal) texture_ctrl = getChild("bumpytexture control"); @@ -1602,6 +1646,13 @@ void LLPanelFace::onMaterialLoaded(const LLMaterialID& material_id, const LLMate { material->getNormalOffset(offset_x,offset_y); material->getNormalRepeat(repeat_x,repeat_y); + + if (identical_planar_texgen) + { + repeat_x *= 2.0f; + repeat_y *= 2.0f; + } + rot = material->getNormalRotation(); getChild("bumpyScaleU")->setValue(repeat_x); getChild("bumpyScaleV")->setValue(repeat_y); @@ -1609,11 +1660,11 @@ void LLPanelFace::onMaterialLoaded(const LLMaterialID& material_id, const LLMate getChild("bumpyOffsetU")->setValue(offset_x); getChild("bumpyOffsetV")->setValue(offset_y); } - updateBumpyControls(combobox_bumpiness,this); + updateBumpyControls(combobox_bumpiness,this, true); } void LLPanelFace::updateMaterial() -{ +{ // assign current state of UI to material definition for submit to sim LL_DEBUGS("Materials") << "Entered." << LL_ENDL; LLComboBox* comboAlphaMode = getChild("combobox alphamode"); LLComboBox* comboBumpiness = getChild("combobox bumpiness"); @@ -1625,6 +1676,18 @@ void LLPanelFace::updateMaterial() U32 alpha_mode = comboAlphaMode->getCurrentIndex(); U32 bumpiness = comboBumpiness->getCurrentIndex(); U32 shininess = comboShininess->getCurrentIndex(); + + LLTextureEntry::e_texgen selected_texgen = LLTextureEntry::TEX_GEN_DEFAULT; + struct f45 : public LLSelectedTEGetFunctor + { + LLTextureEntry::e_texgen get(LLViewerObject* object, S32 face) + { + return (LLTextureEntry::e_texgen)(object->getTE(face)->getTexGen()); + } + } func; + bool identical_texgen = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, selected_texgen ); + bool identical_planar_texgen = (identical_texgen && (selected_texgen == LLTextureEntry::TEX_GEN_PLANAR)); + if ((mIsAlpha && (alpha_mode != LLMaterial::DIFFUSE_ALPHA_MODE_BLEND)) || (bumpiness == BUMPY_TEXTURE) || (shininess == SHINY_TEXTURE)) @@ -1637,17 +1700,26 @@ void LLPanelFace::updateMaterial() mMaterial = LLMaterialPtr(new LLMaterial()); } - mMaterial->setDiffuseAlphaMode(getChild("combobox alphamode")->getCurrentIndex()); - mMaterial->setAlphaMaskCutoff((U8)(getChild("maskcutoff")->getValue().asInteger())); + mMaterial->setDiffuseAlphaMode(getChild("combobox alphamode")->getCurrentIndex()); + mMaterial->setAlphaMaskCutoff((U8)(getChild("maskcutoff")->getValue().asInteger())); if (bumpiness == BUMPY_TEXTURE) { LL_DEBUGS("Materials") << "Setting bumpy texture, bumpiness = " << bumpiness << LL_ENDL; mMaterial->setNormalID(getChild("bumpytexture control")->getImageAssetID()); + + F32 bumpy_scale_u = getChild("bumpyScaleU")->getValue().asReal(); + F32 bumpy_scale_v = getChild("bumpyScaleV")->getValue().asReal(); + + if (identical_planar_texgen) + { + bumpy_scale_u *= 0.5f; + bumpy_scale_v *= 0.5f; + } + mMaterial->setNormalOffset(getChild("bumpyOffsetU")->getValue().asReal(), getChild("bumpyOffsetV")->getValue().asReal()); - mMaterial->setNormalRepeat(getChild("bumpyScaleU")->getValue().asReal(), - getChild("bumpyScaleV")->getValue().asReal()); + mMaterial->setNormalRepeat(bumpy_scale_u, bumpy_scale_v); mMaterial->setNormalRotation(getChild("bumpyRot")->getValue().asReal()*DEG_TO_RAD); } else @@ -1665,18 +1737,21 @@ void LLPanelFace::updateMaterial() mMaterial->setSpecularID(getChild("shinytexture control")->getImageAssetID()); mMaterial->setSpecularOffset(getChild("shinyOffsetU")->getValue().asReal(), getChild("shinyOffsetV")->getValue().asReal()); - mMaterial->setSpecularRepeat(getChild("shinyScaleU")->getValue().asReal(), - getChild("shinyScaleV")->getValue().asReal()); - mMaterial->setSpecularRotation(getChild("shinyRot")->getValue().asReal()*DEG_TO_RAD); - //override shininess to 0.2f if this is a new material - if (new_material) + F32 shiny_scale_u = getChild("shinyScaleU")->getValue().asReal(); + F32 shiny_scale_v = getChild("shinyScaleV")->getValue().asReal(); + + if (identical_planar_texgen) { - mMaterial->setSpecularLightColor(LLColor4U::white); - mMaterial->setSpecularLightExponent((U8) (0.2f*255.f)); - mMaterial->setEnvironmentIntensity(0); + shiny_scale_u *= 0.5f; + shiny_scale_v *= 0.5f; } - else + + mMaterial->setSpecularRepeat(shiny_scale_u, shiny_scale_v); + mMaterial->setSpecularRotation(getChild("shinyRot")->getValue().asReal()*DEG_TO_RAD); + + //override shininess to 0.2f if this is a new material + if (!new_material) { mMaterial->setSpecularLightColor(getChild("shinycolorswatch")->get()); mMaterial->setSpecularLightExponent((U8)(255*getChild("glossiness")->getValue().asReal())); @@ -1690,7 +1765,8 @@ void LLPanelFace::updateMaterial() mMaterial->setSpecularOffset(0.0f,0.0f); mMaterial->setSpecularRepeat(1.0f,1.0f); mMaterial->setSpecularRotation(0.0f); - mMaterial->setSpecularLightExponent(0); + mMaterial->setSpecularLightColor(LLMaterial::DEFAULT_SPECULAR_LIGHT_COLOR); + mMaterial->setSpecularLightExponent(LLMaterial::DEFAULT_SPECULAR_LIGHT_EXPONENT); mMaterial->setEnvironmentIntensity(0); } @@ -1859,9 +1935,8 @@ void LLPanelFace::onCommitMaterialType(LLUICtrl* ctrl, void* userdata) // This is here to insure that we properly update shared UI elements // like the texture ctrls for diffuse/norm/spec so that they are correct // when switching modes - // + // self->getState(); - onCommitMaterialsMedia(ctrl, userdata); } // static @@ -1879,34 +1954,39 @@ void LLPanelFace::onCommitTexGen(LLUICtrl* ctrl, void* userdata) } // static -void LLPanelFace::updateShinyControls(LLUICtrl* ctrl, void* userdata) +void LLPanelFace::updateShinyControls(LLUICtrl* ctrl, void* userdata, bool mess_with_shiny_combobox) { LLPanelFace* self = (LLPanelFace*) userdata; LLTextureCtrl* texture_ctrl = self->getChild("shinytexture control"); LLUUID shiny_texture_ID = texture_ctrl->getImageAssetID(); LL_DEBUGS("Materials") << "Shiny texture selected: " << shiny_texture_ID << LL_ENDL; LLComboBox* comboShiny = self->getChild("combobox shininess"); - if (!comboShiny) - { - return; - } - if (!shiny_texture_ID.isNull()) + + if(mess_with_shiny_combobox) { - if (!comboShiny->itemExists(USE_TEXTURE)) + if (!comboShiny) { - comboShiny->add(USE_TEXTURE); + return; } - comboShiny->setSimple(USE_TEXTURE); - } - else - { - if (comboShiny->itemExists(USE_TEXTURE)) + if (!shiny_texture_ID.isNull()) + { + if (!comboShiny->itemExists(USE_TEXTURE)) + { + comboShiny->add(USE_TEXTURE); + } + comboShiny->setSimple(USE_TEXTURE); + } + else { - // HACK: This depends on adding the "Use texture" - // item at the end of a list of known length. - comboShiny->remove(SHINY_TEXTURE); + if (comboShiny->itemExists(USE_TEXTURE)) + { + // HACK: This depends on adding the "Use texture" + // item at the end of a list of known length. + comboShiny->remove(SHINY_TEXTURE); + } } } + LLComboBox* combo_matmedia = self->getChild("combobox matmedia"); LLComboBox* combo_mattype = self->getChild("combobox mattype"); U32 materials_media = combo_matmedia->getCurrentIndex(); @@ -1924,7 +2004,7 @@ void LLPanelFace::updateShinyControls(LLUICtrl* ctrl, void* userdata) } // static -void LLPanelFace::updateBumpyControls(LLUICtrl* ctrl, void* userdata) +void LLPanelFace::updateBumpyControls(LLUICtrl* ctrl, void* userdata, bool mess_with_combobox) { LLPanelFace* self = (LLPanelFace*) userdata; LLTextureCtrl* texture_ctrl = self->getChild("bumpytexture control"); @@ -1935,21 +2015,25 @@ void LLPanelFace::updateBumpyControls(LLUICtrl* ctrl, void* userdata) { return; } - if (!bumpy_texture_ID.isNull()) + + if (mess_with_combobox) { - if (!comboBumpy->itemExists(USE_TEXTURE)) + if (!bumpy_texture_ID.isNull()) { - comboBumpy->add(USE_TEXTURE); + if (!comboBumpy->itemExists(USE_TEXTURE)) + { + comboBumpy->add(USE_TEXTURE); + } + comboBumpy->setSimple(USE_TEXTURE); } - comboBumpy->setSimple(USE_TEXTURE); - } - else - { - if (comboBumpy->itemExists(USE_TEXTURE)) + else { - // HACK: This depends on adding the "Use texture" - // item at the end of a list of known length. - comboBumpy->remove(BUMPY_TEXTURE); + if (comboBumpy->itemExists(USE_TEXTURE)) + { + // HACK: This depends on adding the "Use texture" + // item at the end of a list of known length. + comboBumpy->remove(BUMPY_TEXTURE); + } } } } @@ -2057,9 +2141,9 @@ void LLPanelFace::onCommitMaterialTexture( const LLSD& data ) LL_DEBUGS("Materials") << data << LL_ENDL; updateMaterial(); LLComboBox* combo_shiny = getChild("combobox shininess"); - updateShinyControls(combo_shiny,this); + updateShinyControls(combo_shiny,this, true); LLComboBox* combo_bumpy = getChild("combobox bumpiness"); - updateBumpyControls(combo_bumpy,this); + updateBumpyControls(combo_bumpy,this, true); } void LLPanelFace::onCancelMaterialTexture(const LLSD& data) @@ -2067,9 +2151,9 @@ void LLPanelFace::onCancelMaterialTexture(const LLSD& data) // not sure what to do here other than updateMaterial(); LLComboBox* combo_shiny = getChild("combobox shininess"); - updateShinyControls(combo_shiny,this); + updateShinyControls(combo_shiny,this, true); LLComboBox* combo_bumpy = getChild("combobox bumpiness"); - updateBumpyControls(combo_bumpy,this); + updateBumpyControls(combo_bumpy,this, true); } void LLPanelFace::onSelectMaterialTexture(const LLSD& data) @@ -2077,9 +2161,9 @@ void LLPanelFace::onSelectMaterialTexture(const LLSD& data) LL_DEBUGS("Materials") << data << LL_ENDL; updateMaterial(); LLComboBox* combo_shiny = getChild("combobox shininess"); - updateShinyControls(combo_shiny,this); + updateShinyControls(combo_shiny,this, true); LLComboBox* combo_bumpy = getChild("combobox bumpiness"); - updateBumpyControls(combo_bumpy,this); + updateBumpyControls(combo_bumpy,this, true); } //static @@ -2228,3 +2312,4 @@ void LLPanelFace::onTextureSelectionChanged(LLInventoryItem* itemp) } } } + diff --git a/indra/newview/llpanelface.h b/indra/newview/llpanelface.h index a99b4e772f..2138319365 100644 --- a/indra/newview/llpanelface.h +++ b/indra/newview/llpanelface.h @@ -93,8 +93,8 @@ protected: static void onCommitMaterialType( LLUICtrl* ctrl, void* userdata); static void onCommitBump( LLUICtrl* ctrl, void* userdata); static void onCommitTexGen( LLUICtrl* ctrl, void* userdata); - static void updateShinyControls( LLUICtrl* ctrl, void* userdata); - static void updateBumpyControls( LLUICtrl* ctrl, void* userdata); + static void updateShinyControls( LLUICtrl* ctrl, void* userdata, bool mess_with_combobox = false); + static void updateBumpyControls( LLUICtrl* ctrl, void* userdata, bool mess_with_combobox = false); static void onCommitShiny( LLUICtrl* ctrl, void* userdata); static void updateAlphaControls( LLUICtrl* ctrl, void* userdata); static void onCommitAlphaMode( LLUICtrl* ctrl, void* userdata); @@ -134,3 +134,4 @@ private: }; #endif + -- cgit v1.3 From fafa21315f043ab51e3373e825c85646685778a6 Mon Sep 17 00:00:00 2001 From: g Date: Fri, 12 Apr 2013 15:21:35 -0700 Subject: Fix issue with alphaNonIndexedNoColorF shader and static init fail on default spec color (real source of NORSPEC-94, I think) --- indra/llprimitive/llmaterial.cpp | 6 +++--- indra/llprimitive/llmaterial.h | 1 + .../shaders/class2/deferred/alphaNonIndexedNoColorF.glsl | 5 +++-- 3 files changed, 7 insertions(+), 5 deletions(-) (limited to 'indra/llprimitive/llmaterial.cpp') diff --git a/indra/llprimitive/llmaterial.cpp b/indra/llprimitive/llmaterial.cpp index 1e92847b38..bd98aa040a 100644 --- a/indra/llprimitive/llmaterial.cpp +++ b/indra/llprimitive/llmaterial.cpp @@ -51,7 +51,7 @@ #define MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD "AlphaMaskCutoff" #define MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD "DiffuseAlphaMode" -const LLColor4U LLMaterial::DEFAULT_SPECULAR_LIGHT_COLOR = LLColor4U::white; +const LLColor4U LLMaterial::DEFAULT_SPECULAR_LIGHT_COLOR(255,255,255,255); /** * Materials constants @@ -103,8 +103,8 @@ LLMaterial::LLMaterial() , mSpecularRotation(.0f) , mSpecularLightColor(LLMaterial::DEFAULT_SPECULAR_LIGHT_COLOR) , mSpecularLightExponent(LLMaterial::DEFAULT_SPECULAR_LIGHT_EXPONENT) - , mEnvironmentIntensity(0) - , mDiffuseAlphaMode(0) + , mEnvironmentIntensity(LLMaterial::DEFAULT_ENV_INTENSITY) + , mDiffuseAlphaMode(LLMaterial::DIFFUSE_ALPHA_MODE_BLEND) , mAlphaMaskCutoff(0) { } diff --git a/indra/llprimitive/llmaterial.h b/indra/llprimitive/llmaterial.h index bedfc8f8c2..c2e49985a4 100644 --- a/indra/llprimitive/llmaterial.h +++ b/indra/llprimitive/llmaterial.h @@ -54,6 +54,7 @@ public: static const U8 DEFAULT_SPECULAR_LIGHT_EXPONENT = ((U8)(0.2f * 255)); static const LLColor4U DEFAULT_SPECULAR_LIGHT_COLOR; + static const U8 DEFAULT_ENV_INTENSITY = ((U8)(0.05f * 255)); LLMaterial(); LLMaterial(const LLSD& material_data); diff --git a/indra/newview/app_settings/shaders/class2/deferred/alphaNonIndexedNoColorF.glsl b/indra/newview/app_settings/shaders/class2/deferred/alphaNonIndexedNoColorF.glsl index 4bd9ccca1d..566aefea6a 100644 --- a/indra/newview/app_settings/shaders/class2/deferred/alphaNonIndexedNoColorF.glsl +++ b/indra/newview/app_settings/shaders/class2/deferred/alphaNonIndexedNoColorF.glsl @@ -53,6 +53,7 @@ VARYING vec3 vary_fragcoord; VARYING vec3 vary_position; VARYING vec3 vary_pointlight_col; VARYING vec2 vary_texcoord0; +VARYING vec3 vary_norm; uniform vec2 shadow_res; @@ -65,10 +66,10 @@ uniform vec3 light_direction[8]; uniform vec3 light_attenuation[8]; uniform vec3 light_diffuse[8]; -float calcDirectionalLight(vec3 n, vec3 l) +vec3 calcDirectionalLight(vec3 n, vec3 l) { float a = pow(max(dot(n,l),0.0), 0.7); - return a; + return vec3(a, a, a); } float calcPointLightOrSpotLight(vec3 v, vec3 n, vec4 lp, vec3 ln, float la, float fa, float is_pointlight) -- cgit v1.3 From 18e3985120d53acdf07d43dce79312b78629e57a Mon Sep 17 00:00:00 2001 From: Dave Parks Date: Mon, 6 May 2013 15:44:44 -0500 Subject: NORSPEC-162 Fix for objects with materials set ignoring "tranparency %" value. --- indra/llprimitive/llmaterial.cpp | 11 +++++++++-- indra/llprimitive/llmaterial.h | 5 +++-- indra/newview/lldrawpoolalpha.cpp | 2 +- indra/newview/llspatialpartition.cpp | 1 + indra/newview/llspatialpartition.h | 2 +- indra/newview/llvovolume.cpp | 25 +++++++++++++++++++++++-- indra/newview/pipeline.cpp | 7 ++++--- 7 files changed, 42 insertions(+), 11 deletions(-) (limited to 'indra/llprimitive/llmaterial.cpp') diff --git a/indra/llprimitive/llmaterial.cpp b/indra/llprimitive/llmaterial.cpp index bd98aa040a..ce443dea1d 100644 --- a/indra/llprimitive/llmaterial.cpp +++ b/indra/llprimitive/llmaterial.cpp @@ -186,12 +186,19 @@ bool LLMaterial::operator != (const LLMaterial& rhs) const } -U32 LLMaterial::getShaderMask() +U32 LLMaterial::getShaderMask(U32 alpha_mode) { //NEVER incorporate this value into the message system -- this function will vary depending on viewer implementation U32 ret = 0; //two least significant bits are "diffuse alpha mode" - ret = getDiffuseAlphaMode(); + if (alpha_mode != DIFFUSE_ALPHA_MODE_DEFAULT) + { + ret = alpha_mode; + } + else + { + ret = getDiffuseAlphaMode(); + } llassert(ret < SHADER_COUNT); diff --git a/indra/llprimitive/llmaterial.h b/indra/llprimitive/llmaterial.h index b294288c64..b265732adc 100644 --- a/indra/llprimitive/llmaterial.h +++ b/indra/llprimitive/llmaterial.h @@ -44,7 +44,8 @@ public: DIFFUSE_ALPHA_MODE_NONE = 0, DIFFUSE_ALPHA_MODE_BLEND = 1, DIFFUSE_ALPHA_MODE_MASK = 2, - DIFFUSE_ALPHA_MODE_EMISSIVE = 3 + DIFFUSE_ALPHA_MODE_EMISSIVE = 3, + DIFFUSE_ALPHA_MODE_DEFAULT = 4, } eDiffuseAlphaMode; typedef enum @@ -100,7 +101,7 @@ public: bool operator == (const LLMaterial& rhs) const; bool operator != (const LLMaterial& rhs) const; - U32 getShaderMask(); + U32 getShaderMask(U32 alpha_mode = DIFFUSE_ALPHA_MODE_DEFAULT); protected: LLUUID mNormalID; diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp index 1912ae0c16..d5de5d30b0 100644 --- a/indra/newview/lldrawpoolalpha.cpp +++ b/indra/newview/lldrawpoolalpha.cpp @@ -481,7 +481,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask) if (!params.mFullbright && deferred_render && mat) { - U32 mask = mat->getShaderMask(); + U32 mask = params.mShaderMask; llassert(mask < LLMaterial::SHADER_COUNT); target_shader = &(gDeferredMaterialProgram[mask]); diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp index 6bb9d5f201..252f129133 100644 --- a/indra/newview/llspatialpartition.cpp +++ b/indra/newview/llspatialpartition.cpp @@ -4634,6 +4634,7 @@ LLDrawInfo::LLDrawInfo(U16 start, U16 end, U32 count, U32 offset, mDistance(0.f), mDrawMode(LLRender::TRIANGLES), mMaterial(NULL), + mShaderMask(0), mSpecColor(1.0f, 1.0f, 1.0f, 0.5f), mEnvIntensity(0.0f), mAlphaMaskCutoff(0.5f), diff --git a/indra/newview/llspatialpartition.h b/indra/newview/llspatialpartition.h index 7c0be549df..bf32440848 100644 --- a/indra/newview/llspatialpartition.h +++ b/indra/newview/llspatialpartition.h @@ -119,8 +119,8 @@ public: LL_ALIGN_16(LLFace* mFace); //associated face F32 mDistance; U32 mDrawMode; - LLMaterialPtr mMaterial; // If this is null, the following parameters are unused. + U32 mShaderMask; LLPointer mSpecularMap; const LLMatrix4* mSpecularMapMatrix; LLPointer mNormalMap; diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp index 9b940300f5..637d40c5b5 100644 --- a/indra/newview/llvovolume.cpp +++ b/indra/newview/llvovolume.cpp @@ -4088,6 +4088,21 @@ void LLVolumeGeometryManager::registerFace(LLSpatialGroup* group, LLFace* facep, bool batchable = false; + U32 shader_mask = 0xFFFFFFFF; //no shader + + if (mat) + { + if (type == LLRenderPass::PASS_ALPHA) + { + shader_mask = mat->getShaderMask(LLMaterial::DIFFUSE_ALPHA_MODE_BLEND); + } + else + { + shader_mask = mat->getShaderMask(); + } + } + + if (index < 255 && idx >= 0) { if (mat || draw_vec[idx]->mMaterial) @@ -4124,7 +4139,8 @@ void LLVolumeGeometryManager::registerFace(LLSpatialGroup* group, LLFace* facep, draw_vec[idx]->mBump == bump && draw_vec[idx]->mTextureMatrix == tex_mat && draw_vec[idx]->mModelMatrix == model_mat && - draw_vec[idx]->mMaterial == mat) + draw_vec[idx]->mMaterial == mat && + draw_vec[idx]->mShaderMask == shader_mask) { draw_vec[idx]->mCount += facep->getIndicesCount(); draw_vec[idx]->mEnd += facep->getGeomCount(); @@ -4152,10 +4168,11 @@ void LLVolumeGeometryManager::registerFace(LLSpatialGroup* group, LLFace* facep, draw_vec.push_back(draw_info); draw_info->mTextureMatrix = tex_mat; draw_info->mModelMatrix = model_mat; - if (mat && LLPipeline::sRenderBump && LLPipeline::sRenderDeferred) + if (mat) { // We have a material. Update our draw info accordingly. draw_info->mMaterial = mat; + draw_info->mShaderMask = shader_mask; LLVector4 specColor; specColor.mV[0] = mat->getSpecularLightColor().mV[0] * (1.f / 255.f); specColor.mV[1] = mat->getSpecularLightColor().mV[1] * (1.f / 255.f); @@ -5280,6 +5297,10 @@ void LLVolumeGeometryManager::genDrawInfo(LLSpatialGroup* group, U32 mask, std:: { registerFace(group, facep, LLRenderPass::PASS_SIMPLE); } + else if (te->getColor().mV[3] < 0.999f) + { + registerFace(group, facep, LLRenderPass::PASS_ALPHA); + } else { U32 pass[] = diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp index 4cce654f47..fd4e9dfc05 100644 --- a/indra/newview/pipeline.cpp +++ b/indra/newview/pipeline.cpp @@ -1660,7 +1660,8 @@ U32 LLPipeline::getPoolTypeFromTE(const LLTextureEntry* te, LLViewerTexture* ima return 0; } - bool alpha = te->getColor().mV[3] < 0.999f; + bool color_alpha = te->getColor().mV[3] < 0.999f; + bool alpha = color_alpha; if (imagep) { alpha = alpha || (imagep->getComponents() == 4 && imagep->getType() != LLViewerTexture::MEDIA_TEXTURE) || (imagep->getComponents() == 2); @@ -1675,10 +1676,10 @@ U32 LLPipeline::getPoolTypeFromTE(const LLTextureEntry* te, LLViewerTexture* ima break; case 0: //alpha mode set to none, never go to alpha pool case 3: //alpha mode set to emissive, never go to alpha pool - alpha = false; + alpha = color_alpha; break; default: //alpha mode set to "mask", go to alpha pool if fullbright - alpha = false; // Material's alpha mode is set to none, mask, or emissive. Toss it into the opaque material draw pool. + alpha = color_alpha; // Material's alpha mode is set to none, mask, or emissive. Toss it into the opaque material draw pool. break; } } -- cgit v1.3 From eba7eb2d062c43cd83cb6972e4e05dc54d409582 Mon Sep 17 00:00:00 2001 From: Graham Madarasz Date: Sat, 8 Jun 2013 06:28:48 -0700 Subject: NORSPEC-233 fix default value and material apply logic errors --- indra/llprimitive/llmaterial.cpp | 20 +++---- indra/newview/llface.cpp | 6 +-- indra/newview/llpanelface.h | 111 +++++++++++++++++++++++---------------- 3 files changed, 78 insertions(+), 59 deletions(-) (limited to 'indra/llprimitive/llmaterial.cpp') diff --git a/indra/llprimitive/llmaterial.cpp b/indra/llprimitive/llmaterial.cpp index ce443dea1d..cf4c645cfd 100644 --- a/indra/llprimitive/llmaterial.cpp +++ b/indra/llprimitive/llmaterial.cpp @@ -91,16 +91,16 @@ template<> LLUUID getMaterialField(const LLSD& data, const std::string& field, c const LLMaterial LLMaterial::null; LLMaterial::LLMaterial() - : mNormalOffsetX(.0f) - , mNormalOffsetY(.0f) - , mNormalRepeatX(.0f) - , mNormalRepeatY(.0f) - , mNormalRotation(.0f) - , mSpecularOffsetX(.0f) - , mSpecularOffsetY(.0f) - , mSpecularRepeatX(.0f) - , mSpecularRepeatY(.0f) - , mSpecularRotation(.0f) + : mNormalOffsetX(0.0f) + , mNormalOffsetY(0.0f) + , mNormalRepeatX(1.0f) + , mNormalRepeatY(1.0f) + , mNormalRotation(0.0f) + , mSpecularOffsetX(0.0f) + , mSpecularOffsetY(0.0f) + , mSpecularRepeatX(1.0f) + , mSpecularRepeatY(1.0f) + , mSpecularRotation(0.0f) , mSpecularLightColor(LLMaterial::DEFAULT_SPECULAR_LIGHT_COLOR) , mSpecularLightExponent(LLMaterial::DEFAULT_SPECULAR_LIGHT_EXPONENT) , mEnvironmentIntensity(LLMaterial::DEFAULT_ENV_INTENSITY) diff --git a/indra/newview/llface.cpp b/indra/newview/llface.cpp index 46d6a1a97f..3e503cb750 100755 --- a/indra/newview/llface.cpp +++ b/indra/newview/llface.cpp @@ -1655,8 +1655,8 @@ BOOL LLFace::getGeometryVolume(const LLVolume& volume, if (mat && !do_bump) { - do_bump = mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_TEXCOORD1) || - mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_TEXCOORD2); + do_bump = mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_TEXCOORD1) + || mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_TEXCOORD2); } bool do_tex_mat = tex_mode && mTextureMatrix; @@ -1780,7 +1780,7 @@ BOOL LLFace::getGeometryVolume(const LLVolume& volume, std::vector bump_tc; - if (mat) + if (mat && !mat->getNormalID().isNull()) { //writing out normal and specular texture coordinates, not bump offsets do_bump = false; } diff --git a/indra/newview/llpanelface.h b/indra/newview/llpanelface.h index 8d267fe723..b6a8df19fe 100755 --- a/indra/newview/llpanelface.h +++ b/indra/newview/llpanelface.h @@ -235,6 +235,15 @@ private: LLMaterialPtr new_material(!current_material.isNull() ? new LLMaterial(current_material->asLLSD()) : new LLMaterial()); 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) + // + U8 default_alpha_mode = (_panel->isAlpha() ? LLMaterial::DIFFUSE_ALPHA_MODE_BLEND : LLMaterial::DIFFUSE_ALPHA_MODE_NONE); + + // Default to matching expected state of UI + // + new_material->setDiffuseAlphaMode(default_alpha_mode); + // Do "It"! // _edit->apply(new_material); @@ -243,10 +252,10 @@ private: LLUUID new_normal_map_id = new_material->getNormalID(); LLUUID new_spec_map_id = new_material->getSpecularID(); - bool is_default_blend_mode = (new_alpha_mode == (_panel->isAlpha() ? LLMaterial::DIFFUSE_ALPHA_MODE_BLEND : LLMaterial::DIFFUSE_ALPHA_MODE_NONE)); + bool is_default_blend_mode = (new_alpha_mode == default_alpha_mode); bool is_need_material = !is_default_blend_mode || !new_normal_map_id.isNull() || !new_spec_map_id.isNull(); - if (!current_material.isNull() && !is_need_material) + if (!is_need_material) { LL_DEBUGS("Materials") << "Removing material from object " << object->getID() << " face " << face << LL_ENDL; LLMaterialMgr::getInstance()->remove(object->getID(),face); @@ -259,7 +268,6 @@ private: { U8 current_alpha_mode = _panel->getCurrentDiffuseAlphaMode(); U8 current_alpha_mask_cutoff = _panel->getCurrentAlphaMaskCutoff(); - new_material->setDiffuseAlphaMode(current_alpha_mode); new_material->setAlphaMaskCutoff(current_alpha_mask_cutoff); } @@ -283,13 +291,16 @@ private: typename DataType, typename ReturnType, ReturnType (LLMaterial::* const MaterialGetFunc)() const > - static void getTEMaterialValue(DataType& data_to_return, bool& identical) + static void getTEMaterialValue(DataType& data_to_return, bool& identical,DataType default_value) { struct GetTEMaterialVal : public LLSelectedTEGetFunctor { + GetTEMaterialVal(DataType default_value) : _default(default_value) {} + virtual ~GetTEMaterialVal() {} + DataType get(LLViewerObject* object, S32 face) { - DataType ret = DataType(); + DataType ret = _default; LLMaterialPtr material_ptr; LLTextureEntry* tep = object ? object->getTE(face) : NULL; if (tep) @@ -302,7 +313,8 @@ private: } return ret; } - } GetFunc; + DataType _default; + } GetFunc(default_value); identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &GetFunc, data_to_return); } @@ -310,15 +322,19 @@ private: typename DataType, typename ReturnType, // some kids just have to different... ReturnType (LLTextureEntry::* const TEGetFunc)() const > - static void getTEValue(DataType& data_to_return, bool& identical) + static void getTEValue(DataType& data_to_return, bool& identical, DataType default_value) { struct GetTEVal : public LLSelectedTEGetFunctor { + 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))()) : DataType(); + return tep ? ((tep->*(TEGetFunc))()) : _default; } - } GetTEValFunc; + DataType _default; + } GetTEValFunc(default_value); identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &GetTEValFunc, data_to_return ); } @@ -359,29 +375,32 @@ private: #undef DEF_GET_TE_STATE #endif + #if defined(DEF_EDIT_MAT_STATE) + DEF_EDIT_MAT_STATE + #endif + // Accessors for selected TE material state // - #define DEF_GET_MAT_STATE(DataType,ReturnType,MaterialMemberFunc) \ - static void MaterialMemberFunc(DataType& data, bool& identical) \ - { \ - getTEMaterialValue< DataType, ReturnType, &LLMaterial::MaterialMemberFunc >(data, identical); \ + #define DEF_GET_MAT_STATE(DataType,ReturnType,MaterialMemberFunc,DefaultValue) \ + static void MaterialMemberFunc(DataType& data, bool& identical) \ + { \ + getTEMaterialValue< DataType, ReturnType, &LLMaterial::MaterialMemberFunc >(data, identical,DefaultValue); \ } // Mutators for selected TE material // - #define DEF_EDIT_MAT_STATE(DataType,ReturnType,MaterialMemberFunc) \ - static void MaterialMemberFunc(LLPanelFace* p,DataType data) \ - { \ - edit< DataType, ReturnType, &LLMaterial::MaterialMemberFunc >(p,data); \ + #define DEF_EDIT_MAT_STATE(DataType,ReturnType,MaterialMemberFunc) \ + static void MaterialMemberFunc(LLPanelFace* p,DataType data) \ + { \ + edit< DataType, ReturnType, &LLMaterial::MaterialMemberFunc >(p,data); \ } - // Accessors for selected TE state proper (legacy settings etc) // - #define DEF_GET_TE_STATE(DataType,ReturnType,TexEntryMemberFunc) \ - static void TexEntryMemberFunc(DataType& data, bool& identical) \ - { \ - getTEValue< DataType, ReturnType, &LLTextureEntry::TexEntryMemberFunc >(data, identical); \ + #define DEF_GET_TE_STATE(DataType,ReturnType,TexEntryMemberFunc,DefaultValue) \ + static void TexEntryMemberFunc(DataType& data, bool& identical) \ + { \ + getTEValue< DataType, ReturnType, &LLTextureEntry::TexEntryMemberFunc >(data, identical,DefaultValue); \ } class LLSelectedTEMaterial @@ -391,21 +410,21 @@ private: static void getMaxSpecularRepeats(F32& repeats, bool& identical); static void getMaxNormalRepeats(F32& repeats, bool& identical); - DEF_GET_MAT_STATE(LLUUID,const LLUUID&,getNormalID) - DEF_GET_MAT_STATE(LLUUID,const LLUUID&,getSpecularID) - DEF_GET_MAT_STATE(U8,U8,getDiffuseAlphaMode) + DEF_GET_MAT_STATE(LLUUID,const LLUUID&,getNormalID,LLUUID::null) + DEF_GET_MAT_STATE(LLUUID,const LLUUID&,getSpecularID,LLUUID::null) + DEF_GET_MAT_STATE(U8,U8,getDiffuseAlphaMode,LLMaterial::DIFFUSE_ALPHA_MODE_NONE) - DEF_GET_MAT_STATE(F32,F32,getSpecularRepeatX) - DEF_GET_MAT_STATE(F32,F32,getSpecularRepeatY) - DEF_GET_MAT_STATE(F32,F32,getSpecularOffsetX) - DEF_GET_MAT_STATE(F32,F32,getSpecularOffsetY) - DEF_GET_MAT_STATE(F32,F32,getSpecularRotation) + DEF_GET_MAT_STATE(F32,F32,getSpecularRepeatX,1.0f) + DEF_GET_MAT_STATE(F32,F32,getSpecularRepeatY,1.0f) + DEF_GET_MAT_STATE(F32,F32,getSpecularOffsetX,0.0f) + DEF_GET_MAT_STATE(F32,F32,getSpecularOffsetY,0.0f) + DEF_GET_MAT_STATE(F32,F32,getSpecularRotation,0.0f) - DEF_GET_MAT_STATE(F32,F32,getNormalRepeatX) - DEF_GET_MAT_STATE(F32,F32,getNormalRepeatY) - DEF_GET_MAT_STATE(F32,F32,getNormalOffsetX) - DEF_GET_MAT_STATE(F32,F32,getNormalOffsetY) - DEF_GET_MAT_STATE(F32,F32,getNormalRotation) + DEF_GET_MAT_STATE(F32,F32,getNormalRepeatX,1.0f) + DEF_GET_MAT_STATE(F32,F32,getNormalRepeatY,1.0f) + DEF_GET_MAT_STATE(F32,F32,getNormalOffsetX,0.0f) + DEF_GET_MAT_STATE(F32,F32,getNormalOffsetY,0.0f) + DEF_GET_MAT_STATE(F32,F32,getNormalRotation,0.0f) DEF_EDIT_MAT_STATE(U8,U8,setDiffuseAlphaMode); DEF_EDIT_MAT_STATE(U8,U8,setAlphaMaskCutoff); @@ -441,17 +460,17 @@ private: static void getObjectScaleT(F32& scale_t, bool& identical); static void getMaxDiffuseRepeats(F32& repeats, bool& identical); - DEF_GET_TE_STATE(U8,U8,getBumpmap) - DEF_GET_TE_STATE(U8,U8,getShiny) - DEF_GET_TE_STATE(U8,U8,getFullbright) - DEF_GET_TE_STATE(F32,F32,getRotation) - DEF_GET_TE_STATE(F32,F32,getOffsetS) - DEF_GET_TE_STATE(F32,F32,getOffsetT) - DEF_GET_TE_STATE(F32,F32,getScaleS) - DEF_GET_TE_STATE(F32,F32,getScaleT) - DEF_GET_TE_STATE(F32,F32,getGlow) - DEF_GET_TE_STATE(LLTextureEntry::e_texgen,LLTextureEntry::e_texgen,getTexGen) - DEF_GET_TE_STATE(LLColor4,const LLColor4&,getColor) + DEF_GET_TE_STATE(U8,U8,getBumpmap,0) + DEF_GET_TE_STATE(U8,U8,getShiny,0) + DEF_GET_TE_STATE(U8,U8,getFullbright,0) + DEF_GET_TE_STATE(F32,F32,getRotation,0.0f) + DEF_GET_TE_STATE(F32,F32,getOffsetS,0.0f) + DEF_GET_TE_STATE(F32,F32,getOffsetT,0.0f) + DEF_GET_TE_STATE(F32,F32,getScaleS,1.0f) + DEF_GET_TE_STATE(F32,F32,getScaleT,1.0f) + DEF_GET_TE_STATE(F32,F32,getGlow,0.0f) + DEF_GET_TE_STATE(LLTextureEntry::e_texgen,LLTextureEntry::e_texgen,getTexGen,LLTextureEntry::TEX_GEN_DEFAULT) + DEF_GET_TE_STATE(LLColor4,const LLColor4&,getColor,LLColor4::white) }; }; -- cgit v1.3