Reverting changes to texture pipeline back to stock LL
Ansariel
parent
2339174f66
commit
f530540d00
|
|
@ -35,10 +35,6 @@ LLCamera::LLCamera() :
|
|||
LLCoordFrame(),
|
||||
mView(DEFAULT_FIELD_OF_VIEW),
|
||||
mAspect(DEFAULT_ASPECT_RATIO),
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//mInverseAspect(1.0f / DEFAULT_ASPECT_RATIO),
|
||||
mDrawDistanceMultiplier(1.0f),
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
mViewHeightInPixels( -1 ), // invalid height
|
||||
mNearPlane(DEFAULT_NEAR_PLANE),
|
||||
mFarPlane(DEFAULT_FAR_PLANE),
|
||||
|
|
@ -67,18 +63,10 @@ LLCamera::LLCamera(F32 vertical_fov_rads, F32 aspect_ratio, S32 view_height_in_p
|
|||
}
|
||||
|
||||
mAspect = llclamp(aspect_ratio, MIN_ASPECT_RATIO, MAX_ASPECT_RATIO);
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Store the inverse of the aspect ratio, so we can remove it from texture calculations
|
||||
//mInverseAspect = 1.0f / mAspect;
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
mNearPlane = llclamp(near_plane, MIN_NEAR_PLANE, MAX_NEAR_PLANE);
|
||||
if(far_plane < 0) far_plane = DEFAULT_FAR_PLANE;
|
||||
mFarPlane = llclamp(far_plane, MIN_FAR_PLANE, MAX_FAR_PLANE);
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Store the draw distance multiplier based upon how much bigger/smaller the far plan is then the default (64.0f)
|
||||
mDrawDistanceMultiplier = mFarPlane / DEFAULT_FAR_PLANE;
|
||||
mDrawDistanceMultiplier = mDrawDistanceMultiplier < 1.0f ? 1.0f : mDrawDistanceMultiplier;
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
|
||||
setView(vertical_fov_rads);
|
||||
}
|
||||
|
||||
|
|
@ -141,10 +129,6 @@ void LLCamera::setViewHeightInPixels(S32 height)
|
|||
void LLCamera::setAspect(F32 aspect_ratio)
|
||||
{
|
||||
mAspect = llclamp(aspect_ratio, MIN_ASPECT_RATIO, MAX_ASPECT_RATIO);
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Store the inverse of the aspect ratio, so we can remove it from texture calculations
|
||||
//mInverseAspect = 1.0f / mAspect;
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
calculateFrustumPlanes();
|
||||
}
|
||||
|
||||
|
|
@ -159,11 +143,6 @@ void LLCamera::setNear(F32 near_plane)
|
|||
void LLCamera::setFar(F32 far_plane)
|
||||
{
|
||||
mFarPlane = llclamp(far_plane, MIN_FAR_PLANE, MAX_FAR_PLANE);
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Store the draw distance multiplier based upon how much bigger/smaller the far plan is then the default (64.0f)
|
||||
mDrawDistanceMultiplier = mFarPlane / DEFAULT_FAR_PLANE;
|
||||
mDrawDistanceMultiplier = mDrawDistanceMultiplier < 1.0f ? 1.0f : mDrawDistanceMultiplier;
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
calculateFrustumPlanes();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -127,11 +127,6 @@ private:
|
|||
|
||||
F32 mView; // angle between top and bottom frustum planes in radians.
|
||||
F32 mAspect; // width/height
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Store the inverse of the aspect ratio, for the texture's sizes
|
||||
//F32 mInverseAspect; // height/width
|
||||
F32 mDrawDistanceMultiplier; // mFarPlane / DEFAULT_FAR_PLANE
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
S32 mViewHeightInPixels; // for ViewHeightInPixels() only
|
||||
F32 mNearPlane;
|
||||
F32 mFarPlane;
|
||||
|
|
@ -166,10 +161,6 @@ public:
|
|||
F32 getView() const { return mView; } // vertical FOV in radians
|
||||
S32 getViewHeightInPixels() const { return mViewHeightInPixels; }
|
||||
F32 getAspect() const { return mAspect; } // width / height
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//F32 getInverseAspect() const { return mInverseAspect; } // width / height
|
||||
F32 getDrawDistanceMultiplier() const { return mDrawDistanceMultiplier; } // mFarPlane / DEFAULT_FAR_PLANE (could also include near plane as well)
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
F32 getNear() const { return mNearPlane; } // meters
|
||||
F32 getFar() const { return mFarPlane; } // meters
|
||||
|
||||
|
|
|
|||
|
|
@ -63,10 +63,6 @@ LLGLTexture::~LLGLTexture()
|
|||
void LLGLTexture::init()
|
||||
{
|
||||
mBoostLevel = LLGLTexture::BOOST_NONE;
|
||||
// <FS:minerjr>
|
||||
// Added a previous boost level to allow for restorign boost after BOOST_SELECTED is applied
|
||||
mPrevBoostLevel = LLGLTexture::BOOST_NONE;
|
||||
// </FS:minerjr>
|
||||
|
||||
mFullWidth = 0;
|
||||
mFullHeight = 0;
|
||||
|
|
@ -104,12 +100,6 @@ void LLGLTexture::setBoostLevel(S32 level)
|
|||
if(mBoostLevel != LLGLTexture::BOOST_NONE
|
||||
&& mBoostLevel != LLGLTexture::BOOST_ICON
|
||||
&& mBoostLevel != LLGLTexture::BOOST_THUMBNAIL
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Add the new grass, light and tree boosts
|
||||
&& mBoostLevel != LLGLTexture::BOOST_GRASS
|
||||
&& mBoostLevel != LLGLTexture::BOOST_LIGHT
|
||||
&& mBoostLevel != LLGLTexture::BOOST_TREE
|
||||
// <FS:minerjr> [FIRE-35081]
|
||||
&& mBoostLevel != LLGLTexture::BOOST_TERRAIN)
|
||||
{
|
||||
setNoDelete() ;
|
||||
|
|
@ -117,18 +107,6 @@ void LLGLTexture::setBoostLevel(S32 level)
|
|||
}
|
||||
}
|
||||
|
||||
// <FS:minerjr>
|
||||
// Changes the current boost level to the previous value
|
||||
void LLGLTexture::restoreBoostLevel()
|
||||
{
|
||||
mBoostLevel = mPrevBoostLevel;
|
||||
}
|
||||
// Stores the current boost level in a the previous boost.
|
||||
void LLGLTexture::storeBoostLevel()
|
||||
{
|
||||
mPrevBoostLevel = mBoostLevel;
|
||||
}
|
||||
// </FS:minerjr>
|
||||
void LLGLTexture::forceActive()
|
||||
{
|
||||
mTextureState = ACTIVE ;
|
||||
|
|
|
|||
|
|
@ -53,11 +53,6 @@ public:
|
|||
BOOST_AVATAR_BAKED ,
|
||||
BOOST_TERRAIN , // Needed for minimap generation for now. Lower than BOOST_HIGH so the texture stats don't get forced, i.e. texture stats are manually managed by minimap/terrain instead.
|
||||
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
BOOST_GRASS , // Grass has a alternative calculation for virtual and face sizes.
|
||||
BOOST_TREE , // Tree has a alternative calculation for virtual and face sizes.
|
||||
BOOST_LIGHT , // Light textures has a alternative calculation for virtual and face sizes.
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
BOOST_HIGH = 10,
|
||||
BOOST_SCULPTED ,
|
||||
BOOST_BUMP ,
|
||||
|
|
@ -106,10 +101,6 @@ public:
|
|||
|
||||
void setBoostLevel(S32 level);
|
||||
S32 getBoostLevel() { return mBoostLevel; }
|
||||
// <FS:minerjr>
|
||||
void restoreBoostLevel(); // Now restores the mBoostLevel with the mPrevBoostLevel
|
||||
void storeBoostLevel(); // Stores the current mBoostLevel in mPrevBoostLevel
|
||||
// </FS:minerjr>
|
||||
|
||||
S32 getFullWidth() const { return mFullWidth; }
|
||||
S32 getFullHeight() const { return mFullHeight; }
|
||||
|
|
@ -192,10 +183,6 @@ public:
|
|||
|
||||
protected:
|
||||
S32 mBoostLevel; // enum describing priority level
|
||||
// <FS:minerjr>
|
||||
// Added previous value to allow for restoring of BOOST_SELECTED overriding current state
|
||||
S32 mPrevBoostLevel; // enum describing priority level (Previous Value for BOOST_SELECTION restore)
|
||||
// </FS:minerjr>
|
||||
U32 mFullWidth;
|
||||
U32 mFullHeight;
|
||||
bool mUseMipMaps;
|
||||
|
|
|
|||
|
|
@ -641,11 +641,6 @@ bool LLImageGL::setSize(S32 width, S32 height, S32 ncomponents, S32 discard_leve
|
|||
if(discard_level > 0)
|
||||
{
|
||||
mMaxDiscardLevel = llmax(mMaxDiscardLevel, (S8)discard_level);
|
||||
// <FS:minerjr> [FIRE-35361] RenderMaxTextureResolution caps texture resolution lower than intended
|
||||
// 2K textures could set the mMaxDiscardLevel above MAX_DISCARD_LEVEL, which would
|
||||
// cause them to not be down-scaled so they would get stuck at 0 discard all the time.
|
||||
mMaxDiscardLevel = llmax(mMaxDiscardLevel, (S8)MAX_DISCARD_LEVEL);
|
||||
// </FS:minerjr> [FIRE-35361]
|
||||
}
|
||||
}
|
||||
else
|
||||
|
|
|
|||
|
|
@ -565,13 +565,8 @@ void LLConsole::Paragraph::updateLines(F32 screen_width, const LLFontGL* font, L
|
|||
{
|
||||
if ( !force_resize )
|
||||
{
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// if ( mMaxWidth >= 0.0f
|
||||
//&& mMaxWidth < screen_width)
|
||||
// If viewer window was made as small as possible with the console enabled, it would cause an assert error
|
||||
// as the line below can go as small as -38
|
||||
if ( ((mMaxWidth >= 0.0f) && (mMaxWidth < screen_width)) || (screen_width <= 30) )
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
if ( mMaxWidth >= 0.0f
|
||||
&& mMaxWidth < screen_width)
|
||||
{
|
||||
return; //No resize required.
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6001,13 +6001,7 @@ void LLAppViewer::idle()
|
|||
// objects and camera should be in sync, do LOD calculations now
|
||||
{
|
||||
LL_RECORD_BLOCK_TIME(FTM_LOD_UPDATE);
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Added a max time limit to the object list updates as these updates do affect the texture system
|
||||
//gObjectList.updateApparentAngles(gAgent);
|
||||
F32 max_update_apparent_angles = 0.025f * gFrameIntervalSeconds.value(); // 20 ms/second decode time
|
||||
max_update_apparent_angles = llclamp(max_update_apparent_angles, 0.002f, 0.005f); // min 2ms/frame, max 5ms/frame)
|
||||
gObjectList.updateApparentAngles(gAgent, max_update_apparent_angles);
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
gObjectList.updateApparentAngles(gAgent);
|
||||
}
|
||||
|
||||
// Update AV render info
|
||||
|
|
|
|||
|
|
@ -75,14 +75,6 @@ static LLStaticHashedString sColorIn("color_in");
|
|||
|
||||
bool LLFace::sSafeRenderSelect = true; // false
|
||||
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Moved to allow more code to access these values
|
||||
const S8 FACE_IMPORTANCE_LEVEL = 4 ;
|
||||
const F32 FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[FACE_IMPORTANCE_LEVEL][2] = //{distance, importance_weight}
|
||||
{{16.1f, 1.0f}, {32.1f, 0.5f}, {48.1f, 0.2f}, {96.1f, 0.05f} } ;
|
||||
const F32 FACE_IMPORTANCE_TO_CAMERA_OVER_ANGLE[FACE_IMPORTANCE_LEVEL][2] = //{cos(angle), importance_weight}
|
||||
{{0.985f /*cos(10 degrees)*/, 1.0f}, {0.94f /*cos(20 degrees)*/, 0.8f}, {0.866f /*cos(30 degrees)*/, 0.64f}, {0.0f, 0.36f}} ;
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
|
||||
#define DOTVEC(a,b) (a.mV[0]*b.mV[0] + a.mV[1]*b.mV[1] + a.mV[2]*b.mV[2])
|
||||
|
||||
|
|
@ -179,10 +171,7 @@ void LLFace::init(LLDrawable* drawablep, LLViewerObject* objp)
|
|||
|
||||
mFaceColor = LLColor4(1,0,0,1);
|
||||
|
||||
mImportanceToCamera = 1.f ;
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
mCloseToCamera = 1.0f;
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
mImportanceToCamera = 0.f ;
|
||||
mBoundingSphereRadius = 0.0f ;
|
||||
|
||||
mTexExtents[0].set(0, 0);
|
||||
|
|
@ -1683,10 +1672,7 @@ bool LLFace::getGeometryVolume(const LLVolume& volume,
|
|||
xforms = XFORM_NONE;
|
||||
}
|
||||
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Removed check for turning off animations
|
||||
//if (getVirtualSize() >= MIN_TEX_ANIM_SIZE) // || isState(LLFace::RIGGED))
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
if (getVirtualSize() >= MIN_TEX_ANIM_SIZE) // || isState(LLFace::RIGGED))
|
||||
{ //don't override texture transform during tc bake
|
||||
tex_mode = 0;
|
||||
}
|
||||
|
|
@ -2287,16 +2273,10 @@ F32 LLFace::getTextureVirtualSize()
|
|||
|
||||
F32 radius;
|
||||
F32 cos_angle_to_view_dir;
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//bool in_frustum = calcPixelArea(cos_angle_to_view_dir, radius);
|
||||
// The mInFrustum value is now updated in calcPixelArea, so no longer need to accss the value
|
||||
calcPixelArea(cos_angle_to_view_dir, radius);
|
||||
bool in_frustum = calcPixelArea(cos_angle_to_view_dir, radius);
|
||||
|
||||
|
||||
//if (mPixelArea < F_ALMOST_ZERO || !in_frustum)
|
||||
// Use the stored value from calcPixelArea
|
||||
if (mPixelArea < F_ALMOST_ZERO || !mInFrustum)
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
if (mPixelArea < F_ALMOST_ZERO || !in_frustum)
|
||||
{
|
||||
setVirtualSize(0.f) ;
|
||||
return 0.f;
|
||||
|
|
@ -2325,10 +2305,6 @@ F32 LLFace::getTextureVirtualSize()
|
|||
}
|
||||
|
||||
face_area = LLFace::adjustPixelArea(mImportanceToCamera, face_area);
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Remove the face area being affected by being partial off screen as close to screen textures can then become scaled down along with
|
||||
// animated textures.
|
||||
/*
|
||||
if(face_area > LLViewerTexture::sMinLargeImageSize) //if is large image, shrink face_area by considering the partial overlapping.
|
||||
{
|
||||
if(mImportanceToCamera > LEAST_IMPORTANCE_FOR_LARGE_IMAGE && mTexture[LLRender::DIFFUSE_MAP].notNull() && mTexture[LLRender::DIFFUSE_MAP]->isLargeImage())
|
||||
|
|
@ -2336,8 +2312,7 @@ F32 LLFace::getTextureVirtualSize()
|
|||
face_area *= adjustPartialOverlapPixelArea(cos_angle_to_view_dir, radius );
|
||||
}
|
||||
}
|
||||
*/
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
|
||||
setVirtualSize(face_area) ;
|
||||
|
||||
return face_area;
|
||||
|
|
@ -2423,10 +2398,6 @@ bool LLFace::calcPixelArea(F32& cos_angle_to_view_dir, F32& radius)
|
|||
// no rigged extents, zero out bounding box and skip update
|
||||
mRiggedExtents[0] = mRiggedExtents[1] = LLVector4a(0.f, 0.f, 0.f);
|
||||
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Set the face to be out of the frustum as the object is invalid
|
||||
mInFrustum = false;
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -2473,14 +2444,6 @@ bool LLFace::calcPixelArea(F32& cos_angle_to_view_dir, F32& radius)
|
|||
LLVector4a x_axis;
|
||||
x_axis.load3(camera->getXAxis().mV);
|
||||
cos_angle_to_view_dir = lookAt.dot3(x_axis).getF32();
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Added close to camera (based upon the mImportanceToCamera) where any object that is within the FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE (16.1f)
|
||||
// gets an extra texture scaling up.
|
||||
// Use positive distance to the camera and apply the multiplier based upon the texture scaled for increase in the default draw distance
|
||||
mCloseToCamera = (dist >= 0.0f && dist <= FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[0][0] * camera->getDrawDistanceMultiplier()) ? 1.0f : 0.0f;
|
||||
// Check if the object is positive distance to the far plane and positive cos angle is in frustum
|
||||
mInFrustum = (dist >= 0 && dist <= camera->getFar() && cos_angle_to_view_dir > 0.0f);
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
|
||||
//if has media, check if the face is out of the view frustum.
|
||||
if(hasMedia())
|
||||
|
|
@ -2488,10 +2451,6 @@ bool LLFace::calcPixelArea(F32& cos_angle_to_view_dir, F32& radius)
|
|||
if(!camera->AABBInFrustum(center, size))
|
||||
{
|
||||
mImportanceToCamera = 0.f ;
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Added real in frustum check value. Previous was only false for media textures off screen and invalid rig objects
|
||||
mInFrustum = false;
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
return false ;
|
||||
}
|
||||
if(cos_angle_to_view_dir > camera->getCosHalfFov()) //the center is within the view frustum
|
||||
|
|
@ -2514,10 +2473,6 @@ bool LLFace::calcPixelArea(F32& cos_angle_to_view_dir, F32& radius)
|
|||
{
|
||||
cos_angle_to_view_dir = 1.0f ;
|
||||
mImportanceToCamera = 1.0f ;
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
mInFrustum = true; // If the face is important to the camera, it is in the frustum
|
||||
mCloseToCamera = 1.0f;
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -2556,21 +2511,22 @@ F32 LLFace::adjustPartialOverlapPixelArea(F32 cos_angle_to_view_dir, F32 radius
|
|||
return 1.0f ;
|
||||
}
|
||||
|
||||
const S8 FACE_IMPORTANCE_LEVEL = 4 ;
|
||||
const F32 FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[FACE_IMPORTANCE_LEVEL][2] = //{distance, importance_weight}
|
||||
{{16.1f, 1.0f}, {32.1f, 0.5f}, {48.1f, 0.2f}, {96.1f, 0.05f} } ;
|
||||
const F32 FACE_IMPORTANCE_TO_CAMERA_OVER_ANGLE[FACE_IMPORTANCE_LEVEL][2] = //{cos(angle), importance_weight}
|
||||
{{0.985f /*cos(10 degrees)*/, 1.0f}, {0.94f /*cos(20 degrees)*/, 0.8f}, {0.866f /*cos(30 degrees)*/, 0.64f}, {0.0f, 0.36f}} ;
|
||||
|
||||
//static
|
||||
F32 LLFace::calcImportanceToCamera(F32 cos_angle_to_view_dir, F32 dist)
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_FACE;
|
||||
F32 importance = 0.f ;
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Move camera out to use for the inital check for the distance to the face importance with the multiplier
|
||||
LLViewerCamera* camera = LLViewerCamera::getInstance();
|
||||
|
||||
if(cos_angle_to_view_dir > LLViewerCamera::getInstance()->getCosHalfFov() &&
|
||||
//dist < FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[FACE_IMPORTANCE_LEVEL - 1][0])
|
||||
dist < FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[FACE_IMPORTANCE_LEVEL - 1][0] * camera->getDrawDistanceMultiplier())
|
||||
if(cos_angle_to_view_dir > LLViewerCamera::getInstance()->getCosHalfFov() &&
|
||||
dist < FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[FACE_IMPORTANCE_LEVEL - 1][0])
|
||||
{
|
||||
//LLViewerCamera* camera = LLViewerCamera::getInstance();
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
LLViewerCamera* camera = LLViewerCamera::getInstance();
|
||||
F32 camera_moving_speed = camera->getAverageSpeed() ;
|
||||
F32 camera_angular_speed = camera->getAverageAngularSpeed();
|
||||
|
||||
|
|
@ -2581,10 +2537,7 @@ F32 LLFace::calcImportanceToCamera(F32 cos_angle_to_view_dir, F32 dist)
|
|||
}
|
||||
|
||||
S32 i = 0 ;
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Added draw distance multiplier to the distance
|
||||
for(i = 0; i < FACE_IMPORTANCE_LEVEL && dist > FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[i][0] * camera->getDrawDistanceMultiplier(); ++i);
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
for(i = 0; i < FACE_IMPORTANCE_LEVEL && dist > FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[i][0]; ++i);
|
||||
i = llmin(i, FACE_IMPORTANCE_LEVEL - 1) ;
|
||||
F32 dist_factor = FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[i][1] ;
|
||||
|
||||
|
|
|
|||
|
|
@ -52,11 +52,7 @@ class LLDrawInfo;
|
|||
class LLMeshSkinInfo;
|
||||
|
||||
const F32 MIN_ALPHA_SIZE = 1024.f;
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//const F32 MIN_TEX_ANIM_SIZE = 512.f;
|
||||
// Change the min size to
|
||||
const F32 MIN_TEX_ANIM_SIZE = 10.f;
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
const F32 MIN_TEX_ANIM_SIZE = 512.f;
|
||||
const U8 FACE_DO_NOT_BATCH_TEXTURES = 255;
|
||||
|
||||
class alignas(16) LLFace
|
||||
|
|
@ -127,8 +123,6 @@ public:
|
|||
void setPixelArea(F32 area) { mPixelArea = area; }
|
||||
F32 getVirtualSize() const { return mVSize; }
|
||||
F32 getPixelArea() const { return mPixelArea; }
|
||||
F32 getImportanceToCamera() const { return mImportanceToCamera; }
|
||||
F32 getCloseToCamera() const { return mCloseToCamera; }
|
||||
|
||||
S32 getIndexInTex(U32 ch) const { llassert(ch < LLRender::NUM_TEXTURE_CHANNELS); return mIndexInTex[ch]; }
|
||||
void setIndexInTex(U32 ch, S32 index) { llassert(ch < LLRender::NUM_TEXTURE_CHANNELS); mIndexInTex[ch] = index; }
|
||||
|
|
@ -335,7 +329,6 @@ private:
|
|||
//1.0: the most important.
|
||||
//based on the distance from the face to the view point and the angle from the face center to the view direction.
|
||||
F32 mImportanceToCamera ;
|
||||
F32 mCloseToCamera;
|
||||
F32 mBoundingSphereRadius ;
|
||||
bool mHasMedia ;
|
||||
bool mIsMediaAllowed;
|
||||
|
|
|
|||
|
|
@ -2094,30 +2094,6 @@ LLPointer<LLImageRaw> LLTextureCache::readFromFastCache(const LLUUID& id, S32& d
|
|||
}
|
||||
LLPointer<LLImageRaw> raw = new LLImageRaw(data, head[0], head[1], head[2], true);
|
||||
|
||||
// <FS:minerjr>
|
||||
// This fixes the invalid discard values from being created which cause the decoder code to fail when trying to handle 6 and 7's which are above the MAX_DISCARD_LEVEL of 5
|
||||
// especially on load
|
||||
// We will expand the 16x16 texture to the actual MAX_DISCARD_LEVEL texture size, it may be blurry until the user gets closer but 5 discard value should be objects far from the camera.
|
||||
// So a 1024x1024 texture with a dicard of 6 will become 32x32 and a 2048x2048 texture with a discard of 7 will become a 64x64 texture.
|
||||
if (discardlevel > MAX_DISCARD_LEVEL)
|
||||
{
|
||||
LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("FixBadDiscardLevel");
|
||||
|
||||
S32 w = head[0]; // Get the current width from the header (16)
|
||||
S32 h = head[1]; // Get the current height from the header (16)
|
||||
|
||||
// Expand the width and height by teh difference between the discard and MAX_DISCARD_LEVEL bit shifted to the left. (Expand power of 2 textures)
|
||||
w <<= discardlevel - MAX_DISCARD_LEVEL;
|
||||
h <<= discardlevel - MAX_DISCARD_LEVEL;
|
||||
|
||||
// Set the discard level to the MAX_DISCARD_LEVEL
|
||||
discardlevel = MAX_DISCARD_LEVEL;
|
||||
|
||||
// Scale up the texture and scale the actual data, as we just created it above, it should be fine.
|
||||
raw->scale(w, h, true);
|
||||
}
|
||||
// </FS:minerjr>
|
||||
|
||||
return raw;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -12890,9 +12890,6 @@ void initialize_menus()
|
|||
// Develop (Fonts debugging)
|
||||
commit.add("Develop.Fonts.Dump", boost::bind(&LLFontGL::dumpFonts));
|
||||
commit.add("Develop.Fonts.DumpTextures", boost::bind(&LLFontGL::dumpFontTextures));
|
||||
|
||||
//Develop (dump data)
|
||||
commit.add("Develop.TextureList.Dump", boost::bind(&LLViewerTextureList::dumpTexturelist));
|
||||
|
||||
// <FS:Beq/> Add telemetry controls to the viewer Develop menu (Toggle profiling)
|
||||
view_listener_t::addMenu(new FSProfilerToggle(), "Develop.ToggleProfiling");
|
||||
|
|
|
|||
|
|
@ -4336,14 +4336,6 @@ void LLViewerObject::boostTexturePriority(bool boost_children /* = true */)
|
|||
S32 tex_count = getNumTEs();
|
||||
for (i = 0; i < tex_count; i++)
|
||||
{
|
||||
// <FS:minerjr>
|
||||
// This isused to fix the textures becoming blury when object interacted with by the user and unselected.
|
||||
// If this is changing the boost level for the TEImage for the first time, store the boost level before modifying it.
|
||||
if (getTEImage(i)->getBoostLevel() != LLGLTexture::BOOST_SELECTED)
|
||||
{
|
||||
getTEImage(i)->storeBoostLevel();
|
||||
}
|
||||
// </FS:minerjr>
|
||||
getTEImage(i)->setBoostLevel(LLGLTexture::BOOST_SELECTED);
|
||||
}
|
||||
|
||||
|
|
@ -4351,17 +4343,7 @@ void LLViewerObject::boostTexturePriority(bool boost_children /* = true */)
|
|||
{
|
||||
LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
|
||||
LLUUID sculpt_id = sculpt_params->getSculptTexture();
|
||||
// <FS:minerjr>
|
||||
//LLViewerTextureManager::getFetchedTexture(sculpt_id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE)->setBoostLevel(LLGLTexture::BOOST_SELECTED);
|
||||
// This isused to fix the textures becoming blury when object interacted with by the user and unselected.
|
||||
// If this is changing the boost level for the sculpted for the first time, store the boost level before modifying it.
|
||||
LLViewerFetchedTexture* sculptedTexture = LLViewerTextureManager::getFetchedTexture(sculpt_id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
|
||||
if (sculptedTexture->getBoostLevel() != LLGLTexture::BOOST_SELECTED)
|
||||
{
|
||||
sculptedTexture->storeBoostLevel();
|
||||
}
|
||||
// </FS:minerjr>
|
||||
sculptedTexture->setBoostLevel(LLGLTexture::BOOST_SELECTED);
|
||||
LLViewerTextureManager::getFetchedTexture(sculpt_id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE)->setBoostLevel(LLGLTexture::BOOST_SELECTED);
|
||||
}
|
||||
|
||||
if (boost_children)
|
||||
|
|
|
|||
|
|
@ -835,20 +835,13 @@ void LLViewerObjectList::setAllObjectDefaultTextures(U32 nChannel, bool fShowDef
|
|||
}
|
||||
}
|
||||
// [/SL:KB]
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//void LLViewerObjectList::updateApparentAngles(LLAgent &agent)
|
||||
// Added time limit on processing of objects as they affect the texture system (They also calcuate mMaxVirtualSize and mPixelArea)
|
||||
void LLViewerObjectList::updateApparentAngles(LLAgent &agent, F32 max_time)
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
|
||||
void LLViewerObjectList::updateApparentAngles(LLAgent &agent)
|
||||
{
|
||||
S32 i;
|
||||
LLViewerObject *objectp;
|
||||
|
||||
S32 num_updates, max_value;
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Remove the old code as it worked on fixed number of updates (Total # of Object / 128) per frame
|
||||
// and some objects had nothing to do while others were avatars or volumes and could t
|
||||
/*
|
||||
if (NUM_BINS - 1 == mCurBin)
|
||||
{
|
||||
// Remainder (mObjects.size() could have changed)
|
||||
|
|
@ -884,46 +877,7 @@ void LLViewerObjectList::updateApparentAngles(LLAgent &agent, F32 max_time)
|
|||
{
|
||||
mCurBin = (mCurBin + 1) % NUM_BINS;
|
||||
}
|
||||
*/
|
||||
num_updates = 0;
|
||||
max_value = (S32)mObjects.size();
|
||||
LLTimer timer;
|
||||
// If the number of objects since last being in here has changed (IE objects deleted, then reset the lazy update index)
|
||||
if (mCurLazyUpdateIndex >= max_value)
|
||||
{
|
||||
mCurLazyUpdateIndex = 0;
|
||||
}
|
||||
// Store the index for the current lazy update index as we will loop over the index
|
||||
i = mCurLazyUpdateIndex;
|
||||
// loop over number of objects in the BIN (128), or below until we run out of time
|
||||
while(num_updates < NUM_BINS)
|
||||
{
|
||||
// Moved to the first to fix up the issue of access violation if the object list chaanges size during processing.
|
||||
if (i >= (S32)mObjects.size())
|
||||
{
|
||||
// Reset the index if we go over the max value
|
||||
i = 0;
|
||||
}
|
||||
objectp = mObjects[i];
|
||||
if (objectp != nullptr && !objectp->isDead())
|
||||
{
|
||||
//LL_DEBUGS() << objectp->getID() << " Update Textures" << LL_ENDL;
|
||||
// Update distance & gpw
|
||||
objectp->setPixelAreaAndAngle(agent); // Also sets the approx. pixel area
|
||||
objectp->updateTextures(); // Update the image levels of textures for this object.
|
||||
}
|
||||
i++;
|
||||
|
||||
num_updates++;
|
||||
// Escape either if we run out of time, or loop back onto ourselves.
|
||||
if (timer.getElapsedTimeF32() > max_time || i == mCurLazyUpdateIndex)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
// Update the current lazy update index with the current index, so we can continue next frame from where we left off
|
||||
mCurLazyUpdateIndex = i;
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
#if 0
|
||||
// Slam priorities for textures that we care about (hovered, selected, and focused)
|
||||
// Hovered
|
||||
|
|
|
|||
|
|
@ -89,11 +89,7 @@ public:
|
|||
void processObjectUpdate(LLMessageSystem *mesgsys, void **user_data, EObjectUpdateType update_type, bool compressed=false);
|
||||
void processCompressedObjectUpdate(LLMessageSystem *mesgsys, void **user_data, EObjectUpdateType update_type);
|
||||
void processCachedObjectUpdate(LLMessageSystem *mesgsys, void **user_data, EObjectUpdateType update_type);
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//void updateApparentAngles(LLAgent &agent);
|
||||
// Added time limit on processing of objects as they affect the texture system
|
||||
void updateApparentAngles(LLAgent &agent, F32 max_time);
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
void updateApparentAngles(LLAgent &agent);
|
||||
void update(LLAgent &agent);
|
||||
|
||||
void fetchObjectCosts();
|
||||
|
|
|
|||
|
|
@ -779,12 +779,6 @@ void LLViewerTexture::setBoostLevel(S32 level)
|
|||
mBoostLevel = level;
|
||||
if(mBoostLevel != LLViewerTexture::BOOST_NONE &&
|
||||
mBoostLevel != LLViewerTexture::BOOST_SELECTED &&
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Added the new boost levels
|
||||
mBoostLevel != LLViewerTexture::BOOST_GRASS &&
|
||||
mBoostLevel != LLViewerTexture::BOOST_LIGHT &&
|
||||
mBoostLevel != LLViewerTexture::BOOST_TREE &&
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
mBoostLevel != LLViewerTexture::BOOST_ICON &&
|
||||
mBoostLevel != LLViewerTexture::BOOST_THUMBNAIL)
|
||||
{
|
||||
|
|
@ -796,13 +790,6 @@ void LLViewerTexture::setBoostLevel(S32 level)
|
|||
if (mBoostLevel >= LLViewerTexture::BOOST_HIGH)
|
||||
{
|
||||
mMaxVirtualSize = 2048.f * 2048.f;
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Add additional for the important to camera and in frustum
|
||||
static LLCachedControl<F32> texture_camera_boost(gSavedSettings, "TextureCameraBoost", 7.f);
|
||||
mMaxVirtualSize = mMaxVirtualSize + (mMaxVirtualSize * 1.0f * texture_camera_boost);
|
||||
// Apply second boost based upon if the texture is close to the camera (< 16.1 meters * draw distance multiplier)
|
||||
mMaxVirtualSize = mMaxVirtualSize + (mMaxVirtualSize * 1.0f * texture_camera_boost);
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1208,9 +1195,6 @@ void LLViewerFetchedTexture::init(bool firstinit)
|
|||
mKeptSavedRawImageTime = 0.f;
|
||||
mLastCallBackActiveTime = 0.f;
|
||||
mForceCallbackFetch = false;
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
mCloseToCamera = 1.0f; // Store if the camera is close to the camera (0.0f or 1.0f)
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
|
||||
mFTType = FTT_UNKNOWN;
|
||||
}
|
||||
|
|
@ -1283,7 +1267,7 @@ void LLViewerFetchedTexture::loadFromFastCache()
|
|||
record(LLTextureFetch::sCacheHitRate, LLUnits::Ratio::fromValue(1));
|
||||
sample(LLTextureFetch::sCacheReadLatency, cachReadTime);
|
||||
|
||||
mFullWidth = mRawImage->getWidth() << mRawDiscardLevel;
|
||||
mFullWidth = mRawImage->getWidth() << mRawDiscardLevel;
|
||||
mFullHeight = mRawImage->getHeight() << mRawDiscardLevel;
|
||||
setTexelsPerImage();
|
||||
|
||||
|
|
@ -3086,23 +3070,8 @@ void LLViewerLODTexture::processTextureStats()
|
|||
else if (mBoostLevel < LLGLTexture::BOOST_HIGH && mMaxVirtualSize <= 10.f)
|
||||
{
|
||||
// If the image has not been significantly visible in a while, we don't want it
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//mDesiredDiscardLevel = llmin(mMinDesiredDiscardLevel, (S8)(MAX_DISCARD_LEVEL + 1));
|
||||
// Off screen textures at 6 would not downscale.
|
||||
mDesiredDiscardLevel = llmin(mMinDesiredDiscardLevel, (S8)(MAX_DISCARD_LEVEL));
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
mDesiredDiscardLevel = llmin(mMinDesiredDiscardLevel, (S8)(MAX_DISCARD_LEVEL + 1));
|
||||
mDesiredDiscardLevel = llmin(mDesiredDiscardLevel, (S32)mLoadedCallbackDesiredDiscardLevel);
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Add scale down here as the textures off screen were not getting scaled down properly
|
||||
S32 current_discard = getDiscardLevel();
|
||||
if (mBoostLevel < LLGLTexture::BOOST_AVATAR_BAKED)
|
||||
{
|
||||
if (current_discard < mDesiredDiscardLevel && !mForceToSaveRawImage)
|
||||
{ // should scale down
|
||||
scaleDown();
|
||||
}
|
||||
}
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
}
|
||||
else if (!mFullWidth || !mFullHeight)
|
||||
{
|
||||
|
|
@ -3111,8 +3080,6 @@ void LLViewerLODTexture::processTextureStats()
|
|||
}
|
||||
else
|
||||
{
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
/*
|
||||
//static const F64 log_2 = log(2.0);
|
||||
static const F64 log_4 = log(4.0);
|
||||
|
||||
|
|
@ -3140,28 +3107,10 @@ void LLViewerLODTexture::processTextureStats()
|
|||
discard_level = floorf(discard_level);
|
||||
|
||||
F32 min_discard = 0.f;
|
||||
*/
|
||||
|
||||
// Use a S32 instead of a float
|
||||
S32 min_discard = 0;
|
||||
if (mFullWidth > max_tex_res || mFullHeight > max_tex_res)
|
||||
min_discard = 1;
|
||||
min_discard = 1.f;
|
||||
|
||||
// Use a S32 value for the discard level
|
||||
S32 discard_level = min_discard;
|
||||
// Find the best discard that covers the entire mMaxVirtualSize of the on screen texture (Use MAX_DISCARD_LEVEL as a max discard instead of MAX_DISCARD_LEVEL+1)
|
||||
for (; discard_level < MAX_DISCARD_LEVEL; discard_level++) // <FS:minerjr> [FIRE-35361] RenderMaxTextureResolution caps texture resolution lower than intended
|
||||
{
|
||||
// If the max virtual size is greater then or equal to the current discard level, then break out of the loop and use the current discard level
|
||||
if (mMaxVirtualSize >= getWidth(discard_level) * getHeight(discard_level)) // <FS:minerjr> [FIRE-35361] RenderMaxTextureResolution caps texture resolution lower than intended
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//discard_level = llclamp(discard_level, min_discard, (F32)MAX_DISCARD_LEVEL);
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
discard_level = llclamp(discard_level, min_discard, (F32)MAX_DISCARD_LEVEL);
|
||||
|
||||
// Can't go higher than the max discard level
|
||||
mDesiredDiscardLevel = llmin(getMaxDiscardLevel() + 1, (S32)discard_level);
|
||||
|
|
@ -3202,10 +3151,7 @@ void LLViewerLODTexture::processTextureStats()
|
|||
// unset it immediately after we consume it
|
||||
if (getBoostLevel() == BOOST_SELECTED)
|
||||
{
|
||||
// <FS:minerjr>
|
||||
//setBoostLevel(BOOST_NONE);
|
||||
restoreBoostLevel();
|
||||
// </FS:minerjr>
|
||||
setBoostLevel(BOOST_NONE);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3456,23 +3402,11 @@ void LLViewerMediaTexture::initVirtualSize()
|
|||
{
|
||||
return;
|
||||
}
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Add camera importance to the media textures as well
|
||||
static LLCachedControl<F32> texture_camera_boost(gSavedSettings, "TextureCameraBoost", 7.f);
|
||||
F32 vsize = 0.0f;
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
|
||||
findFaces();
|
||||
for(std::list< LLFace* >::iterator iter = mMediaFaceList.begin(); iter!= mMediaFaceList.end(); ++iter)
|
||||
{
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//addTextureStats((*iter)->getVirtualSize());
|
||||
// Add camera importance to the media textures as well
|
||||
vsize = (*iter)->getVirtualSize();
|
||||
vsize = vsize + (vsize * (*iter)->getImportanceToCamera() * texture_camera_boost);
|
||||
// Apply second boost based upon if the texture is close to the camera (< 16.1 meters * draw distance multiplier)
|
||||
vsize = vsize + (vsize * (*iter)->getCloseToCamera() * texture_camera_boost);
|
||||
addTextureStats(vsize);
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
addTextureStats((*iter)->getVirtualSize());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3531,11 +3465,6 @@ void LLViewerMediaTexture::addFace(U32 ch, LLFace* facep)
|
|||
return;
|
||||
}
|
||||
// [/SL:KB]
|
||||
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Try to set the boost level to MEDIA to try to force the media to high quality
|
||||
tex->setBoostLevel(LLViewerTexture::MEDIA);
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
mTextureList.push_back(tex);//increase the reference number by one for tex to avoid deleting it.
|
||||
return;
|
||||
}
|
||||
|
|
@ -3777,10 +3706,7 @@ F32 LLViewerMediaTexture::getMaxVirtualSize()
|
|||
{
|
||||
addTextureStats(0.f, false);//reset
|
||||
}
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
static LLCachedControl<F32> texture_camera_boost(gSavedSettings, "TextureCameraBoost", 7.f);
|
||||
F32 vsize = 0.0f;
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
|
||||
if(mIsPlaying) //media is playing
|
||||
{
|
||||
for (U32 ch = 0; ch < LLRender::NUM_TEXTURE_CHANNELS; ++ch)
|
||||
|
|
@ -3790,16 +3716,8 @@ F32 LLViewerMediaTexture::getMaxVirtualSize()
|
|||
{
|
||||
LLFace* facep = mFaceList[ch][i];
|
||||
if(facep->getDrawable()->isRecentlyVisible())
|
||||
{
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//addTextureStats(facep->getVirtualSize());
|
||||
// Add the importance to camera and close to camera to the media texture
|
||||
vsize = facep->getVirtualSize();
|
||||
vsize = vsize + (vsize * facep->getImportanceToCamera() * texture_camera_boost);
|
||||
// Apply second boost based upon if the texture is close to the camera (< 16.1 meters * draw distance multiplier)
|
||||
vsize = vsize + (vsize * facep->getCloseToCamera() * texture_camera_boost);
|
||||
addTextureStats(vsize);
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
{
|
||||
addTextureStats(facep->getVirtualSize());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -3815,15 +3733,7 @@ F32 LLViewerMediaTexture::getMaxVirtualSize()
|
|||
LLFace* facep = *iter;
|
||||
if(facep->getDrawable()->isRecentlyVisible())
|
||||
{
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//addTextureStats(facep->getVirtualSize());
|
||||
// Add the importance to camera and close to camera to the media texture
|
||||
vsize = facep->getVirtualSize();
|
||||
vsize = vsize + (vsize * facep->getImportanceToCamera() * texture_camera_boost);
|
||||
// Apply second boost based upon if the texture is close to the camera (< 16.1 meters * draw distance multiplier)
|
||||
vsize = vsize + (vsize * facep->getCloseToCamera() * texture_camera_boost);
|
||||
addTextureStats(vsize);
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
addTextureStats(facep->getVirtualSize());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -437,11 +437,6 @@ public:
|
|||
void setInFastCacheList(bool in_list) { mInFastCacheList = in_list; }
|
||||
bool isInFastCacheList() { return mInFastCacheList; }
|
||||
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
F32 getCloseToCamera() const {return mCloseToCamera ;} // Get close to camera value
|
||||
void setCloseToCamera(F32 value) {mCloseToCamera = value ;} // Set the close to camera value (0.0f or 1.0f)
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
|
||||
/*virtual*/bool isActiveFetching() override; //is actively in fetching by the fetching pipeline.
|
||||
|
||||
virtual bool scaleDown() { return false; };
|
||||
|
|
@ -542,9 +537,6 @@ protected:
|
|||
|
||||
bool mForSculpt ; //a flag if the texture is used as sculpt data.
|
||||
bool mIsFetched ; //is loaded from remote or from cache, not generated locally.
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
F32 mCloseToCamera; // Float (0.0f or 1.0f) to indicate if the texture is close to the camera
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
|
||||
public:
|
||||
static F32 sMaxVirtualSize; //maximum possible value of mMaxVirtualSize
|
||||
|
|
|
|||
|
|
@ -372,187 +372,23 @@ void LLViewerTextureList::shutdown()
|
|||
|
||||
mInitialized = false ; //prevent loading textures again.
|
||||
}
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// static
|
||||
// Allows the menu to call the dump method of the texture list
|
||||
void LLViewerTextureList::dumpTexturelist()
|
||||
{
|
||||
gTextureList.dump();
|
||||
}
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
|
||||
void LLViewerTextureList::dump()
|
||||
{
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
|
||||
LL_INFOS() << "LLViewerTextureList::dump()" << LL_ENDL;
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
S32 texture_count = 0;
|
||||
S32 textures_close_to_camera = 0;
|
||||
std::array<S32, MAX_DISCARD_LEVEL * 2 + 2> image_counts{0}; // Double the size for higher discards from textures < 1024 (2048 can make a 7 and 4096 could make an 8)
|
||||
std::array<S32, 12 * 12> size_counts{0}; // Track the 12 possible sizes (1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048)
|
||||
std::array<S32, (MAX_DISCARD_LEVEL * 2 + 2) * 12> discard_counts{0}; // Also need to an 1 additional as -1 is a valid discard level (not loaded by reported as a 1x1 texture)
|
||||
std::array<S32, (MAX_DISCARD_LEVEL * 2 + 2) * 12> fullsize_discard_counts{0}; // Also need to an 1 additional as -1 is a valid discard level (not loaded by reported as a 1x1 texture)
|
||||
std::array<S32, LLViewerTexture::BOOST_MAX_LEVEL * 12> boost_counts{0}; // Track the # of textures at boost levels by 12 possible sizes
|
||||
// Don't Init the buffers with 0's like it's the the 1980's...
|
||||
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
for (image_list_t::iterator it = mImageList.begin(); it != mImageList.end(); ++it)
|
||||
{
|
||||
LLViewerFetchedTexture* image = *it;
|
||||
|
||||
LL_INFOS() << "priority " << image->getMaxVirtualSize()
|
||||
<< " boost " << image->getBoostLevel()
|
||||
<< " size " << image->getWidth() << "x" << image->getHeight()
|
||||
<< " discard " << image->getDiscardLevel()
|
||||
<< " desired " << image->getDesiredDiscardLevel()
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
<< " close to camera " << (image->getCloseToCamera() > 0.0f ? "Y" : "N") // Display the close to camera flag
|
||||
<< " FFType " << fttype_to_string(image->getFTType()) // Display the FFType of the camera
|
||||
<< " Type " << (S32)image->getType() // Display the type of the image (LOCAL_TEXTURE = 0, MEDIA_TEXTURE = 1, DYNAMIC_TEXTURE = 2, FETCHED_TEXTURE = 3,LOD_TEXTURE = 4)
|
||||
<< " Sculpted " << (image->forSculpt() ? "Y" : "N")
|
||||
<< " # of Faces ";
|
||||
for (S32 index = 0; index < LLRender::NUM_TEXTURE_CHANNELS; index++)
|
||||
{
|
||||
LL_CONT << image->getNumFaces(index) << " ";
|
||||
}
|
||||
LL_CONT << " # of Volumes ";
|
||||
for (S32 index = 0; index < LLRender::NUM_VOLUME_TEXTURE_CHANNELS; index++)
|
||||
{
|
||||
LL_CONT << image->getNumVolumes(index) << " ";
|
||||
}
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
LL_CONT << " " << image->getID().asString().substr(0, 7)
|
||||
<< " http://asset.siva.lindenlab.com/" << image->getID() << ".texture"
|
||||
<< LL_ENDL;
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
image_counts[(image->getDiscardLevel() + 1)] += 1; // Need to add +1 to make up for -1 being a possible value
|
||||
S32 x_index = (S32)log2(image->getWidth()); // Convert the width into a 0 based index by taking the Log2 of the size to get the exponent of the size. (1 = 2^0, 2 = 2^1, 4 = 2^2...)
|
||||
S32 y_index = (S32)log2(image->getHeight()); // Convert the height into a 0 based index by taking the Log2 of the size to get the exponent of the size. (1 = 2^0, 2 = 2^1, 4 = 2^2...)
|
||||
size_counts[x_index + y_index * 12] += 1; // Add this texture's dimensions to the size count
|
||||
// Onlyuse the largest size for the texture's discard level(for non-square textures)
|
||||
S32 max_dimension = (y_index > x_index ? y_index : x_index);
|
||||
discard_counts[(image->getDiscardLevel() + 1) + max_dimension * (MAX_DISCARD_LEVEL * 2 + 2)] += 1;
|
||||
boost_counts[image->getBoostLevel() + max_dimension * (LLViewerTexture::BOOST_MAX_LEVEL)] += 1;
|
||||
S32 full_x_index = (S32)log2(image->getFullWidth());
|
||||
S32 full_y_index = (S32)log2(image->getFullHeight());
|
||||
S32 full_max_dimension = (full_y_index > full_x_index ? full_y_index : full_x_index);
|
||||
fullsize_discard_counts[(image->getDiscardLevel() + 1) + full_max_dimension * (MAX_DISCARD_LEVEL * 2 + 2)] += 1;
|
||||
texture_count++;
|
||||
textures_close_to_camera += S32(image->getCloseToCamera());
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
}
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Add overal texture totals
|
||||
LL_INFOS() << "Texture Stats: Textures in Close to Camera " << textures_close_to_camera << " of " << texture_count << " : " << LL_ENDL;
|
||||
|
||||
// Fix for the -1 discard level as well as higher possible discard levels (for 2048+ size textures)
|
||||
for (S32 index = 0; index < MAX_DISCARD_LEVEL * 2 + 2; index++)
|
||||
{
|
||||
LL_INFOS() << " Discard Level: " << (index - 1) << " Number of Textures: " << image_counts[index] << LL_ENDL;
|
||||
}
|
||||
|
||||
// Create a line to break up the header from the content of the table
|
||||
std::string header_break(13 * 8, '-');
|
||||
|
||||
LL_INFOS() << "Size vs Size" << LL_ENDL;
|
||||
LL_INFOS() << header_break << LL_ENDL;
|
||||
// Create a header that for the Sizes
|
||||
LL_INFOS() << std::setw(8) << "Size";
|
||||
for (S32 x = 1; x <= 2048; x <<= 1)
|
||||
{
|
||||
LL_CONT << std::setw(8) << x;
|
||||
}
|
||||
LL_CONT << LL_ENDL;
|
||||
LL_INFOS() << header_break << LL_ENDL;
|
||||
|
||||
// Y Axis is the size of the height of the texture
|
||||
for (S32 y = 0; y < 12; y++)
|
||||
{
|
||||
LL_INFOS() << std::setw(8) << (1 << y);
|
||||
//X Axis is the size of the width of the texture
|
||||
for (S32 x = 0; x < 12; x++)
|
||||
{
|
||||
LL_CONT << std::setw(8) << size_counts[x + y * 12];
|
||||
|
||||
}
|
||||
LL_CONT << LL_ENDL;
|
||||
}
|
||||
LL_INFOS() << LL_ENDL;
|
||||
|
||||
// This is the Discard Level Vs Size counts table
|
||||
LL_INFOS() << "Discard Level Vs Size" << LL_ENDL;
|
||||
LL_INFOS() << header_break << LL_ENDL;
|
||||
LL_INFOS() << std::setw(8) << "Discard";
|
||||
for (S32 x = 0; x < MAX_DISCARD_LEVEL * 2 + 2; x++)
|
||||
{
|
||||
LL_CONT << std::setw(8) << (x - 1);
|
||||
}
|
||||
LL_CONT << LL_ENDL;
|
||||
LL_INFOS() << header_break << LL_ENDL;
|
||||
|
||||
// Y Axis is the current possible max dimension of the textures (X or Y, which ever is larger is used)
|
||||
for (S32 y = 0; y < 12; y++)
|
||||
{
|
||||
LL_INFOS() << std::setw(8) << (1 << y);
|
||||
// X Axis is the discard level starging from -1 up to 10 (2 x MAX_DISCARD_LEVEL + 1 (for negative number) + 1 additional for the fact that the last value actuauly used on not < but <=)
|
||||
for (S32 x = 0; x < (MAX_DISCARD_LEVEL * 2 + 2); x++)
|
||||
{
|
||||
LL_CONT << std::setw(8) << discard_counts[x + y * (MAX_DISCARD_LEVEL * 2 + 2)];
|
||||
}
|
||||
LL_CONT << LL_ENDL;
|
||||
}
|
||||
LL_INFOS() << LL_ENDL;
|
||||
|
||||
|
||||
// This is the Discard Level Vs Full Size counts table
|
||||
LL_INFOS() << "Discard Level Vs Full Size" << LL_ENDL;
|
||||
LL_INFOS() << header_break << LL_ENDL;
|
||||
LL_INFOS() << std::setw(8) << "Discard";
|
||||
for (S32 x = 0; x < MAX_DISCARD_LEVEL * 2 + 2; x++)
|
||||
{
|
||||
LL_CONT << std::setw(8) << (x - 1);
|
||||
}
|
||||
LL_CONT << LL_ENDL;
|
||||
LL_INFOS() << header_break << LL_ENDL;
|
||||
|
||||
// Y Axis is the current possible max dimension of the textures (X or Y, which ever is larger is used)
|
||||
for (S32 y = 0; y < 12; y++)
|
||||
{
|
||||
LL_INFOS() << std::setw(8) << (1 << y);
|
||||
// X Axis is the discard level starging from -1 up to 10 (2 x MAX_DISCARD_LEVEL + 1 (for negative number) + 1 additional for the fact that the last value actuauly used on not < but <=)
|
||||
for (S32 x = 0; x < (MAX_DISCARD_LEVEL * 2 + 2); x++)
|
||||
{
|
||||
LL_CONT << std::setw(8) << fullsize_discard_counts[x + y * (MAX_DISCARD_LEVEL * 2 + 2)];
|
||||
}
|
||||
LL_CONT << LL_ENDL;
|
||||
}
|
||||
LL_INFOS() << LL_ENDL;
|
||||
|
||||
|
||||
// This is the Boost Level Vs Size counts table
|
||||
LL_INFOS() << "Boost Level Vs Size" << LL_ENDL;
|
||||
header_break.append((LLViewerTexture::BOOST_MAX_LEVEL * 8) - (12 * 8), '-');
|
||||
LL_INFOS() << header_break << LL_ENDL;
|
||||
LL_INFOS() << std::setw(8) << "Discard";
|
||||
for (S32 x = 0; x < LLViewerTexture::BOOST_MAX_LEVEL; x++)
|
||||
{
|
||||
LL_CONT << std::setw(8) << x;
|
||||
}
|
||||
LL_CONT << LL_ENDL;
|
||||
LL_INFOS() << header_break << LL_ENDL;
|
||||
|
||||
// Y Axis is the current possible max dimension of the textures (X or Y, which ever is larger is used)
|
||||
for (S32 y = 0; y < 12; y++)
|
||||
{
|
||||
LL_INFOS() << std::setw(8) << (1 << y);
|
||||
// X Axis is the boost level starging from BOOST_NONE up to BOOST_MAX_LEVEL
|
||||
for (S32 x = 0; x < (LLViewerTexture::BOOST_MAX_LEVEL); x++)
|
||||
{
|
||||
LL_CONT << std::setw(8) << boost_counts[x + y * (LLViewerTexture::BOOST_MAX_LEVEL)];
|
||||
}
|
||||
LL_CONT << LL_ENDL;
|
||||
}
|
||||
LL_INFOS() << LL_ENDL;
|
||||
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
}
|
||||
|
||||
void LLViewerTextureList::destroyGL()
|
||||
|
|
@ -808,14 +644,6 @@ LLViewerFetchedTexture* LLViewerTextureList::createImage(const LLUUID &image_id,
|
|||
imagep->setExplicitFormat(internal_format, primary_format);
|
||||
}
|
||||
|
||||
// <FS:minerjr> [FIRE-35428] - Mega prim issue - fix compressed sculpted textures
|
||||
// Sculpted textures use the RGBA data for coodinates, so any compression can cause artifacts.
|
||||
if (boost_priority == LLViewerFetchedTexture::BOOST_SCULPTED)
|
||||
{
|
||||
// Disable the compression of BOOST_SCULPTED textures
|
||||
if (imagep->getGLTexture())imagep->getGLTexture()->setAllowCompression(false);
|
||||
}
|
||||
// </FS:minerjr> [FIRE-35428]
|
||||
addImage(imagep, get_element_type(boost_priority));
|
||||
|
||||
if (boost_priority != 0)
|
||||
|
|
@ -843,11 +671,7 @@ LLViewerFetchedTexture* LLViewerTextureList::createImage(const LLUUID &image_id,
|
|||
}
|
||||
|
||||
// <FS:Ansariel> Keep Fast Cache option
|
||||
// <FS:minerjr> [FIRE-35428] - Mega prim issue - fix compressed sculpted textures
|
||||
//if(fast_cache_fetching_enabled)
|
||||
// If the texture is Sculpted, don't allow it to be added to fast cache as it can affect the texture.
|
||||
if(fast_cache_fetching_enabled && boost_priority != LLViewerFetchedTexture::BOOST_SCULPTED)
|
||||
// </FS:minerjr> [FIRE-35428]
|
||||
if (fast_cache_fetching_enabled)
|
||||
{
|
||||
mFastCacheList.insert(imagep);
|
||||
imagep->setInFastCacheList(true);
|
||||
|
|
@ -1108,38 +932,8 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
|
|||
F32 bias = llclamp(max_discard - 2.f, 1.f, LLViewerTexture::sDesiredDiscardBias);
|
||||
|
||||
// convert bias into a vsize scaler
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//bias = (F32) llroundf(powf(4, bias - 1.f));
|
||||
// Pre-divide the bias so you can just use multiply in the loop
|
||||
bias = (F32) 1.0f / llroundf(powf(4, bias - 1.f));
|
||||
bias = (F32) llroundf(powf(4, bias - 1.f));
|
||||
|
||||
// Apply new rules to bias discard, there are now 2 bias, off-screen and on-screen.
|
||||
// On-screen Bias
|
||||
// Only applied to LOD Textures and one that have Discard > 1 (0, 1 protected)
|
||||
//
|
||||
// Off-screen Bias
|
||||
// Will be using the old method of applying the mMaxVirtualSize, however
|
||||
// only on LOD textures and fetched textures get bias applied.
|
||||
//
|
||||
// Local (UI & Icons), Media and Dynamic textures should not have any discard applied to them.
|
||||
//
|
||||
// Without this, textures will become blurry that are on screen, which is one of the #1
|
||||
// user complaints.
|
||||
|
||||
// Store a seperate max on screen vsize without bias applied.
|
||||
F32 max_on_screen_vsize = 0.0f;
|
||||
S32 on_screen_count = 0;
|
||||
// Moved all the variables outside of the loop
|
||||
bool current_on_screen = false;
|
||||
F32 vsize = 0.0f; // Moved outside the loop to save reallocation every loop
|
||||
F32 important_to_camera = 0.0f;
|
||||
F32 close_to_camera = 0.0f; // Track if the texture is close to the cameras
|
||||
F64 animated = 0; // U64 used to track if a pointer is set for the animations. (The texture matrix of the face is null if no animation assigned to the texture)
|
||||
// So if you keep adding and the final result is 0, there is no animation
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
// boost resolution of textures that are important to the camera
|
||||
// Can instead of using max for a min of 1.0, just subtract 1 from the boost and just do a 1 + (TextureCameraBoost - 1) * importanceToCamera)
|
||||
static LLCachedControl<F32> texture_camera_boost(gSavedSettings, "TextureCameraBoost", 7.f);
|
||||
LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
|
||||
for (U32 i = 0; i < LLRender::NUM_TEXTURE_CHANNELS; ++i)
|
||||
{
|
||||
|
|
@ -1152,42 +946,21 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
|
|||
|
||||
if (face && face->getViewerObject())
|
||||
{
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// No longer needed as we no longer re-calculate the face's virtual texture size, we use it directly from the face
|
||||
//F32 radius;
|
||||
//F32 cos_angle_to_view_dir;
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
F32 radius;
|
||||
F32 cos_angle_to_view_dir;
|
||||
|
||||
if ((gFrameCount - face->mLastTextureUpdate) > 10)
|
||||
{ // only call calcPixelArea at most once every 10 frames for a given face
|
||||
// this helps eliminate redundant calls to calcPixelArea for faces that have multiple textures
|
||||
// assigned to them, such as is the case with GLTF materials or Blinn-Phong materials
|
||||
|
||||
//face->calcPixelArea(cos_angle_to_view_dir, radius);
|
||||
// The face already has a function to calculate the Texture Virtual Size, which already calls the calcPixelArea method
|
||||
// so just call this instead. This can be called from outside this loop by LLVolume objects
|
||||
face->getTextureVirtualSize();
|
||||
face->mInFrustum = face->calcPixelArea(cos_angle_to_view_dir, radius);
|
||||
face->mLastTextureUpdate = gFrameCount;
|
||||
}
|
||||
|
||||
// Also moved allocation outside the loop
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//F32 vsize = face->getPixelArea();
|
||||
|
||||
//on_screen |= face->mInFrustum;
|
||||
// Get the already calculated face's virtual size, instead of re-calculating it
|
||||
vsize = face->getVirtualSize();
|
||||
|
||||
current_on_screen = face->mInFrustum; // Create a new var to store the current on screen status
|
||||
on_screen_count += current_on_screen; // Count the number of on sceen faces instead of using brach
|
||||
important_to_camera = face->mImportanceToCamera; // Store so we don't have to do 2 indirects later on
|
||||
// If the face/texture is animated, then set the boost level to high, so that it will ways be the best quality
|
||||
animated += S64(face->mTextureMatrix);
|
||||
animated += S64(face->hasMedia()); // Add has media for both local and parcel media
|
||||
animated += S64(imagep->hasParcelMedia());
|
||||
F32 vsize = face->getPixelArea();
|
||||
|
||||
on_screen |= face->mInFrustum;
|
||||
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings (It is)
|
||||
/*
|
||||
// Scale desired texture resolution higher or lower depending on texture scale
|
||||
//
|
||||
// Minimum usage examples: a 1024x1024 texture with aplhabet (texture atlas),
|
||||
|
|
@ -1196,7 +969,6 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
|
|||
//
|
||||
// Maximum usage examples: huge chunk of terrain repeats texture
|
||||
// TODO: make this work with the GLTF texture transforms
|
||||
|
||||
S32 te_offset = face->getTEOffset(); // offset is -1 if not inited
|
||||
LLViewerObject* objp = face->getViewerObject();
|
||||
const LLTextureEntry* te = (te_offset < 0 || te_offset >= objp->getNumTEs()) ? nullptr : objp->getTE(te_offset);
|
||||
|
|
@ -1226,46 +998,17 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
|
|||
{
|
||||
break;
|
||||
}
|
||||
*/
|
||||
|
||||
// Use math to skip having to use a conditaional check
|
||||
// Bools are stored as 0 false, 1 true, use to cheat
|
||||
// Lerp instead of doing conditional input
|
||||
// If the image is import to the camera, even a little then make the on screen true
|
||||
on_screen_count += S32(important_to_camera * 1000.0f);
|
||||
//vsize = vsize + (vsize * (1.0f + important_to_camera * texture_camera_boost) - vsize) * F32(current_on_screen);
|
||||
// Apply boost of size based upon importance to camera
|
||||
vsize = vsize + (vsize * important_to_camera * texture_camera_boost);
|
||||
// Apply second boost based upon if the texture is close to the camera (< 16.1 meters * draw distance multiplier)
|
||||
vsize = vsize + (vsize * face->mCloseToCamera * texture_camera_boost);
|
||||
// Update the max on screen vsize based upon the on screen vsize
|
||||
close_to_camera += face->mCloseToCamera;
|
||||
// LL_DEBUGS() << face->getViewerObject()->getID() << " TID " << imagep->getID() << " #F " << imagep->getNumFaces(i) << " OS Vsize: " << vsize << " Vsize: " << (vsize * bias) << " CTC: " << face->mCloseToCamera << " Channel " << i << " Face Index " << fi << LL_ENDL;
|
||||
max_on_screen_vsize = llmax(max_on_screen_vsize, vsize);
|
||||
max_vsize = llmax(max_vsize, vsize * bias);
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
}
|
||||
}
|
||||
|
||||
// <FS> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//if (max_vsize >= LLViewerFetchedTexture::sMaxVirtualSize
|
||||
// && (on_screen || LLViewerTexture::sDesiredDiscardBias <= BIAS_TRS_ON_SCREEN))
|
||||
//{
|
||||
// break;
|
||||
//}
|
||||
// </FS>
|
||||
if (max_vsize >= LLViewerFetchedTexture::sMaxVirtualSize
|
||||
&& (on_screen || LLViewerTexture::sDesiredDiscardBias <= BIAS_TRS_ON_SCREEN))
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Replaced all the checks for this bool to be only in this 1 place instead of in the loop.
|
||||
// If the on screen counter is greater then 0, then there was at least 1 on screen texture
|
||||
on_screen = bool(on_screen_count);
|
||||
imagep->setCloseToCamera(close_to_camera > 0.0f ? 1.0f : 0.0f);
|
||||
|
||||
//if (face_count > max_faces_to_check)
|
||||
// Add check for if the image is animated to boost to high as well
|
||||
if (face_count > max_faces_to_check || animated != 0)
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
if (face_count > max_faces_to_check)
|
||||
{ // this texture is used in so many places we should just boost it and not bother checking its vsize
|
||||
// this is especially important because the above is not time sliced and can hit multiple ms for a single texture
|
||||
max_vsize = MAX_IMAGE_AREA;
|
||||
|
|
@ -1283,33 +1026,7 @@ void LLViewerTextureList::updateImageDecodePriority(LLViewerFetchedTexture* imag
|
|||
}
|
||||
}
|
||||
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//imagep->addTextureStats(max_vsize);
|
||||
// New logic block for the bias system
|
||||
// Then depending on the type of texture, the higher resolution on_screen_max_vsize is applied.
|
||||
// On Screen (Without Bias applied:
|
||||
// LOD/Fetch Texture: Discard Levels 0, 1
|
||||
// Fetch Texture 2, 3, 5 with bias < 2.0
|
||||
// BoostLevel = Boost_High
|
||||
// Local, Media, Dynamic Texture
|
||||
// If the textures are on screen and either 1 are the first 2 levels of discard and are either fetched or LOD textures
|
||||
if (on_screen && ((imagep->getDiscardLevel() < 2 && imagep->getType() >= LLViewerTexture::FETCHED_TEXTURE) || (imagep->getType() == LLViewerTexture::FETCHED_TEXTURE && LLViewerTexture::sDesiredDiscardBias < 2.0f)))
|
||||
{
|
||||
// Always use the best quality of the texture
|
||||
imagep->addTextureStats(max_on_screen_vsize);
|
||||
}
|
||||
// If the boost level just became high, or the texture is (Local, Media Dynamic)
|
||||
else if (imagep->getBoostLevel() >= LLViewerTexture::BOOST_HIGH || imagep->getType() < LLViewerTexture::FETCHED_TEXTURE || close_to_camera)
|
||||
{
|
||||
// Always use the best quality of the texture
|
||||
imagep->addTextureStats(max_on_screen_vsize);
|
||||
}
|
||||
// All other texture cases will use max_vsize with bias applied.
|
||||
else
|
||||
{
|
||||
imagep->addTextureStats(max_vsize);
|
||||
}
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
imagep->addTextureStats(max_vsize);
|
||||
}
|
||||
|
||||
#if 0
|
||||
|
|
@ -1410,11 +1127,7 @@ F32 LLViewerTextureList::updateImagesCreateTextures(F32 max_time)
|
|||
mCreateTextureList.pop();
|
||||
|
||||
if (imagep->hasGLTexture() && imagep->getDiscardLevel() < imagep->getDesiredDiscardLevel() &&
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//(imagep->getDesiredDiscardLevel() <= MAX_DISCARD_LEVEL))
|
||||
// Add additional restrictions on scaling down (only BOOST_NONE LOD Textures (Also skip media)
|
||||
(imagep->getDesiredDiscardLevel() <= MAX_DISCARD_LEVEL) && imagep->getBoostLevel() == LLViewerTexture::BOOST_NONE && imagep->getType() == LLViewerTexture::LOD_TEXTURE && !imagep->hasParcelMedia() && !imagep->isViewerMediaTexture())
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
(imagep->getDesiredDiscardLevel() <= MAX_DISCARD_LEVEL))
|
||||
{
|
||||
// NOTE: this may happen if the desired discard reduces while a decode is in progress and does not
|
||||
// necessarily indicate a problem, but if log occurrences excede that of dsiplay_stats: FPS,
|
||||
|
|
@ -1423,7 +1136,7 @@ F32 LLViewerTextureList::updateImagesCreateTextures(F32 max_time)
|
|||
imagep->scaleDown();
|
||||
}
|
||||
|
||||
if (create_timer.getElapsedTimeF32() > max_time * 0.5f)
|
||||
if (create_timer.getElapsedTimeF32() > max_time)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
|
@ -1447,7 +1160,7 @@ F32 LLViewerTextureList::updateImagesCreateTextures(F32 max_time)
|
|||
// freeze.
|
||||
S32 min_count = (S32)mCreateTextureList.size() / 20 + 5;
|
||||
|
||||
//create_timer.reset();
|
||||
create_timer.reset();
|
||||
while (!mDownScaleQueue.empty())
|
||||
{
|
||||
LLViewerFetchedTexture* image = mDownScaleQueue.front();
|
||||
|
|
|
|||
|
|
@ -111,9 +111,6 @@ public:
|
|||
static void receiveImageHeader(LLMessageSystem *msg, void **user_data);
|
||||
static void receiveImagePacket(LLMessageSystem *msg, void **user_data);
|
||||
// </FS:Ansariel>
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
static void dumpTexturelist(); // Added code to handle dumping texture information
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
|
||||
public:
|
||||
LLViewerTextureList();
|
||||
|
|
|
|||
|
|
@ -2987,19 +2987,12 @@ LLViewerFetchedTexture *LLVOAvatar::getBakedTextureImage(const U8 te, const LLUU
|
|||
LL_DEBUGS("Avatar") << avString() << "get old-bake image from host " << uuid << LL_ENDL;
|
||||
LLHost host = getObjectHost();
|
||||
result = LLViewerTextureManager::getFetchedTexture(
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//uuid, FTT_HOST_BAKE, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE, 0, 0, host);
|
||||
uuid, FTT_HOST_BAKE, true, LLGLTexture::BOOST_AVATAR_BAKED, LLViewerTexture::LOD_TEXTURE, 0, 0, host);
|
||||
// <FS:minerjr> [FIRE-35081]
|
||||
uuid, FTT_HOST_BAKE, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE, 0, 0, host);
|
||||
// </FS:Ansariel> [Legacy Bake]
|
||||
}
|
||||
LL_DEBUGS("Avatar") << avString() << "get server-bake image from URL " << url << LL_ENDL;
|
||||
result = LLViewerTextureManager::getFetchedTextureFromUrl(
|
||||
// <FS:minerjr>
|
||||
//url, FTT_SERVER_BAKE, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE, 0, 0, uuid);
|
||||
// Change the texture from LOD to AVATAR_BAKED.
|
||||
url, FTT_SERVER_BAKE, true, LLGLTexture::BOOST_AVATAR_BAKED, LLViewerTexture::LOD_TEXTURE, 0, 0, uuid);
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
url, FTT_SERVER_BAKE, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE, 0, 0, uuid);
|
||||
if (result->isMissingAsset())
|
||||
{
|
||||
result->setIsMissingAsset(false);
|
||||
|
|
@ -11029,11 +11022,7 @@ void LLVOAvatar::applyParsedAppearanceMessage(LLAppearanceMessageContents& conte
|
|||
//LL_DEBUGS("Avatar") << avString() << " baked_index " << (S32) baked_index << " using mLastTextureID " << mBakedTextureDatas[baked_index].mLastTextureID << LL_ENDL;
|
||||
LL_DEBUGS("Avatar") << avString() << "sb " << (S32) isUsingServerBakes() << " baked_index " << (S32) baked_index << " using mLastTextureID " << mBakedTextureDatas[baked_index].mLastTextureID << LL_ENDL;
|
||||
setTEImage(mBakedTextureDatas[baked_index].mTextureIndex,
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//LLViewerTextureManager::getFetchedTexture(mBakedTextureDatas[baked_index].mLastTextureID, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE));
|
||||
//Texture will use baked textures, so it should also use that for the boost.
|
||||
LLViewerTextureManager::getFetchedTexture(mBakedTextureDatas[baked_index].mLastTextureID, FTT_DEFAULT, true, LLGLTexture::BOOST_AVATAR_BAKED, LLViewerTexture::LOD_TEXTURE));
|
||||
// <FS:minerjr> [FIRE-35081]
|
||||
LLViewerTextureManager::getFetchedTexture(mBakedTextureDatas[baked_index].mLastTextureID, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE));
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
|
|||
|
|
@ -99,11 +99,7 @@ void LLVOGrass::updateSpecies()
|
|||
SpeciesMap::const_iterator it = sSpeciesTable.begin();
|
||||
mSpecies = (*it).first;
|
||||
}
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//setTEImage(0, LLViewerTextureManager::getFetchedTexture(sSpeciesTable[mSpecies]->mTextureID, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE));
|
||||
// Added new boost Grass as it forces a fixed size on updates
|
||||
setTEImage(0, LLViewerTextureManager::getFetchedTexture(sSpeciesTable[mSpecies]->mTextureID, FTT_DEFAULT, true, LLGLTexture::BOOST_GRASS, LLViewerTexture::LOD_TEXTURE));
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
setTEImage(0, LLViewerTextureManager::getFetchedTexture(sSpeciesTable[mSpecies]->mTextureID, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE));
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -330,11 +330,7 @@ U32 LLVOTree::processUpdateMessage(LLMessageSystem *mesgsys,
|
|||
// Load Species-Specific data
|
||||
//
|
||||
static const S32 MAX_TREE_TEXTURE_VIRTURE_SIZE_RESET_INTERVAL = 32 ; //frames.
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//mTreeImagep = LLViewerTextureManager::getFetchedTexture(sSpeciesTable[mSpecies]->mTextureID, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
|
||||
// Set boost level for Tree as it overrides the normal texture sizes
|
||||
mTreeImagep = LLViewerTextureManager::getFetchedTexture(sSpeciesTable[mSpecies]->mTextureID, FTT_DEFAULT, true, LLGLTexture::BOOST_TREE, LLViewerTexture::LOD_TEXTURE);
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
mTreeImagep = LLViewerTextureManager::getFetchedTexture(sSpeciesTable[mSpecies]->mTextureID, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
|
||||
mTreeImagep->setMaxVirtualSizeResetInterval(MAX_TREE_TEXTURE_VIRTURE_SIZE_RESET_INTERVAL); //allow to wait for at most 16 frames to reset virtual size.
|
||||
|
||||
mBranchLength = sSpeciesTable[mSpecies]->mBranchLength;
|
||||
|
|
|
|||
|
|
@ -742,10 +742,7 @@ void LLVOVolume::animateTextures()
|
|||
{
|
||||
LLFace* facep = mDrawable->getFace(i);
|
||||
if (!facep) continue;
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Removed check for turning off animations
|
||||
//if(facep->getVirtualSize() <= MIN_TEX_ANIM_SIZE && facep->mTextureMatrix) continue;
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
if(facep->getVirtualSize() <= MIN_TEX_ANIM_SIZE && facep->mTextureMatrix) continue;
|
||||
|
||||
const LLTextureEntry* te = facep->getTextureEntry();
|
||||
|
||||
|
|
@ -770,10 +767,7 @@ void LLVOVolume::animateTextures()
|
|||
if (!facep->mTextureMatrix)
|
||||
{
|
||||
facep->mTextureMatrix = new LLMatrix4();
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Removed check for turning off animations
|
||||
//if (facep->getVirtualSize() > MIN_TEX_ANIM_SIZE)
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
if (facep->getVirtualSize() > MIN_TEX_ANIM_SIZE)
|
||||
{
|
||||
// Fix the one edge case missed in
|
||||
// LLVOVolume::updateTextureVirtualSize when the
|
||||
|
|
@ -926,10 +920,6 @@ void LLVOVolume::updateTextureVirtualSize(bool forced)
|
|||
F32 min_vsize=999999999.f, max_vsize=0.f;
|
||||
LLViewerCamera* camera = LLViewerCamera::getInstance();
|
||||
std::stringstream debug_text;
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Use this flag to indicate that there was a legit change to 0.0 for the mPixelArea (All faces off screen)
|
||||
bool changed = false;
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
for (S32 i = 0; i < num_faces; i++)
|
||||
{
|
||||
LLFace* face = mDrawable->getFace(i);
|
||||
|
|
@ -978,13 +968,6 @@ void LLVOVolume::updateTextureVirtualSize(bool forced)
|
|||
|
||||
mPixelArea = llmax(mPixelArea, face->getPixelArea());
|
||||
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// If the new area is changed from the old area, then accept it.
|
||||
if (mPixelArea != old_area)
|
||||
{
|
||||
changed = true;
|
||||
}
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
// if the face has gotten small enough to turn off texture animation and texture
|
||||
// animation is running, rebuild the render batch for this face to turn off
|
||||
// texture animation
|
||||
|
|
@ -1068,10 +1051,7 @@ void LLVOVolume::updateTextureVirtualSize(bool forced)
|
|||
{
|
||||
LLLightImageParams* params = (LLLightImageParams*) getParameterEntry(LLNetworkData::PARAMS_LIGHT_IMAGE);
|
||||
LLUUID id = params->getLightTexture();
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Light textures should be treaded not the same as normal LOD textures
|
||||
mLightTexture = LLViewerTextureManager::getFetchedTexture(id, FTT_DEFAULT, true, LLGLTexture::BOOST_LIGHT);
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
mLightTexture = LLViewerTextureManager::getFetchedTexture(id, FTT_DEFAULT, true, LLGLTexture::BOOST_NONE);
|
||||
if (mLightTexture.notNull())
|
||||
{
|
||||
F32 rad = getLightRadius();
|
||||
|
|
@ -1121,11 +1101,7 @@ void LLVOVolume::updateTextureVirtualSize(bool forced)
|
|||
setDebugText(output);
|
||||
}
|
||||
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
//if (mPixelArea == 0)
|
||||
// If there is a legit change to 0.0, don't dismiss it.
|
||||
if (mPixelArea == 0 && !changed)
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
if (mPixelArea == 0)
|
||||
{ //flexi phasing issues make this happen
|
||||
mPixelArea = old_area;
|
||||
}
|
||||
|
|
@ -5474,10 +5450,7 @@ bool can_batch_texture(LLFace* facep)
|
|||
return false;
|
||||
}
|
||||
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Removed check for turning off animations
|
||||
if (facep->isState(LLFace::TEXTURE_ANIM))//&& facep->getVirtualSize() > MIN_TEX_ANIM_SIZE)
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
if (facep->isState(LLFace::TEXTURE_ANIM) && facep->getVirtualSize() > MIN_TEX_ANIM_SIZE)
|
||||
{ //texture animation breaks batches
|
||||
return false;
|
||||
}
|
||||
|
|
@ -5624,10 +5597,7 @@ void LLVolumeGeometryManager::registerFace(LLSpatialGroup* group, LLFace* facep,
|
|||
}
|
||||
|
||||
const LLMatrix4* tex_mat = NULL;
|
||||
// <FS:minerjr> [FIRE-35081] Blurry prims not changing with graphics settings
|
||||
// Removed check for turning off animations
|
||||
if (facep->isState(LLFace::TEXTURE_ANIM)) //&& facep->getVirtualSize() > MIN_TEX_ANIM_SIZE)
|
||||
// </FS:minerjr> [FIRE-35081]
|
||||
if (facep->isState(LLFace::TEXTURE_ANIM) && facep->getVirtualSize() > MIN_TEX_ANIM_SIZE)
|
||||
{
|
||||
tex_mat = facep->mTextureMatrix;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue