diff options
25 files changed, 761 insertions, 355 deletions
diff --git a/doc/contributions.txt b/doc/contributions.txt index 90bbb1c2c6..d823e37dbd 100755 --- a/doc/contributions.txt +++ b/doc/contributions.txt @@ -220,6 +220,7 @@ Ansariel Hiller STORM-2151 MAINT-6917 MAINT-8085 + MAINT-8723 Aralara Rajal Arare Chantilly CHUIBUG-191 diff --git a/indra/llmath/llvolume.cpp b/indra/llmath/llvolume.cpp index 6b6cd65ce2..a34999b6fd 100644 --- a/indra/llmath/llvolume.cpp +++ b/indra/llmath/llvolume.cpp @@ -2192,6 +2192,13 @@ BOOL LLVolume::generate() LLVector4a* end_profile = profile+sizeT; LLVector4a offset = mPathp->mPath[s].mPos; + // hack to work around MAINT-5660 for debug until we can suss out + // what is wrong with the path generated that inserts NaNs... + if (!offset.isFinite3()) + { + offset.clear(); + } + LLVector4a tmp; // Run along the profile. diff --git a/indra/llprimitive/llmaterial.cpp b/indra/llprimitive/llmaterial.cpp index 57ceb3e11b..a219ac1450 100644 --- a/indra/llprimitive/llmaterial.cpp +++ b/indra/llprimitive/llmaterial.cpp @@ -65,23 +65,23 @@ const F32 MATERIALS_MULTIPLIER = 10000.f; template<typename T> 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]; - } - LL_ERRS() << "Missing or mistyped field '" << field << "' in material definition" << LL_ENDL; - return (T)LLSD(); + if ( (data.has(field)) && (field_type == data[field].type()) ) + { + return (T)data[field]; + } + LL_ERRS() << "Missing or mistyped field '" << field << "' in material definition" << LL_ENDL; + 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(); - } - LL_ERRS() << "Missing or mistyped field '" << field << "' in material definition" << LL_ENDL; - return LLUUID::null; + if ( (data.has(field)) && (field_type == data[field].type()) ) + { + return data[field].asUUID(); + } + LL_ERRS() << "Missing or mistyped field '" << field << "' in material definition" << LL_ENDL; + return LLUUID::null; } /** @@ -91,137 +91,377 @@ template<> LLUUID getMaterialField(const LLSD& data, const std::string& field, c const LLMaterial LLMaterial::null; LLMaterial::LLMaterial() - : 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) - , mDiffuseAlphaMode(LLMaterial::DIFFUSE_ALPHA_MODE_BLEND) - , mAlphaMaskCutoff(0) + : 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) + , mDiffuseAlphaMode(LLMaterial::DIFFUSE_ALPHA_MODE_BLEND) + , mAlphaMaskCutoff(0) { } LLMaterial::LLMaterial(const LLSD& material_data) { - fromLLSD(material_data); + fromLLSD(material_data); } -LLSD LLMaterial::asLLSD() const +const LLUUID& LLMaterial::getNormalID() const +{ + return mNormalID; +} + +void LLMaterial::setNormalID(const LLUUID& normal_id) { - LLSD material_data; + mNormalID = normal_id; +} + +void LLMaterial::getNormalOffset(F32& offset_x, F32& offset_y) const +{ + offset_x = mNormalOffsetX; + offset_y = mNormalOffsetY; +} - material_data[MATERIALS_CAP_NORMAL_MAP_FIELD] = mNormalID; - material_data[MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD] = ll_round(mNormalOffsetX * MATERIALS_MULTIPLIER); - material_data[MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD] = ll_round(mNormalOffsetY * MATERIALS_MULTIPLIER); - material_data[MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD] = ll_round(mNormalRepeatX * MATERIALS_MULTIPLIER); - material_data[MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD] = ll_round(mNormalRepeatY * MATERIALS_MULTIPLIER); - material_data[MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD] = ll_round(mNormalRotation * MATERIALS_MULTIPLIER); +F32 LLMaterial::getNormalOffsetX() const +{ + return mNormalOffsetX; +} - material_data[MATERIALS_CAP_SPECULAR_MAP_FIELD] = mSpecularID; - material_data[MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD] = ll_round(mSpecularOffsetX * MATERIALS_MULTIPLIER); - material_data[MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD] = ll_round(mSpecularOffsetY * MATERIALS_MULTIPLIER); - material_data[MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD] = ll_round(mSpecularRepeatX * MATERIALS_MULTIPLIER); - material_data[MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD] = ll_round(mSpecularRepeatY * MATERIALS_MULTIPLIER); - material_data[MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD] = ll_round(mSpecularRotation * MATERIALS_MULTIPLIER); +F32 LLMaterial::getNormalOffsetY() const +{ + return mNormalOffsetY; +} - 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_DIFFUSE_ALPHA_MODE_FIELD] = mDiffuseAlphaMode; - material_data[MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD] = mAlphaMaskCutoff; +void LLMaterial::setNormalOffset(F32 offset_x, F32 offset_y) +{ + mNormalOffsetX = offset_x; + mNormalOffsetY = offset_y; +} - return material_data; +void LLMaterial::setNormalOffsetX(F32 offset_x) +{ + mNormalOffsetX = offset_x; } -void LLMaterial::fromLLSD(const LLSD& material_data) +void LLMaterial::setNormalOffsetY(F32 offset_y) +{ + mNormalOffsetY = offset_y; +} + +void LLMaterial::getNormalRepeat(F32& repeat_x, F32& repeat_y) const +{ + repeat_x = mNormalRepeatX; + repeat_y = mNormalRepeatY; +} + +F32 LLMaterial::getNormalRepeatX() const +{ + return mNormalRepeatX; +} + +F32 LLMaterial::getNormalRepeatY() const +{ + return mNormalRepeatY; +} + +void LLMaterial::setNormalRepeat(F32 repeat_x, F32 repeat_y) +{ + mNormalRepeatX = repeat_x; + mNormalRepeatY = repeat_y; +} + +void LLMaterial::setNormalRepeatX(F32 repeat_x) +{ + mNormalRepeatX = repeat_x; +} + +void LLMaterial::setNormalRepeatY(F32 repeat_y) +{ + mNormalRepeatY = repeat_y; +} + +F32 LLMaterial::getNormalRotation() const +{ + return mNormalRotation; +} + +void LLMaterial::setNormalRotation(F32 rot) +{ + mNormalRotation = rot; +} + +const LLUUID& LLMaterial::getSpecularID() const +{ + return mSpecularID; +} + +void LLMaterial::setSpecularID(const LLUUID& specular_id) +{ + mSpecularID = specular_id; +} + +void LLMaterial::getSpecularOffset(F32& offset_x, F32& offset_y) const +{ + offset_x = mSpecularOffsetX; + offset_y = mSpecularOffsetY; +} + +F32 LLMaterial::getSpecularOffsetX() const +{ + return mSpecularOffsetX; +} + +F32 LLMaterial::getSpecularOffsetY() const +{ + return mSpecularOffsetY; +} + +void LLMaterial::setSpecularOffset(F32 offset_x, F32 offset_y) +{ + mSpecularOffsetX = offset_x; + mSpecularOffsetY = offset_y; +} + +void LLMaterial::setSpecularOffsetX(F32 offset_x) +{ + mSpecularOffsetX = offset_x; +} + +void LLMaterial::setSpecularOffsetY(F32 offset_y) +{ + mSpecularOffsetY = offset_y; +} + +void LLMaterial::getSpecularRepeat(F32& repeat_x, F32& repeat_y) const +{ + repeat_x = mSpecularRepeatX; + repeat_y = mSpecularRepeatY; +} + +F32 LLMaterial::getSpecularRepeatX() const +{ + return mSpecularRepeatX; +} + +F32 LLMaterial::getSpecularRepeatY() const +{ + return mSpecularRepeatY; +} + +void LLMaterial::setSpecularRepeat(F32 repeat_x, F32 repeat_y) +{ + mSpecularRepeatX = repeat_x; mSpecularRepeatY = repeat_y; +} + +void LLMaterial::setSpecularRepeatX(F32 repeat_x) +{ + mSpecularRepeatX = repeat_x; +} + +void LLMaterial::setSpecularRepeatY(F32 repeat_y) +{ + mSpecularRepeatY = repeat_y; +} + +F32 LLMaterial::getSpecularRotation() const +{ + return mSpecularRotation; +} + +void LLMaterial::setSpecularRotation(F32 rot) +{ + mSpecularRotation = rot; +} + +const LLColor4U LLMaterial::getSpecularLightColor() const +{ + return mSpecularLightColor; +} + +void LLMaterial::setSpecularLightColor(const LLColor4U& color) +{ + mSpecularLightColor = color; +} + +U8 LLMaterial::getSpecularLightExponent() const +{ + return mSpecularLightExponent; +} + +void LLMaterial::setSpecularLightExponent(U8 exponent) +{ + mSpecularLightExponent = exponent; +} + +U8 LLMaterial::getEnvironmentIntensity() const +{ + return mEnvironmentIntensity; +} + +void LLMaterial::setEnvironmentIntensity(U8 intensity) { - mNormalID = getMaterialField<LLSD::UUID>(material_data, MATERIALS_CAP_NORMAL_MAP_FIELD, LLSD::TypeUUID); - mNormalOffsetX = (F32)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; - mNormalOffsetY = (F32)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; - mNormalRepeatX = (F32)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; - mNormalRepeatY = (F32)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; - mNormalRotation = (F32)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; + mEnvironmentIntensity = intensity; +} - mSpecularID = getMaterialField<LLSD::UUID>(material_data, MATERIALS_CAP_SPECULAR_MAP_FIELD, LLSD::TypeUUID); - mSpecularOffsetX = (F32)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; - mSpecularOffsetY = (F32)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; - mSpecularRepeatX = (F32)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; - mSpecularRepeatY = (F32)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; - mSpecularRotation = (F32)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD, LLSD::TypeInteger) / MATERIALS_MULTIPLIER; +U8 LLMaterial::getDiffuseAlphaMode() const +{ + return mDiffuseAlphaMode; +} - mSpecularLightColor.setValue(getMaterialField<LLSD>(material_data, MATERIALS_CAP_SPECULAR_COLOR_FIELD, LLSD::TypeArray)); - mSpecularLightExponent = (U8)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_SPECULAR_EXP_FIELD, LLSD::TypeInteger); - mEnvironmentIntensity = (U8)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_ENV_INTENSITY_FIELD, LLSD::TypeInteger); - mDiffuseAlphaMode = (U8)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD, LLSD::TypeInteger); - mAlphaMaskCutoff = (U8)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD, LLSD::TypeInteger); +void LLMaterial::setDiffuseAlphaMode(U8 alpha_mode) +{ + mDiffuseAlphaMode = alpha_mode; +} + +U8 LLMaterial::getAlphaMaskCutoff() const +{ + return mAlphaMaskCutoff; +} + +void LLMaterial::setAlphaMaskCutoff(U8 cutoff) +{ + mAlphaMaskCutoff = cutoff; +} + +LLSD LLMaterial::asLLSD() const +{ + LLSD material_data; + + S32 normalOffsetXInt = ll_round(mNormalOffsetX * MATERIALS_MULTIPLIER); + S32 normalOffsetYInt = ll_round(mNormalOffsetY * MATERIALS_MULTIPLIER); + S32 normalRotInt = ll_round(mNormalRotation * MATERIALS_MULTIPLIER); + + material_data[MATERIALS_CAP_NORMAL_MAP_FIELD] = mNormalID; + material_data[MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD] = normalOffsetXInt; + material_data[MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD] = normalOffsetYInt; + material_data[MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD] = ll_round(mNormalRepeatX * MATERIALS_MULTIPLIER); + material_data[MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD] = ll_round(mNormalRepeatY * MATERIALS_MULTIPLIER); + material_data[MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD] = normalRotInt; + + material_data[MATERIALS_CAP_SPECULAR_MAP_FIELD] = mSpecularID; + + S32 specularOffsetXInt = ll_round(mSpecularOffsetX * MATERIALS_MULTIPLIER); + S32 specularOffsetYInt = ll_round(mSpecularOffsetY * MATERIALS_MULTIPLIER); + S32 specularRotInt = ll_round(mSpecularRotation * MATERIALS_MULTIPLIER); + + material_data[MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD] = specularOffsetXInt; + material_data[MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD] = specularOffsetYInt; + material_data[MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD] = ll_round(mSpecularRepeatX * MATERIALS_MULTIPLIER); + material_data[MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD] = ll_round(mSpecularRepeatY * MATERIALS_MULTIPLIER); + material_data[MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD] = specularRotInt; + + 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_DIFFUSE_ALPHA_MODE_FIELD] = mDiffuseAlphaMode; + material_data[MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD] = mAlphaMaskCutoff; + + return material_data; +} + +void LLMaterial::fromLLSD(const LLSD& material_data) +{ + mNormalID = getMaterialField<LLSD::UUID>(material_data, MATERIALS_CAP_NORMAL_MAP_FIELD, LLSD::TypeUUID); + + S32 normalOffsetXInt = getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_NORMAL_MAP_OFFSET_X_FIELD, LLSD::TypeInteger); + S32 normalOffsetYInt = getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_NORMAL_MAP_OFFSET_Y_FIELD, LLSD::TypeInteger); + S32 normalRotInt = getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_NORMAL_MAP_ROTATION_FIELD, LLSD::TypeInteger); + S32 normalRepeatXInt = getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_NORMAL_MAP_REPEAT_X_FIELD, LLSD::TypeInteger); + S32 normalRepeatYInt = getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_NORMAL_MAP_REPEAT_Y_FIELD, LLSD::TypeInteger); + + mNormalOffsetX = F32(normalOffsetXInt) / MATERIALS_MULTIPLIER; + mNormalOffsetY = F32(normalOffsetYInt) / MATERIALS_MULTIPLIER; + mNormalRotation = F32(normalRotInt) / MATERIALS_MULTIPLIER; + mNormalRepeatX = F32(normalRepeatXInt) / MATERIALS_MULTIPLIER; + mNormalRepeatY = F32(normalRepeatYInt) / MATERIALS_MULTIPLIER; + + mSpecularID = getMaterialField<LLSD::UUID>(material_data, MATERIALS_CAP_SPECULAR_MAP_FIELD, LLSD::TypeUUID); + + S32 specularOffsetXInt = getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_SPECULAR_MAP_OFFSET_X_FIELD, LLSD::TypeInteger); + S32 specularOffsetYInt = getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_SPECULAR_MAP_OFFSET_Y_FIELD, LLSD::TypeInteger); + S32 specularRotInt = getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_SPECULAR_MAP_ROTATION_FIELD, LLSD::TypeInteger); + S32 specularRepeatXInt = getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_SPECULAR_MAP_REPEAT_X_FIELD, LLSD::TypeInteger); + S32 specularRepeatYInt = getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_SPECULAR_MAP_REPEAT_Y_FIELD, LLSD::TypeInteger); + + mSpecularOffsetX = F32(specularOffsetXInt) / MATERIALS_MULTIPLIER; + mSpecularOffsetY = F32(specularOffsetYInt) / MATERIALS_MULTIPLIER; + mSpecularRotation = F32(specularRotInt) / MATERIALS_MULTIPLIER; + mSpecularRepeatX = F32(specularRepeatXInt) / MATERIALS_MULTIPLIER; + mSpecularRepeatY = F32(specularRepeatYInt) / MATERIALS_MULTIPLIER; + + mSpecularLightColor.setValue(getMaterialField<LLSD>(material_data, MATERIALS_CAP_SPECULAR_COLOR_FIELD, LLSD::TypeArray)); + mSpecularLightExponent = (U8)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_SPECULAR_EXP_FIELD, LLSD::TypeInteger); + mEnvironmentIntensity = (U8)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_ENV_INTENSITY_FIELD, LLSD::TypeInteger); + mDiffuseAlphaMode = (U8)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_DIFFUSE_ALPHA_MODE_FIELD, LLSD::TypeInteger); + mAlphaMaskCutoff = (U8)getMaterialField<LLSD::Integer>(material_data, MATERIALS_CAP_ALPHA_MASK_CUTOFF_FIELD, LLSD::TypeInteger); } bool LLMaterial::isNull() const { - return (*this == null); + return (*this == null); } bool LLMaterial::operator == (const LLMaterial& rhs) const { - return - (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); + return + (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); + return !(*this == rhs); } 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" - if (alpha_mode != DIFFUSE_ALPHA_MODE_DEFAULT) - { - ret = alpha_mode; - } - else - { - 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; + U32 ret = 0; + + //two least significant bits are "diffuse alpha mode" + if (alpha_mode != DIFFUSE_ALPHA_MODE_DEFAULT) + { + ret = alpha_mode; + } + else + { + 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 9f52a3f6c1..d58b7ee812 100644 --- a/indra/llprimitive/llmaterial.h +++ b/indra/llprimitive/llmaterial.h @@ -39,114 +39,115 @@ class LLMaterial : public LLRefCount { public: - typedef enum - { - DIFFUSE_ALPHA_MODE_NONE = 0, - DIFFUSE_ALPHA_MODE_BLEND = 1, - DIFFUSE_ALPHA_MODE_MASK = 2, - DIFFUSE_ALPHA_MODE_EMISSIVE = 3, - DIFFUSE_ALPHA_MODE_DEFAULT = 4, - } eDiffuseAlphaMode; - - typedef enum - { - SHADER_COUNT = 16, - ALPHA_SHADER_COUNT = 4 - } eShaderCount; - - - - static const U8 DEFAULT_SPECULAR_LIGHT_EXPONENT = ((U8)(0.2f * 255)); - static const LLColor4U DEFAULT_SPECULAR_LIGHT_COLOR; - static const U8 DEFAULT_ENV_INTENSITY = 0; - - LLMaterial(); - LLMaterial(const LLSD& material_data); - - LLSD asLLSD() const; - void fromLLSD(const LLSD& material_data); - - const LLUUID& getNormalID() const { return mNormalID; } - void setNormalID(const LLUUID& normal_id) { mNormalID = normal_id; } - void getNormalOffset(F32& offset_x, F32& offset_y) const { offset_x = mNormalOffsetX; offset_y = mNormalOffsetY; } - F32 getNormalOffsetX() const { return mNormalOffsetX; } - F32 getNormalOffsetY() const { return mNormalOffsetY; } - - void setNormalOffset(F32 offset_x, F32 offset_y) { mNormalOffsetX = offset_x; mNormalOffsetY = offset_y; } - void setNormalOffsetX(F32 offset_x) { mNormalOffsetX = offset_x; } - void setNormalOffsetY(F32 offset_y) { mNormalOffsetY = offset_y; } - - void getNormalRepeat(F32& repeat_x, F32& repeat_y) const { repeat_x = mNormalRepeatX; repeat_y = mNormalRepeatY; } - F32 getNormalRepeatX() const { return mNormalRepeatX; } - F32 getNormalRepeatY() const { return mNormalRepeatY; } - - void setNormalRepeat(F32 repeat_x, F32 repeat_y) { mNormalRepeatX = repeat_x; mNormalRepeatY = repeat_y; } - void setNormalRepeatX(F32 repeat_x) { mNormalRepeatX = repeat_x; } - void setNormalRepeatY(F32 repeat_y) { mNormalRepeatY = repeat_y; } - - F32 getNormalRotation() const { return mNormalRotation; } - void setNormalRotation(F32 rot) { mNormalRotation = rot; } - - const LLUUID& getSpecularID() const { return mSpecularID; } - void setSpecularID(const LLUUID& specular_id) { mSpecularID = specular_id; } - void getSpecularOffset(F32& offset_x, F32& offset_y) const { offset_x = mSpecularOffsetX; offset_y = mSpecularOffsetY; } - F32 getSpecularOffsetX() const { return mSpecularOffsetX; } - F32 getSpecularOffsetY() const { return mSpecularOffsetY; } - - void setSpecularOffset(F32 offset_x, F32 offset_y) { mSpecularOffsetX = offset_x; mSpecularOffsetY = offset_y; } - void setSpecularOffsetX(F32 offset_x) { mSpecularOffsetX = offset_x; } - void setSpecularOffsetY(F32 offset_y) { mSpecularOffsetY = offset_y; } - - void getSpecularRepeat(F32& repeat_x, F32& repeat_y) const { repeat_x = mSpecularRepeatX; repeat_y = mSpecularRepeatY; } - F32 getSpecularRepeatX() const { return mSpecularRepeatX; } - F32 getSpecularRepeatY() const { return mSpecularRepeatY; } - - void setSpecularRepeat(F32 repeat_x, F32 repeat_y) { mSpecularRepeatX = repeat_x; mSpecularRepeatY = repeat_y; } - void setSpecularRepeatX(F32 repeat_x) { mSpecularRepeatX = repeat_x; } - void setSpecularRepeatY(F32 repeat_y) { mSpecularRepeatY = repeat_y; } - - F32 getSpecularRotation() const { return mSpecularRotation; } - void setSpecularRotation(F32 rot) { mSpecularRotation = rot; } - - const LLColor4U getSpecularLightColor() const { return mSpecularLightColor; } - void setSpecularLightColor(const LLColor4U& color) { mSpecularLightColor = color; } - U8 getSpecularLightExponent() const { return mSpecularLightExponent; } - void setSpecularLightExponent(U8 exponent) { mSpecularLightExponent = exponent; } - U8 getEnvironmentIntensity() const { return mEnvironmentIntensity; } - void setEnvironmentIntensity(U8 intensity) { mEnvironmentIntensity = intensity; } - U8 getDiffuseAlphaMode() const { return mDiffuseAlphaMode; } - void setDiffuseAlphaMode(U8 alpha_mode) { mDiffuseAlphaMode = alpha_mode; } - U8 getAlphaMaskCutoff() const { return mAlphaMaskCutoff; } - void setAlphaMaskCutoff(U8 cutoff) { mAlphaMaskCutoff = cutoff; } - - bool isNull() const; - static const LLMaterial null; - - bool operator == (const LLMaterial& rhs) const; - bool operator != (const LLMaterial& rhs) const; - - U32 getShaderMask(U32 alpha_mode = DIFFUSE_ALPHA_MODE_DEFAULT); + typedef enum + { + DIFFUSE_ALPHA_MODE_NONE = 0, + DIFFUSE_ALPHA_MODE_BLEND = 1, + DIFFUSE_ALPHA_MODE_MASK = 2, + DIFFUSE_ALPHA_MODE_EMISSIVE = 3, + DIFFUSE_ALPHA_MODE_DEFAULT = 4, + } eDiffuseAlphaMode; + + typedef enum + { + SHADER_COUNT = 16, + ALPHA_SHADER_COUNT = 4 + } eShaderCount; + + + + static const U8 DEFAULT_SPECULAR_LIGHT_EXPONENT = ((U8)(0.2f * 255)); + static const LLColor4U DEFAULT_SPECULAR_LIGHT_COLOR; + static const U8 DEFAULT_ENV_INTENSITY = 0; + + LLMaterial(); + LLMaterial(const LLSD& material_data); + + LLSD asLLSD() const; + void fromLLSD(const LLSD& material_data); + + const LLUUID& getNormalID() const; + void setNormalID(const LLUUID& normal_id); + + void getNormalOffset(F32& offset_x, F32& offset_y) const; + F32 getNormalOffsetX() const; + F32 getNormalOffsetY() const; + + void setNormalOffset(F32 offset_x, F32 offset_y); + void setNormalOffsetX(F32 offset_x); + void setNormalOffsetY(F32 offset_y); + + void getNormalRepeat(F32& repeat_x, F32& repeat_y) const; + F32 getNormalRepeatX() const; + F32 getNormalRepeatY() const; + + void setNormalRepeat(F32 repeat_x, F32 repeat_y); + void setNormalRepeatX(F32 repeat_x); + void setNormalRepeatY(F32 repeat_y); + + F32 getNormalRotation() const; + void setNormalRotation(F32 rot); + + const LLUUID& getSpecularID() const; + void setSpecularID(const LLUUID& specular_id); + void getSpecularOffset(F32& offset_x, F32& offset_y) const; + F32 getSpecularOffsetX() const; + F32 getSpecularOffsetY() const; + + void setSpecularOffset(F32 offset_x, F32 offset_y); + void setSpecularOffsetX(F32 offset_x); + void setSpecularOffsetY(F32 offset_y); + + void getSpecularRepeat(F32& repeat_x, F32& repeat_y) const; + F32 getSpecularRepeatX() const; + F32 getSpecularRepeatY() const; + + void setSpecularRepeat(F32 repeat_x, F32 repeat_y); + void setSpecularRepeatX(F32 repeat_x); + void setSpecularRepeatY(F32 repeat_y); + + F32 getSpecularRotation() const; + void setSpecularRotation(F32 rot); + + const LLColor4U getSpecularLightColor() const; + void setSpecularLightColor(const LLColor4U& color); + U8 getSpecularLightExponent() const; + void setSpecularLightExponent(U8 exponent); + U8 getEnvironmentIntensity() const; + void setEnvironmentIntensity(U8 intensity); + U8 getDiffuseAlphaMode() const; + void setDiffuseAlphaMode(U8 alpha_mode); + U8 getAlphaMaskCutoff() const; + void setAlphaMaskCutoff(U8 cutoff); + + bool isNull() const; + static const LLMaterial null; + + bool operator == (const LLMaterial& rhs) const; + bool operator != (const LLMaterial& rhs) const; + + U32 getShaderMask(U32 alpha_mode = DIFFUSE_ALPHA_MODE_DEFAULT); protected: - LLUUID mNormalID; - F32 mNormalOffsetX; - F32 mNormalOffsetY; - F32 mNormalRepeatX; - F32 mNormalRepeatY; - F32 mNormalRotation; - - LLUUID mSpecularID; - F32 mSpecularOffsetX; - F32 mSpecularOffsetY; - F32 mSpecularRepeatX; - F32 mSpecularRepeatY; - F32 mSpecularRotation; - - LLColor4U mSpecularLightColor; - U8 mSpecularLightExponent; - U8 mEnvironmentIntensity; - U8 mDiffuseAlphaMode; - U8 mAlphaMaskCutoff; + LLUUID mNormalID; + F32 mNormalOffsetX; + F32 mNormalOffsetY; + F32 mNormalRepeatX; + F32 mNormalRepeatY; + F32 mNormalRotation; + + LLUUID mSpecularID; + F32 mSpecularOffsetX; + F32 mSpecularOffsetY; + F32 mSpecularRepeatX; + F32 mSpecularRepeatY; + F32 mSpecularRotation; + + LLColor4U mSpecularLightColor; + U8 mSpecularLightExponent; + U8 mEnvironmentIntensity; + U8 mDiffuseAlphaMode; + U8 mAlphaMaskCutoff; }; typedef LLPointer<LLMaterial> LLMaterialPtr; diff --git a/indra/llrender/llgl.cpp b/indra/llrender/llgl.cpp index 35b6951779..79a50d199a 100644 --- a/indra/llrender/llgl.cpp +++ b/indra/llrender/llgl.cpp @@ -2561,5 +2561,11 @@ void LLGLSyncFence::wait() #endif } - +#if LL_WINDOWS +// Expose desired use of high-performance graphics processor to Optimus driver +extern "C" +{ + _declspec(dllexport) DWORD NvOptimusEnablement = 0x00000001; +} +#endif diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp index 687b76c224..125c8be317 100644 --- a/indra/newview/llappviewer.cpp +++ b/indra/newview/llappviewer.cpp @@ -1083,7 +1083,7 @@ bool LLAppViewer::init() } } -// don't nag developers who need to run the executable directly +// do not pester devs who need to run the executable directly to debug #if LL_RELEASE_FOR_DOWNLOAD // MAINT-8305: If we're processing a SLURL, skip the launcher check. if (gSavedSettings.getString("CmdLineLoginLocation").empty()) diff --git a/indra/newview/llhudeffectlookat.cpp b/indra/newview/llhudeffectlookat.cpp index 73120a0242..f46152dcec 100644 --- a/indra/newview/llhudeffectlookat.cpp +++ b/indra/newview/llhudeffectlookat.cpp @@ -495,6 +495,8 @@ void LLHUDEffectLookAt::render() { gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); + LLGLDisable gls_stencil(GL_STENCIL_TEST); + LLVector3 target = mTargetPos + ((LLVOAvatar*)(LLViewerObject*)mSourceObject)->mHeadp->getWorldPosition(); gGL.matrixMode(LLRender::MM_MODELVIEW); gGL.pushMatrix(); diff --git a/indra/newview/llhudeffectpointat.cpp b/indra/newview/llhudeffectpointat.cpp index 44c8db19c0..cc772c8f5c 100644 --- a/indra/newview/llhudeffectpointat.cpp +++ b/indra/newview/llhudeffectpointat.cpp @@ -322,6 +322,7 @@ void LLHUDEffectPointAt::render() update(); if (sDebugPointAt && mTargetType != POINTAT_TARGET_NONE) { + LLGLDisable gls_stencil(GL_STENCIL_TEST); gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); LLVector3 target = mTargetPos + mSourceObject->getRenderPosition(); diff --git a/indra/newview/llhudicon.cpp b/indra/newview/llhudicon.cpp index 825c2b31be..85a878c4a2 100644 --- a/indra/newview/llhudicon.cpp +++ b/indra/newview/llhudicon.cpp @@ -80,6 +80,7 @@ void LLHUDIcon::renderIcon(BOOL for_select) { LLGLSUIDefault texture_state; LLGLDepthTest gls_depth(GL_TRUE); + LLGLDisable gls_stencil(GL_STENCIL_TEST); if (for_select) { gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); diff --git a/indra/newview/llhudnametag.cpp b/indra/newview/llhudnametag.cpp index c7d108b6de..81d862a827 100644 --- a/indra/newview/llhudnametag.cpp +++ b/indra/newview/llhudnametag.cpp @@ -224,6 +224,7 @@ void LLHUDNameTag::render() if (sDisplayText) { LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE); + LLGLDisable gls_stencil(GL_STENCIL_TEST); renderText(FALSE); } } diff --git a/indra/newview/llhudtext.cpp b/indra/newview/llhudtext.cpp index 6b1e196182..ef3b234f50 100644 --- a/indra/newview/llhudtext.cpp +++ b/indra/newview/llhudtext.cpp @@ -102,6 +102,7 @@ void LLHUDText::render() if (!mOnHUDAttachment && sDisplayText) { LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE); + LLGLDisable gls_stencil(GL_STENCIL_TEST); renderText(); } } diff --git a/indra/newview/lllogininstance.cpp b/indra/newview/lllogininstance.cpp index bc93fa2c20..deef3dbce7 100644 --- a/indra/newview/lllogininstance.cpp +++ b/indra/newview/lllogininstance.cpp @@ -113,6 +113,11 @@ void LLLoginInstance::connect(LLPointer<LLCredential> credentials) { std::vector<std::string> uris; LLGridManager::getInstance()->getLoginURIs(uris); + if (uris.size() < 1) + { + LL_WARNS() << "Failed to get login URIs during connect. No connect for you!" << LL_ENDL; + return; + } connect(uris.front(), credentials); } diff --git a/indra/newview/llpanelface.cpp b/indra/newview/llpanelface.cpp index 01ce4470f0..b71e98b102 100644 --- a/indra/newview/llpanelface.cpp +++ b/indra/newview/llpanelface.cpp @@ -550,8 +550,14 @@ struct LLPanelFaceSetAlignedTEFunctor : public LLSelectedTEFunctor if (set_aligned) { object->setTEOffset(te, uv_offset.mV[VX], uv_offset.mV[VY]); - object->setTEScale(te, uv_scale.mV[VX], uv_scale.mV[VY]); + object->setTEScale(te, uv_scale.mV[VX], uv_scale.mV[VY]); object->setTERotation(te, uv_rot); + LLPanelFace::LLSelectedTEMaterial::setNormalOffsetX(mPanel, uv_offset.mV[VX], te); + LLPanelFace::LLSelectedTEMaterial::setNormalOffsetY(mPanel, uv_offset.mV[VY], te); + LLPanelFace::LLSelectedTEMaterial::setSpecularOffsetX(mPanel, uv_offset.mV[VX], te); + LLPanelFace::LLSelectedTEMaterial::setSpecularOffsetY(mPanel, uv_offset.mV[VY], te); + LLPanelFace::LLSelectedTEMaterial::setNormalRotation(mPanel, uv_rot, te); + LLPanelFace::LLSelectedTEMaterial::setSpecularRotation(mPanel, uv_rot, te); } } if (!set_aligned) @@ -599,12 +605,19 @@ struct LLPanelFaceGetIsAlignedTEFunctor : public LLSelectedTEFunctor tep->getOffset(&st_offset.mV[VX], &st_offset.mV[VY]); tep->getScale(&st_scale.mV[VX], &st_scale.mV[VY]); F32 st_rot = tep->getRotation(); + + bool eq_offset_x = is_approx_equal_fraction(st_offset.mV[VX], aligned_st_offset.mV[VX], 12); + bool eq_offset_y = is_approx_equal_fraction(st_offset.mV[VY], aligned_st_offset.mV[VY], 12); + bool eq_scale_x = is_approx_equal_fraction(st_scale.mV[VX], aligned_st_scale.mV[VX], 12); + bool eq_scale_y = is_approx_equal_fraction(st_scale.mV[VY], aligned_st_scale.mV[VY], 12); + bool eq_rot = is_approx_equal_fraction(st_rot, aligned_st_rot, 6); + // needs a fuzzy comparison, because of fp errors - if (is_approx_equal_fraction(st_offset.mV[VX], aligned_st_offset.mV[VX], 12) && - is_approx_equal_fraction(st_offset.mV[VY], aligned_st_offset.mV[VY], 12) && - is_approx_equal_fraction(st_scale.mV[VX], aligned_st_scale.mV[VX], 12) && - is_approx_equal_fraction(st_scale.mV[VY], aligned_st_scale.mV[VY], 12) && - is_approx_equal_fraction(st_rot, aligned_st_rot, 14)) + if (eq_offset_x && + eq_offset_y && + eq_scale_x && + eq_scale_y && + eq_rot) { return true; } @@ -967,9 +980,9 @@ void LLPanelFace::updateUI(bool force_set_values /*false*/) F32 spec_scale_s = 1.f; F32 norm_scale_s = 1.f; - LLSelectedTE::getScaleS( diff_scale_s, identical_diff_scale_s); - LLSelectedTEMaterial::getSpecularRepeatX( spec_scale_s, identical_spec_scale_s); - LLSelectedTEMaterial::getNormalRepeatX( norm_scale_s, identical_norm_scale_s); + LLSelectedTE::getScaleS(diff_scale_s, identical_diff_scale_s); + LLSelectedTEMaterial::getSpecularRepeatX(spec_scale_s, identical_spec_scale_s); + LLSelectedTEMaterial::getNormalRepeatX(norm_scale_s, identical_norm_scale_s); diff_scale_s = editable ? diff_scale_s : 1.0f; diff_scale_s *= identical_planar_texgen ? 2.0f : 1.0f; @@ -2051,10 +2064,10 @@ void LLPanelFace::onCommitMaterialShinyScaleY(LLUICtrl* ctrl, void* userdata) } //static -void LLPanelFace::syncMaterialRot(LLPanelFace* self, F32 rot) +void LLPanelFace::syncMaterialRot(LLPanelFace* self, F32 rot, int te) { - LLSelectedTEMaterial::setNormalRotation(self,rot * DEG_TO_RAD); - LLSelectedTEMaterial::setSpecularRotation(self,rot * DEG_TO_RAD); + LLSelectedTEMaterial::setNormalRotation(self,rot * DEG_TO_RAD, te); + LLSelectedTEMaterial::setSpecularRotation(self,rot * DEG_TO_RAD, te); self->sendTextureInfo(); } @@ -2432,7 +2445,7 @@ void LLPanelFace::LLSelectedTE::getFace(LLFace*& face_to_return, bool& identical return (object->mDrawable) ? object->mDrawable->getFace(te): NULL; } } get_te_face_func; - identical_face = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue(&get_te_face_func, face_to_return); + identical_face = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue(&get_te_face_func, face_to_return, false, (LLFace*)nullptr); } void LLPanelFace::LLSelectedTE::getImageFormat(LLGLenum& image_format_to_return, bool& identical_face) diff --git a/indra/newview/llpanelface.h b/indra/newview/llpanelface.h index 7c084cb0ab..4937966034 100644 --- a/indra/newview/llpanelface.h +++ b/indra/newview/llpanelface.h @@ -179,7 +179,7 @@ protected: static void syncRepeatY(LLPanelFace* self, F32 scaleV); static void syncOffsetX(LLPanelFace* self, F32 offsetU); static void syncOffsetY(LLPanelFace* self, F32 offsetV); - static void syncMaterialRot(LLPanelFace* self, F32 rot); + static void syncMaterialRot(LLPanelFace* self, F32 rot, int te = -1); static void onCommitMaterialShinyScaleX( LLUICtrl* ctrl, void* userdata); static void onCommitMaterialShinyScaleY( LLUICtrl* ctrl, void* userdata); @@ -252,7 +252,7 @@ private: typename DataType, typename SetValueType, void (LLMaterial::*MaterialEditFunc)(SetValueType data) > - static void edit(LLPanelFace* p, DataType data) + static void edit(LLPanelFace* p, DataType data, int te = -1) { LLMaterialEditFunctor< DataType, SetValueType, MaterialEditFunc > edit(data); struct LLSelectedTEEditMaterial : public LLSelectedTEMaterialFunctor @@ -327,14 +327,14 @@ private: LLMaterialEditFunctor< DataType, SetValueType, MaterialEditFunc >* _edit; LLPanelFace* _panel; } editor(p, &edit); - LLSelectMgr::getInstance()->selectionSetMaterialParams(&editor); + LLSelectMgr::getInstance()->selectionSetMaterialParams(&editor, te); } template< typename DataType, - typename ReturnType, + typename ReturnType, ReturnType (LLMaterial::* const MaterialGetFunc)() const > - static void getTEMaterialValue(DataType& data_to_return, bool& identical,DataType default_value) + static void getTEMaterialValue(DataType& data_to_return, bool& identical,DataType default_value, bool has_tolerance = false, DataType tolerance = DataType()) { DataType data_value; struct GetTEMaterialVal : public LLSelectedTEGetFunctor<DataType> @@ -359,7 +359,7 @@ private: } DataType _default; } GetFunc(default_value); - identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &GetFunc, data_value); + identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &GetFunc, data_value, has_tolerance, tolerance); data_to_return = data_value; } @@ -367,7 +367,7 @@ 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, DataType default_value) + static void getTEValue(DataType& data_to_return, bool& identical, DataType default_value, bool has_tolerance = false, DataType tolerance = DataType()) { DataType data_value; struct GetTEVal : public LLSelectedTEGetFunctor<DataType> @@ -381,7 +381,7 @@ private: } DataType _default; } GetTEValFunc(default_value); - identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &GetTEValFunc, data_value ); + identical = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &GetTEValFunc, data_value, has_tolerance, tolerance ); data_to_return = data_value; } @@ -414,6 +414,7 @@ private: bool mUpdateInFlight; bool mUpdatePending; +public: #if defined(DEF_GET_MAT_STATE) #undef DEF_GET_MAT_STATE #endif @@ -426,29 +427,29 @@ private: DEF_EDIT_MAT_STATE #endif - // Accessors for selected TE material state - // - #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); \ - } - - // Accessors for selected TE state proper (legacy settings etc) - // - #define DEF_GET_TE_STATE(DataType,ReturnType,TexEntryMemberFunc,DefaultValue) \ - static void TexEntryMemberFunc(DataType& data, bool& identical) \ - { \ - getTEValue< DataType, ReturnType, &LLTextureEntry::TexEntryMemberFunc >(data, identical,DefaultValue); \ - } + // Accessors for selected TE material state + // + #define DEF_GET_MAT_STATE(DataType,ReturnType,MaterialMemberFunc,DefaultValue,HasTolerance,Tolerance) \ + static void MaterialMemberFunc(DataType& data, bool& identical, bool has_tolerance = HasTolerance, DataType tolerance = Tolerance) \ + { \ + getTEMaterialValue< DataType, ReturnType, &LLMaterial::MaterialMemberFunc >(data, identical, DefaultValue, has_tolerance, tolerance); \ + } + + // Mutators for selected TE material + // + #define DEF_EDIT_MAT_STATE(DataType,ReturnType,MaterialMemberFunc) \ + static void MaterialMemberFunc(LLPanelFace* p, DataType data, int te = -1) \ + { \ + edit< DataType, ReturnType, &LLMaterial::MaterialMemberFunc >(p, data, te); \ + } + + // Accessors for selected TE state proper (legacy settings etc) + // + #define DEF_GET_TE_STATE(DataType,ReturnType,TexEntryMemberFunc,DefaultValue,HasTolerance,Tolerance) \ + static void TexEntryMemberFunc(DataType& data, bool& identical, bool has_tolerance = HasTolerance, DataType tolerance = Tolerance) \ + { \ + getTEValue< DataType, ReturnType, &LLTextureEntry::TexEntryMemberFunc >(data, identical, DefaultValue, has_tolerance, tolerance); \ + } class LLSelectedTEMaterial { @@ -458,19 +459,19 @@ private: static void getMaxNormalRepeats(F32& repeats, bool& identical); static void getCurrentDiffuseAlphaMode(U8& diffuse_alpha_mode, bool& identical, bool diffuse_texture_has_alpha); - DEF_GET_MAT_STATE(LLUUID,const LLUUID&,getNormalID,LLUUID::null) - DEF_GET_MAT_STATE(LLUUID,const LLUUID&,getSpecularID,LLUUID::null) - 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(LLUUID,const LLUUID&,getNormalID,LLUUID::null, false, LLUUID::null) + DEF_GET_MAT_STATE(LLUUID,const LLUUID&,getSpecularID,LLUUID::null, false, LLUUID::null) + DEF_GET_MAT_STATE(F32,F32,getSpecularRepeatX,1.0f, true, 0.001f) + DEF_GET_MAT_STATE(F32,F32,getSpecularRepeatY,1.0f, true, 0.001f) + DEF_GET_MAT_STATE(F32,F32,getSpecularOffsetX,0.0f, true, 0.001f) + DEF_GET_MAT_STATE(F32,F32,getSpecularOffsetY,0.0f, true, 0.001f) + DEF_GET_MAT_STATE(F32,F32,getSpecularRotation,0.0f, true, 0.001f) - 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_GET_MAT_STATE(F32,F32,getNormalRepeatX,1.0f, true, 0.001f) + DEF_GET_MAT_STATE(F32,F32,getNormalRepeatY,1.0f, true, 0.001f) + DEF_GET_MAT_STATE(F32,F32,getNormalOffsetX,0.0f, true, 0.001f) + DEF_GET_MAT_STATE(F32,F32,getNormalOffsetY,0.0f, true, 0.001f) + DEF_GET_MAT_STATE(F32,F32,getNormalRotation,0.0f, true, 0.001f) DEF_EDIT_MAT_STATE(U8,U8,setDiffuseAlphaMode); DEF_EDIT_MAT_STATE(U8,U8,setAlphaMaskCutoff); @@ -506,17 +507,17 @@ private: static void getObjectScaleT(F32& scale_t, bool& identical); static void getMaxDiffuseRepeats(F32& repeats, bool& identical); - 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) + DEF_GET_TE_STATE(U8,U8,getBumpmap,0, false, 0) + DEF_GET_TE_STATE(U8,U8,getShiny,0, false, 0) + DEF_GET_TE_STATE(U8,U8,getFullbright,0, false, 0) + DEF_GET_TE_STATE(F32,F32,getRotation,0.0f, true, 0.001f) + DEF_GET_TE_STATE(F32,F32,getOffsetS,0.0f, true, 0.001f) + DEF_GET_TE_STATE(F32,F32,getOffsetT,0.0f, true, 0.001f) + DEF_GET_TE_STATE(F32,F32,getScaleS,1.0f, true, 0.001f) + DEF_GET_TE_STATE(F32,F32,getScaleT,1.0f, true, 0.001f) + DEF_GET_TE_STATE(F32,F32,getGlow,0.0f, true, 0.001f) + DEF_GET_TE_STATE(LLTextureEntry::e_texgen,LLTextureEntry::e_texgen,getTexGen,LLTextureEntry::TEX_GEN_DEFAULT, false, LLTextureEntry::TEX_GEN_DEFAULT) + DEF_GET_TE_STATE(LLColor4,const LLColor4&,getColor,LLColor4::white, false, LLColor4::black); }; }; diff --git a/indra/newview/llselectmgr.cpp b/indra/newview/llselectmgr.cpp index ddae109030..245d248390 100644 --- a/indra/newview/llselectmgr.cpp +++ b/indra/newview/llselectmgr.cpp @@ -2080,29 +2080,33 @@ void LLSelectMgr::selectionSetGlow(F32 glow) mSelectedObjects->applyToObjects( &func2 ); } -void LLSelectMgr::selectionSetMaterialParams(LLSelectedTEMaterialFunctor* material_func) +void LLSelectMgr::selectionSetMaterialParams(LLSelectedTEMaterialFunctor* material_func, int te) { struct f1 : public LLSelectedTEFunctor { LLMaterialPtr mMaterial; - f1(LLSelectedTEMaterialFunctor* material_func) : _material_func(material_func) {} + f1(LLSelectedTEMaterialFunctor* material_func, int te) : _material_func(material_func), _specific_te(te) {} - bool apply(LLViewerObject* object, S32 face) + bool apply(LLViewerObject* object, S32 te) { - if (object && object->permModify() && _material_func) - { - LLTextureEntry* tep = object->getTE(face); - if (tep) - { - LLMaterialPtr current_material = tep->getMaterialParams(); - _material_func->apply(object, face, tep, current_material); - } - } + if (_specific_te == -1 || (te == _specific_te)) + { + if (object && object->permModify() && _material_func) + { + LLTextureEntry* tep = object->getTE(te); + if (tep) + { + LLMaterialPtr current_material = tep->getMaterialParams(); + _material_func->apply(object, te, tep, current_material); + } + } + } return true; } LLSelectedTEMaterialFunctor* _material_func; - } func1(material_func); + int _specific_te; + } func1(material_func, te); mSelectedObjects->applyToTEs( &func1 ); struct f2 : public LLSelectedObjectFunctor @@ -7932,3 +7936,40 @@ void LLSelectMgr::sendSelectionMove() //saveSelectedObjectTransform(SELECT_ACTION_TYPE_PICK); } + +template<> +bool LLCheckIdenticalFunctor<F32>::same(const F32& a, const F32& b, const F32& tolerance) +{ + F32 delta = (a - b); + F32 abs_delta = fabs(delta); + return abs_delta <= tolerance; +} + +#define DEF_DUMMY_CHECK_FUNCTOR(T) \ +template<> \ +bool LLCheckIdenticalFunctor<T>::same(const T& a, const T& b, const T& tolerance) \ +{ \ + (void)tolerance; \ + return a == b; \ +} + +DEF_DUMMY_CHECK_FUNCTOR(LLUUID) +DEF_DUMMY_CHECK_FUNCTOR(LLGLenum) +DEF_DUMMY_CHECK_FUNCTOR(LLTextureEntry) +DEF_DUMMY_CHECK_FUNCTOR(LLTextureEntry::e_texgen) +DEF_DUMMY_CHECK_FUNCTOR(bool) +DEF_DUMMY_CHECK_FUNCTOR(U8) +DEF_DUMMY_CHECK_FUNCTOR(int) +DEF_DUMMY_CHECK_FUNCTOR(LLColor4) +DEF_DUMMY_CHECK_FUNCTOR(LLMediaEntry) +DEF_DUMMY_CHECK_FUNCTOR(LLPointer<LLMaterial>) +DEF_DUMMY_CHECK_FUNCTOR(std::string) +DEF_DUMMY_CHECK_FUNCTOR(std::vector<std::string>) + +template<> +bool LLCheckIdenticalFunctor<class LLFace *>::same(class LLFace* const & a, class LLFace* const & b, class LLFace* const & tolerance) \ +{ \ + (void)tolerance; \ + return a == b; \ +} + diff --git a/indra/newview/llselectmgr.h b/indra/newview/llselectmgr.h index e965dd80d5..cbe9200c4e 100644 --- a/indra/newview/llselectmgr.h +++ b/indra/newview/llselectmgr.h @@ -124,6 +124,11 @@ template <typename T> struct LLSelectedTEGetFunctor virtual T get(LLViewerObject* object, S32 te) = 0; }; +template <typename T> struct LLCheckIdenticalFunctor +{ + static bool same(const T& a, const T& b, const T& tolerance); +}; + typedef enum e_send_type { SEND_ONLY_ROOTS, @@ -313,7 +318,7 @@ public: LLViewerObject* getPrimaryObject() { return mPrimaryObject; } // iterate through texture entries - template <typename T> bool getSelectedTEValue(LLSelectedTEGetFunctor<T>* func, T& res); + template <typename T> bool getSelectedTEValue(LLSelectedTEGetFunctor<T>* func, T& res, bool has_tolerance = false, T tolerance = T()); template <typename T> bool isMultipleTEValue(LLSelectedTEGetFunctor<T>* func, const T& ignore_value); S32 getNumNodes(); @@ -591,7 +596,7 @@ public: void selectionSetClickAction(U8 action); void selectionSetIncludeInSearch(bool include_in_search); void selectionSetGlow(const F32 glow); - void selectionSetMaterialParams(LLSelectedTEMaterialFunctor* material_func); + void selectionSetMaterialParams(LLSelectedTEMaterialFunctor* material_func, int specific_te = -1); void selectionRemoveMaterial(); void selectionSetObjectPermissions(U8 perm_field, BOOL set, U32 perm_mask, BOOL override = FALSE); @@ -856,7 +861,7 @@ void dialog_refresh_all(); //----------------------------------------------------------------------------- // getSelectedTEValue //----------------------------------------------------------------------------- -template <typename T> bool LLObjectSelection::getSelectedTEValue(LLSelectedTEGetFunctor<T>* func, T& res) +template <typename T> bool LLObjectSelection::getSelectedTEValue(LLSelectedTEGetFunctor<T>* func, T& res, bool has_tolerance, T tolerance) { bool have_first = false; bool have_selected = false; @@ -892,7 +897,14 @@ template <typename T> bool LLObjectSelection::getSelectedTEValue(LLSelectedTEGet { if ( value != selected_value ) { - identical = false; + if (!has_tolerance) + { + identical = false; + } + else if (!LLCheckIdenticalFunctor<T>::same(value, selected_value, tolerance)) + { + identical = false; + } } if (te == selected_te) { diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp index 1f69939c46..f8849bf997 100644 --- a/indra/newview/lltexturefetch.cpp +++ b/indra/newview/lltexturefetch.cpp @@ -60,13 +60,16 @@ #include "bufferarray.h" #include "bufferstream.h" #include "llcorehttputil.h" - #include "llhttpretrypolicy.h" bool LLTextureFetchDebugger::sDebuggerEnabled = false ; -LLTrace::EventStatHandle<LLUnit<F32, LLUnits::Percent> > LLTextureFetch::sCacheHitRate("texture_cache_hits"); -LLTrace::EventStatHandle<F64Milliseconds > LLTextureFetch::sCacheReadLatency("texture_cache_read_latency"); +LLTrace::CountStatHandle<F64> LLTextureFetch::sCacheHit("texture_cache_hit"); +LLTrace::CountStatHandle<F64> LLTextureFetch::sCacheAttempt("texture_cache_attempt"); + +LLTrace::SampleStatHandle<F32Seconds> LLTextureFetch::sCacheReadLatency("texture_cache_read_latency"); +LLTrace::SampleStatHandle<F32Seconds> LLTextureFetch::sTexDecodeLatency("texture_decode_latency"); +LLTrace::SampleStatHandle<F32Seconds> LLTextureFetch::sTexFetchLatency("texture_fetch_latency"); ////////////////////////////////////////////////////////////////////////////// // @@ -564,15 +567,21 @@ private: F32 mImagePriority; U32 mWorkPriority; F32 mRequestedPriority; - S32 mDesiredDiscard, - mSimRequestedDiscard, - mRequestedDiscard, - mLoadedDiscard, - mDecodedDiscard; - LLFrameTimer mRequestedTimer, - mFetchTimer; - LLTimer mCacheReadTimer; - F32 mCacheReadTime; + S32 mDesiredDiscard; + S32 mSimRequestedDiscard; + S32 mRequestedDiscard; + S32 mLoadedDiscard; + S32 mDecodedDiscard; + S32 mFullWidth; + S32 mFullHeight; + LLFrameTimer mRequestedDeltaTimer; + LLFrameTimer mFetchDeltaTimer; + LLTimer mCacheReadTimer; + LLTimer mDecodeTimer; + LLTimer mFetchTimer; + F32 mCacheReadTime; // time for cache read only + F32 mDecodeTime; // time for decode only + F32 mFetchTime; // total time from req to finished fetch LLTextureCache::handle_t mCacheReadHandle, mCacheWriteHandle; S32 mRequestedSize, @@ -906,6 +915,8 @@ LLTextureFetchWorker::LLTextureFetchWorker(LLTextureFetch* fetcher, mLoadedDiscard(-1), mDecodedDiscard(-1), mCacheReadTime(0.f), + mDecodeTime(0.f), + mFetchTime(0.f), mCacheReadHandle(LLTextureCache::nullHandle()), mCacheWriteHandle(LLTextureCache::nullHandle()), mRequestedSize(0), @@ -1167,7 +1178,7 @@ bool LLTextureFetchWorker::doWork(S32 param) if (mState != DONE) { - mFetchTimer.reset(); + mFetchDeltaTimer.reset(); } if (mState == INIT) @@ -1218,7 +1229,9 @@ bool LLTextureFetchWorker::doWork(S32 param) } mFileSize = 0; mLoaded = FALSE; - + + add(LLTextureFetch::sCacheAttempt, 1.0); + if (mUrl.compare(0, 7, "file://") == 0) { setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority); // Set priority first since Responder may change it @@ -1229,7 +1242,7 @@ bool LLTextureFetchWorker::doWork(S32 param) CacheReadResponder* responder = new CacheReadResponder(mFetcher, mID, mFormattedImage); mCacheReadHandle = mFetcher->mTextureCache->readFromCache(filename, mID, cache_priority, offset, size, responder); - mCacheReadTimer.reset(); + mCacheReadTimer.reset(); } else if ((mUrl.empty() || mFTType==FTT_SERVER_BAKE) && mFetcher->canLoadFromCache()) { @@ -1260,6 +1273,7 @@ bool LLTextureFetchWorker::doWork(S32 param) { mCacheReadHandle = LLTextureCache::nullHandle(); setState(CACHE_POST); + add(LLTextureFetch::sCacheHit, 1.0); // fall through } else @@ -1297,7 +1311,6 @@ bool LLTextureFetchWorker::doWork(S32 param) LL_DEBUGS(LOG_TXT) << mID << ": Cached. Bytes: " << mFormattedImage->getDataSize() << " Size: " << llformat("%dx%d",mFormattedImage->getWidth(),mFormattedImage->getHeight()) << " Desired Discard: " << mDesiredDiscard << " Desired Size: " << mDesiredSize << LL_ENDL; - record(LLTextureFetch::sCacheHitRate, LLUnits::Ratio::fromValue(1)); } else { @@ -1315,7 +1328,6 @@ bool LLTextureFetchWorker::doWork(S32 param) } // fall through - record(LLTextureFetch::sCacheHitRate, LLUnits::Ratio::fromValue(0)); } } @@ -1571,7 +1583,7 @@ bool LLTextureFetchWorker::doWork(S32 param) return true; // failed } - mRequestedTimer.reset(); + mRequestedDeltaTimer.reset(); mLoaded = FALSE; mGetStatus = LLCore::HttpStatus(); mGetReason.clear(); @@ -1898,6 +1910,8 @@ bool LLTextureFetchWorker::doWork(S32 param) mFetcher->getFetchDebugger()->addHistoryEntry(this); } + mDecodeTime = mDecodeTimer.getElapsedTimeF32(); + if (mDecodedDiscard < 0) { if (mCachedSize > 0 && !mInLocalCache && mRetryAttempt == 0) @@ -2002,6 +2016,7 @@ bool LLTextureFetchWorker::doWork(S32 param) else { setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority); + mFetchTime = mFetchTimer.getElapsedTimeF32(); return true; } } @@ -2945,11 +2960,12 @@ bool LLTextureFetch::getRequestFinished(const LLUUID& id, S32& discard_level, discard_level = worker->mDecodedDiscard; raw = worker->mRawImage; aux = worker->mAuxImage; - F32Seconds cache_read_time(worker->mCacheReadTime); - if (cache_read_time != (F32Seconds)0.f) - { - record(sCacheReadLatency, cache_read_time); - } + sample(sTexDecodeLatency, worker->mDecodeTime); + sample(sTexFetchLatency, worker->mFetchTime); + sample(sCacheReadLatency, worker->mCacheReadTime); + worker->mCacheReadTimer.reset(); + worker->mDecodeTimer.reset(); + worker->mFetchTimer.reset(); res = true; LL_DEBUGS(LOG_TXT) << id << ": Request Finished. State: " << worker->mState << " Discard: " << discard_level << LL_ENDL; worker->unlockWorkMutex(); // -Mw @@ -3253,7 +3269,7 @@ void LLTextureFetch::sendRequestListToSimulators() // req->setPriority(LLWorkerThread::PRIORITY_HIGH | req->mWorkPriority); continue; } - F32 elapsed = req->mRequestedTimer.getElapsedTimeF32(); + F32 elapsed = req->mRequestedDeltaTimer.getElapsedTimeF32(); { F32 delta_priority = llabs(req->mRequestedPriority - req->mImagePriority); if ((req->mSimRequestedDiscard != req->mDesiredDiscard) || @@ -3322,7 +3338,7 @@ void LLTextureFetch::sendRequestListToSimulators() req->mSentRequest = LLTextureFetchWorker::SENT_SIM; req->mSimRequestedDiscard = req->mDesiredDiscard; req->mRequestedPriority = req->mImagePriority; - req->mRequestedTimer.reset(); + req->mRequestedDeltaTimer.reset(); req->unlockWorkMutex(); // -Mw sim_request_count++; if (sim_request_count >= IMAGES_PER_REQUEST) @@ -3397,7 +3413,7 @@ void LLTextureFetch::sendRequestListToSimulators() // Locks: Mw bool LLTextureFetchWorker::insertPacket(S32 index, U8* data, S32 size) { - mRequestedTimer.reset(); + mRequestedDeltaTimer.reset(); if (index >= mTotalPackets) { // LL_WARNS(LOG_TXT) << "Received Image Packet " << index << " > max: " << mTotalPackets << " for image: " << mID << LL_ENDL; @@ -3606,8 +3622,8 @@ S32 LLTextureFetch::getFetchState(const LLUUID& id, F32& data_progress_p, F32& r { worker->lockWorkMutex(); // +Mw state = worker->mState; - fetch_dtime = worker->mFetchTimer.getElapsedTimeF32(); - request_dtime = worker->mRequestedTimer.getElapsedTimeF32(); + fetch_dtime = worker->mFetchDeltaTimer.getElapsedTimeF32(); + request_dtime = worker->mRequestedDeltaTimer.getElapsedTimeF32(); if (worker->mFileSize > 0) { if (state == LLTextureFetchWorker::LOAD_FROM_SIMULATOR) diff --git a/indra/newview/lltexturefetch.h b/indra/newview/lltexturefetch.h index cfa312ccd9..a2155bde1f 100644 --- a/indra/newview/lltexturefetch.h +++ b/indra/newview/lltexturefetch.h @@ -308,13 +308,16 @@ public: S32 mPacketCount; S32 mBadPacketCount; + static LLTrace::CountStatHandle<F64> sCacheHit; + static LLTrace::CountStatHandle<F64> sCacheAttempt; + static LLTrace::SampleStatHandle<F32Seconds> sCacheReadLatency; + static LLTrace::SampleStatHandle<F32Seconds> sTexDecodeLatency; + static LLTrace::SampleStatHandle<F32Seconds> sTexFetchLatency; + private: LLMutex mQueueMutex; //to protect mRequestMap and mCommands only LLMutex mNetworkQueueMutex; //to protect mNetworkQueue, mHTTPTextureQueue and mCancelQueue. - static LLTrace::EventStatHandle<LLUnit<F32, LLUnits::Percent> > sCacheHitRate; - static LLTrace::EventStatHandle<F64Milliseconds > sCacheReadLatency; - LLTextureCache* mTextureCache; LLImageDecodeThread* mImageDecodeThread; diff --git a/indra/newview/lltextureview.cpp b/indra/newview/lltextureview.cpp index d7b95db94f..0d2edc0268 100644 --- a/indra/newview/lltextureview.cpp +++ b/indra/newview/lltextureview.cpp @@ -240,9 +240,9 @@ void LLTextureBar::draw() { "REQ", LLColor4::yellow },// SEND_HTTP_REQ { "HTP", LLColor4::green }, // WAIT_HTTP_REQ { "DEC", LLColor4::yellow },// DECODE_IMAGE - { "DEC", LLColor4::green }, // DECODE_IMAGE_UPDATE + { "DEU", LLColor4::green }, // DECODE_IMAGE_UPDATE { "WRT", LLColor4::purple },// WRITE_TO_CACHE - { "WRT", LLColor4::orange },// WAIT_ON_WRITE + { "WWT", LLColor4::orange },// WAIT_ON_WRITE { "END", LLColor4::red }, // DONE #define LAST_STATE 14 { "CRE", LLColor4::magenta }, // LAST_STATE+1 @@ -530,6 +530,25 @@ void LLGLTexMemBar::draw() LLFontGL::getFontMonospace()->renderUTF8(text, 0, 0, v_offset + line_height*6, text_color, LLFontGL::LEFT, LLFontGL::TOP); + LLTrace::Recording& recording = LLViewerStats::instance().getRecording(); + + F64 cacheHits = recording.getSampleCount(LLTextureFetch::sCacheHit); + F64 cacheAttempts = recording.getSampleCount(LLTextureFetch::sCacheAttempt); + + F32 cacheHitRate = (cacheAttempts > 0.0) ? F32((cacheHits / cacheAttempts) * 100.0f) : 0.0f; + + U32 cacheReadLatMin = U32(recording.getMin(LLTextureFetch::sCacheReadLatency).value() * 1000.0f); + U32 cacheReadLatMed = U32(recording.getMean(LLTextureFetch::sCacheReadLatency).value() * 1000.0f); + U32 cacheReadLatMax = U32(recording.getMax(LLTextureFetch::sCacheReadLatency).value() * 1000.0f); + + U32 texDecodeLatMin = U32(recording.getMin(LLTextureFetch::sTexDecodeLatency).value() * 1000.0f); + U32 texDecodeLatMed = U32(recording.getMean(LLTextureFetch::sTexDecodeLatency).value() * 1000.0f); + U32 texDecodeLatMax = U32(recording.getMax(LLTextureFetch::sTexDecodeLatency).value() * 1000.0f); + + U32 texFetchLatMin = U32(recording.getMin(LLTextureFetch::sTexFetchLatency).value() * 1000.0f); + U32 texFetchLatMed = U32(recording.getMean(LLTextureFetch::sTexFetchLatency).value() * 1000.0f); + U32 texFetchLatMax = U32(recording.getMax(LLTextureFetch::sTexFetchLatency).value() * 1000.0f); + text = llformat("GL Tot: %d/%d MB Bound: %d/%d MB FBO: %d MB Raw Tot: %d MB Bias: %.2f Cache: %.1f/%.1f MB", total_mem.value(), max_total_mem.value(), @@ -542,7 +561,7 @@ void LLGLTexMemBar::draw() cache_max_usage); //, cache_entries, cache_max_entries - LLFontGL::getFontMonospace()->renderUTF8(text, 0, 0, v_offset + line_height*5, + LLFontGL::getFontMonospace()->renderUTF8(text, 0, 0, v_offset + line_height*6, text_color, LLFontGL::LEFT, LLFontGL::TOP); U32 cache_read(0U), cache_write(0U), res_wait(0U); @@ -558,6 +577,21 @@ void LLGLTexMemBar::draw() cache_write, res_wait); + LLFontGL::getFontMonospace()->renderUTF8(text, 0, 0, v_offset + line_height*5, + text_color, LLFontGL::LEFT, LLFontGL::TOP); + + text = llformat("CacheHitRate: %3.2f Read: %d/%d/%d Decode: %d/%d/%d Fetch: %d/%d/%d", + cacheHitRate, + cacheReadLatMin, + cacheReadLatMed, + cacheReadLatMax, + texDecodeLatMin, + texDecodeLatMed, + texDecodeLatMax, + texFetchLatMin, + texFetchLatMed, + texFetchLatMax); + LLFontGL::getFontMonospace()->renderUTF8(text, 0, 0, v_offset + line_height*4, text_color, LLFontGL::LEFT, LLFontGL::TOP); @@ -640,7 +674,7 @@ BOOL LLGLTexMemBar::handleMouseDown(S32 x, S32 y, MASK mask) LLRect LLGLTexMemBar::getRequiredRect() { LLRect rect; - rect.mTop = 68; //LLFontGL::getFontMonospace()->getLineHeight() * 6; + rect.mTop = 78; //LLFontGL::getFontMonospace()->getLineHeight() * 6; return rect; } diff --git a/indra/newview/llviewernetwork.cpp b/indra/newview/llviewernetwork.cpp index 9f6d606a22..fe8069cf03 100644 --- a/indra/newview/llviewernetwork.cpp +++ b/indra/newview/llviewernetwork.cpp @@ -484,12 +484,19 @@ void LLGridManager::getLoginURIs(const std::string& grid, std::vector<std::strin std::string grid_name = getGrid(grid); if (!grid_name.empty()) { - for (LLSD::array_iterator llsd_uri = mGridList[grid_name][GRID_LOGIN_URI_VALUE].beginArray(); - llsd_uri != mGridList[grid_name][GRID_LOGIN_URI_VALUE].endArray(); - llsd_uri++) - { - uris.push_back(llsd_uri->asString()); - } + if (mGridList[grid_name][GRID_LOGIN_URI_VALUE].isArray()) + { + for (LLSD::array_iterator llsd_uri = mGridList[grid_name][GRID_LOGIN_URI_VALUE].beginArray(); + llsd_uri != mGridList[grid_name][GRID_LOGIN_URI_VALUE].endArray(); + llsd_uri++) + { + uris.push_back(llsd_uri->asString()); + } + } + else + { + uris.push_back(mGridList[grid_name][GRID_LOGIN_URI_VALUE].asString()); + } } else { diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp index ff7647a7e4..d2acfa291c 100644 --- a/indra/newview/llviewershadermgr.cpp +++ b/indra/newview/llviewershadermgr.cpp @@ -2065,6 +2065,7 @@ BOOL LLViewerShaderMgr::loadShadersObject() gObjectSimpleNonIndexedProgram.mFeatures.hasAtmospherics = true; gObjectSimpleNonIndexedProgram.mFeatures.hasLighting = true; gObjectSimpleNonIndexedProgram.mFeatures.disableTextureIndex = true; + gObjectSimpleNonIndexedProgram.mFeatures.hasAlphaMask = true; gObjectSimpleNonIndexedProgram.mShaderFiles.clear(); gObjectSimpleNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER_ARB)); gObjectSimpleNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER_ARB)); diff --git a/indra/newview/llviewertexture.cpp b/indra/newview/llviewertexture.cpp index 39ffbfc989..712d0883d3 100644 --- a/indra/newview/llviewertexture.cpp +++ b/indra/newview/llviewertexture.cpp @@ -1189,9 +1189,17 @@ void LLViewerFetchedTexture::loadFromFastCache() } mInFastCacheList = FALSE; + add(LLTextureFetch::sCacheAttempt, 1.0); + + LLTimer fastCacheTimer; mRawImage = LLAppViewer::getTextureCache()->readFromFastCache(getID(), mRawDiscardLevel); if(mRawImage.notNull()) { + F32 cachReadTime = fastCacheTimer.getElapsedTimeF32(); + + add(LLTextureFetch::sCacheHit, 1.0); + sample(LLTextureFetch::sCacheReadLatency, cachReadTime); + mFullWidth = mRawImage->getWidth() << mRawDiscardLevel; mFullHeight = mRawImage->getHeight() << mRawDiscardLevel; setTexelsPerImage(); diff --git a/indra/newview/llvoicevisualizer.cpp b/indra/newview/llvoicevisualizer.cpp index cb83cf8fdf..6e08a2ff12 100644 --- a/indra/newview/llvoicevisualizer.cpp +++ b/indra/newview/llvoicevisualizer.cpp @@ -356,6 +356,7 @@ void LLVoiceVisualizer::render() //--------------------------------------------------------------- LLGLSPipelineAlpha alpha_blend; LLGLDepthTest depth(GL_TRUE, GL_FALSE); + LLGLDisable gls_stencil(GL_STENCIL_TEST); //------------------------------------------------------------- // create coordinates of the geometry for the dot diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp index e541c1054e..5699d47ad8 100644 --- a/indra/newview/pipeline.cpp +++ b/indra/newview/pipeline.cpp @@ -2514,8 +2514,8 @@ void LLPipeline::updateCull(LLCamera& camera, LLCullResult& result, S32 water_cl LLSpatialPartition* part = region->getSpatialPartition(i); if (part) { - if (hasRenderType(part->mDrawableType)) - { + if (LLViewerRegion::PARTITION_BRIDGE == i || hasRenderType(part->mDrawableType)) + { //pass PARTITION BRIDGE because LLDrawable can be moved to this partition part->cull(camera); } } diff --git a/indra/newview/skins/default/xui/en/panel_tools_texture.xml b/indra/newview/skins/default/xui/en/panel_tools_texture.xml index 8c769d87de..67b99ca588 100644 --- a/indra/newview/skins/default/xui/en/panel_tools_texture.xml +++ b/indra/newview/skins/default/xui/en/panel_tools_texture.xml @@ -603,11 +603,10 @@ layout="topleft" label_width="205" left="10" - max_val="9999" - min_val="-9999" + max_val="360" + min_val="-360" name="TexRot" width="265" /> - <spinner follows="left|top" height="19" @@ -617,6 +616,7 @@ layout="topleft" left="10" min_val="-1" + max_val="1" name="TexOffsetU" width="265" /> <spinner @@ -628,6 +628,7 @@ layout="topleft" left="10" min_val="-1" + max_val="1" name="TexOffsetV" width="265" /> <spinner @@ -667,10 +668,9 @@ label_width="205" left="10" max_val="360" - min_val="0" + min_val="-360" name="bumpyRot" width="265" /> - <spinner follows="left|top" height="19" @@ -679,7 +679,8 @@ label_width="205" layout="topleft" left="10" - min_val="0" + min_val="-1" + max_val="1" name="bumpyOffsetU" width="265" /> <spinner @@ -690,7 +691,8 @@ label_width="205" layout="topleft" left="10" - min_val="0" + min_val="-1" + max_val="1" name="bumpyOffsetV" width="265" /> <spinner @@ -730,10 +732,9 @@ label_width="205" left="10" max_val="360" - min_val="0" + min_val="-360" name="shinyRot" width="265" /> - <spinner follows="left|top" height="19" @@ -742,7 +743,8 @@ label_width="205" layout="topleft" left="10" - min_val="0" + min_val="-1" + max_val="1" name="shinyOffsetU" width="265" /> <spinner @@ -753,7 +755,8 @@ label_width="205" layout="topleft" left="10" - min_val="0" + min_val="-1" + max_val="1" name="shinyOffsetV" width="265" /> <check_box |