diff options
79 files changed, 4068 insertions, 750 deletions
diff --git a/indra/llcommon/llprofiler.h b/indra/llcommon/llprofiler.h index f6a4d24747..9267c5cbda 100644 --- a/indra/llcommon/llprofiler.h +++ b/indra/llcommon/llprofiler.h @@ -71,7 +71,7 @@ #define LL_PROFILER_CONFIG_TRACY_FAST_TIMER 3 // Profiling on: Fast Timers + Tracy #ifndef LL_PROFILER_CONFIGURATION -#define LL_PROFILER_CONFIGURATION LL_PROFILER_CONFIG_FAST_TIMER +#define LL_PROFILER_CONFIGURATION 0 #endif extern thread_local bool gProfilerEnabled; @@ -155,6 +155,28 @@ extern thread_local bool gProfilerEnabled; #else #define LL_PROFILER_FRAME_END #define LL_PROFILER_SET_THREAD_NAME( name ) (void)(name) + + #define LL_PROFILER_FRAME_END + #define LL_PROFILER_SET_THREAD_NAME( name ) (void)(name) + #define LL_RECORD_BLOCK_TIME(name) + #define LL_PROFILE_ZONE_NAMED(name) // LL_PROFILE_ZONE_NAMED is a no-op when Tracy is disabled + #define LL_PROFILE_ZONE_NAMED_COLOR(name,color) // LL_PROFILE_ZONE_NAMED_COLOR is a no-op when Tracy is disabled + #define LL_PROFILE_ZONE_SCOPED // LL_PROFILE_ZONE_SCOPED is a no-op when Tracy is disabled + #define LL_PROFILE_ZONE_COLOR(name,color) // LL_RECORD_BLOCK_TIME(name) + + #define LL_PROFILE_ZONE_NUM( val ) (void)( val ); // Not supported + #define LL_PROFILE_ZONE_TEXT( text, size ) (void)( text ); void( size ); // Not supported + + #define LL_PROFILE_ZONE_ERR(name) (void)(name); // Not supported + #define LL_PROFILE_ZONE_INFO(name) (void)(name); // Not supported + #define LL_PROFILE_ZONE_WARN(name) (void)(name); // Not supported + + #define LL_PROFILE_MUTEX(type, varname) type varname + #define LL_PROFILE_MUTEX_NAMED(type, varname, desc) type varname + #define LL_PROFILE_MUTEX_SHARED(type, varname) type varname + #define LL_PROFILE_MUTEX_SHARED_NAMED(type, varname, desc) type varname + #define LL_PROFILE_MUTEX_LOCK(varname) // LL_PROFILE_MUTEX_LOCK is a no-op when Tracy is disabled + #endif // LL_PROFILER #if LL_PROFILER_ENABLE_TRACY_OPENGL diff --git a/indra/llrender/llcubemaparray.cpp b/indra/llrender/llcubemaparray.cpp index fb35e002df..e0a8782c33 100644 --- a/indra/llrender/llcubemaparray.cpp +++ b/indra/llrender/llcubemaparray.cpp @@ -114,6 +114,8 @@ LLCubeMapArray::LLCubeMapArray(LLCubeMapArray& lhs, U32 width, U32 count) : mTex allocate(mWidth, lhs.mImage->getComponents(), count, lhs.mImage->getUseMipMaps(), lhs.mHDR); // Copy each cubemap from the incoming array to the new array + // The call to glTexSubImage3D causes an INVALID OPERATION OpenGL error. For now we comment this.. + /* U32 min_count = std::min(count, lhs.mCount); for (U32 i = 0; i < min_count * 6; ++i) { @@ -133,6 +135,7 @@ LLCubeMapArray::LLCubeMapArray(LLCubeMapArray& lhs, U32 width, U32 count) : mTex glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0, i, mWidth, mWidth, 1, components, GL_UNSIGNED_BYTE, scaled_image->getData()); } } + */ } LLCubeMapArray::~LLCubeMapArray() diff --git a/indra/llrender/llgl.cpp b/indra/llrender/llgl.cpp index ac66faaf5a..cc619e2086 100644 --- a/indra/llrender/llgl.cpp +++ b/indra/llrender/llgl.cpp @@ -2279,26 +2279,28 @@ void rotate_quat(LLQuaternion& rotation) void flush_glerror() { + if(!gDebugGL) return; glGetError(); } -//this function outputs gl error to the log file, does not crash the code. -void log_glerror() +void log_glerror(std::string comment) { + if(!gDebugGL) return; + if (LL_UNLIKELY(!gGLManager.mInited)) { return ; } - // Create or update texture to be used with this data + GLenum error; error = glGetError(); - while (LL_UNLIKELY(error)) + if (error != GL_NO_ERROR) { #if GLU_VERSION_1_1 GLubyte const * gl_error_msg = gluErrorString(error); if (NULL != gl_error_msg) { - LL_WARNS() << "GL Error: " << error << " GL Error String: " << gl_error_msg << LL_ENDL ; + LL_WARNS() << "GL Error (" << comment << ")" << error << ": " << gl_error_msg << LL_ENDL; } else #endif // GLU_VERSION_1_1 @@ -2307,7 +2309,6 @@ void log_glerror() // you'll probably have to grep for the number in glext.h. LL_WARNS() << "GL Error: UNKNOWN 0x" << std::hex << error << std::dec << LL_ENDL; } - error = glGetError(); } } @@ -2385,6 +2386,7 @@ void assert_glerror() void clear_glerror() { + if(!gDebugGL) return; glGetError(); glGetError(); } diff --git a/indra/llrender/llgl.h b/indra/llrender/llgl.h index bf8368a7b3..130b06f9df 100644 --- a/indra/llrender/llgl.h +++ b/indra/llrender/llgl.h @@ -154,17 +154,20 @@ void rotate_quat(LLQuaternion& rotation); void flush_glerror(); // Flush GL errors when we know we're handling them correctly. -void log_glerror(); +void log_glerror(std::string comment); void assert_glerror(); void clear_glerror(); -#if !LL_RELEASE_FOR_DOWNLOAD -# define stop_glerror() assert_glerror() -# define llglassertok() assert_glerror() -# define STOP_GLERROR stop_glerror() +//#if !LL_RELEASE_FOR_DOWNLOAD +#if 1 +# define LOG_GLERROR(COMMENT) log_glerror(COMMENT) +# define stop_glerror() log_glerror("stop") +# define llglassertok() log_glerror("ASSERTOK") +# define STOP_GLERROR log_glerror("STOP") #else +# define LOG_GLERROR(COMMENT) # define stop_glerror() # define llglassertok() # define STOP_GLERROR diff --git a/indra/llrender/llimagegl.cpp b/indra/llrender/llimagegl.cpp index 558c3b062a..42af68c276 100644 --- a/indra/llrender/llimagegl.cpp +++ b/indra/llrender/llimagegl.cpp @@ -358,6 +358,7 @@ S32 LLImageGL::dataFormatBits(S32 dataformat) #endif case GL_DEPTH_COMPONENT: return 24; case GL_DEPTH_COMPONENT24: return 24; + case GL_RGBA16: return 64; case GL_R16F: return 16; case GL_RG16F: return 32; case GL_RGB16F: return 48; @@ -1290,7 +1291,7 @@ bool LLImageGL::setSubImageFromFrameBuffer(S32 fb_x, S32 fb_y, S32 x_pos, S32 y_ { glCopyTexSubImage2D(GL_TEXTURE_2D, 0, fb_x, fb_y, x_pos, y_pos, width, height); mGLTextureCreated = true; - stop_glerror(); + LOG_GLERROR("LLImageGL::setSubImageFromFrameBuffer()"); return true; } else @@ -2583,6 +2584,8 @@ bool LLImageGL::scaleDown(S32 desired_discard) return false; } + //LL_WARNS() << "scaleDown" << LL_ENDL; + S32 mip = desired_discard - mCurrentDiscardLevel; S32 desired_width = getWidth(desired_discard); @@ -2600,6 +2603,7 @@ bool LLImageGL::scaleDown(S32 desired_discard) free_tex_image(mTexName); glTexImage2D(mTarget, 0, mFormatInternal, desired_width, desired_height, 0, mFormatPrimary, mFormatType, nullptr); glCopyTexSubImage2D(mTarget, 0, 0, 0, 0, 0, desired_width, desired_height); + LOG_GLERROR("LLImageGL::scaleDown() - glCopyTexSubImage2D"); alloc_tex_image(desired_width, desired_height, mFormatInternal, 1); mTexOptionsDirty = true; @@ -2609,6 +2613,7 @@ bool LLImageGL::scaleDown(S32 desired_discard) LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("scaleDown - glGenerateMipmap"); gGL.getTexUnit(0)->bind(this); glGenerateMipmap(mTarget); + LOG_GLERROR("LLImageGL::scaleDown() - glGenerateMipmap"); gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); } } diff --git a/indra/llrender/llrender.cpp b/indra/llrender/llrender.cpp index cbb178b6f8..70993393ff 100644 --- a/indra/llrender/llrender.cpp +++ b/indra/llrender/llrender.cpp @@ -203,6 +203,7 @@ void LLTexUnit::bindFast(LLTexture* texture) glActiveTexture(GL_TEXTURE0 + mIndex); gGL.mCurrTextureUnitIndex = mIndex; mCurrTexture = gl_tex->getTexName(); + mCurrTexType = gl_tex->getTarget(); if (!mCurrTexture) { LL_PROFILE_ZONE_NAMED("MISSING TEXTURE"); @@ -479,41 +480,49 @@ void LLTexUnit::setTextureFilteringOption(LLTexUnit::eTextureFilterOptions optio { if (mIndex < 0 || mCurrTexture == 0 || mCurrTexType == LLTexUnit::TT_MULTISAMPLE_TEXTURE) return; + GLenum target = sGLTextureType[mCurrTexType]; + + if (mCurrTexType == LLTexUnit::TT_NONE) + { + LL_WARNS() << "setTextureFilteringOption() Error: mCurrTexType==TT_NONE texture: " << mCurrTexture << LL_ENDL; + gGL.debugTexUnits(); + } + gGL.flush(); if (option == TFO_POINT) { - glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); } else { - glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } if (option >= TFO_TRILINEAR && mHasMipMaps) { - glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); } else if (option >= TFO_BILINEAR) { if (mHasMipMaps) { - glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); + glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); } else { - glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); } } else { if (mHasMipMaps) { - glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); + glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); } else { - glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); } } @@ -521,11 +530,11 @@ void LLTexUnit::setTextureFilteringOption(LLTexUnit::eTextureFilterOptions optio { if (LLImageGL::sGlobalUseAnisotropic && option == TFO_ANISOTROPIC) { - glTexParameterf(sGLTextureType[mCurrTexType], GL_TEXTURE_MAX_ANISOTROPY_EXT, gGLManager.mMaxAnisotropy); + glTexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, gGLManager.mMaxAnisotropy); } else { - glTexParameterf(sGLTextureType[mCurrTexType], GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.f); + glTexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.f); } } } @@ -908,13 +917,12 @@ bool LLRender::init(bool needs_vertex_buffer) void LLRender::initVertexBuffer() { llassert_always(mBuffer.isNull()); - stop_glerror(); mBuffer = new LLVertexBuffer(immediate_mask); - mBuffer->allocateBuffer(4096, 0); + mBuffer->allocateBuffer(16384, 0); mBuffer->getVertexStrider(mVerticesp); mBuffer->getTexCoord0Strider(mTexcoordsp); mBuffer->getColorStrider(mColorsp); - stop_glerror(); + LOG_GLERROR("LLRender::initVertexBuffer()"); } void LLRender::resetVertexBuffer() @@ -1000,7 +1008,6 @@ void LLRender::syncLightState() void LLRender::syncMatrices() { - STOP_GLERROR; LL_PROFILE_ZONE_SCOPED_CATEGORY_DISPLAY; static const U32 name[] = @@ -1145,7 +1152,7 @@ void LLRender::syncMatrices() syncLightState(); } } - STOP_GLERROR; + LOG_GLERROR("LLRender::syncMatrices()"); } void LLRender::translatef(const GLfloat& x, const GLfloat& y, const GLfloat& z) @@ -1555,7 +1562,7 @@ void LLRender::begin(const GLuint& mode) mMode == LLRender::TRIANGLES || mMode == LLRender::POINTS) { - flush(); + flush("LLRender::begin"); } else if (mCount != 0) { @@ -1566,7 +1573,7 @@ void LLRender::begin(const GLuint& mode) } } -void LLRender::end() +void LLRender::end(std::string comment_) { if (mCount == 0) { @@ -1579,13 +1586,13 @@ void LLRender::end() mMode != LLRender::POINTS) || mCount > 2048) { - flush(); + flush("from end " + comment_); } } -void LLRender::flush() +void LLRender::flush(std::string comment_) { - STOP_GLERROR; + LOG_GLERROR("LLRender::flush() begin " + comment_); if (mCount > 0) { LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE; @@ -1655,6 +1662,13 @@ void LLRender::flush() resetStriders(count); } + + LOG_GLERROR("LLRender::flush() end " + comment_); +} + +void LLRender::flush() +{ + flush(""); } LLVertexBuffer* LLRender::bufferfromCache(U32 attribute_mask, U32 count) @@ -2026,7 +2040,8 @@ void LLRender::debugTexUnits(void) std::string active_enabled = "false"; for (U32 i = 0; i < mTexUnits.size(); i++) { - if (getTexUnit(i)->mCurrTexType != LLTexUnit::TT_NONE) + //if (getTexUnit(i)->mCurrTexType != LLTexUnit::TT_NONE) + if(1) { if (i == mCurrTextureUnitIndex) active_enabled = "true"; LL_INFOS("TextureUnit") << "TexUnit: " << i << " Enabled" << LL_ENDL; @@ -2044,8 +2059,19 @@ void LLRender::debugTexUnits(void) case LLTexUnit::TT_CUBE_MAP: LL_CONT << "Cube Map"; break; + case LLTexUnit::TT_CUBE_MAP_ARRAY: + LL_CONT << "Cube Map Array"; + break; + + case LLTexUnit::TT_MULTISAMPLE_TEXTURE: + LL_CONT << "Multisample Texture"; + break; + + case LLTexUnit::TT_TEXTURE_3D: + LL_CONT << "Texture 3D"; + break; default: - LL_CONT << "ARGH!!! NONE!"; + LL_CONT << "ARGH!!! NONE! -> type = " << getTexUnit(i)->mCurrTexType; break; } LL_CONT << ", Texture Bound: " << getTexUnit(i)->mCurrTexture << LL_ENDL; diff --git a/indra/llrender/llrender.h b/indra/llrender/llrender.h index 97c47bcae9..a755ddd2b1 100644 --- a/indra/llrender/llrender.h +++ b/indra/llrender/llrender.h @@ -421,6 +421,7 @@ public: LLVector3 getUITranslation(); LLVector3 getUIScale(); + void flush(std::string comment_); void flush(); // if list is set, will store buffers in list for later use, if list isn't set, will use cache @@ -428,7 +429,7 @@ public: void endList(); void begin(const GLuint& mode); - void end(); + void end(std::string comment_ = ""); U8 getMode() const { return mMode; } diff --git a/indra/llrender/llrender2dutils.cpp b/indra/llrender/llrender2dutils.cpp index 9144ce6d62..714df863cd 100644 --- a/indra/llrender/llrender2dutils.cpp +++ b/indra/llrender/llrender2dutils.cpp @@ -833,8 +833,7 @@ void gl_line_3d( const LLVector3& start, const LLVector3& end, const LLColor4& c { gGL.color4f(color.mV[VRED], color.mV[VGREEN], color.mV[VBLUE], color.mV[VALPHA]); - gGL.flush(); - glLineWidth(2.5f); + LLRender2D::setLineWidth(2.5f); gGL.begin(LLRender::LINES); { diff --git a/indra/llrender/llrendertarget.cpp b/indra/llrender/llrendertarget.cpp index 0e4aa2ee7a..ddb2bf5df7 100644 --- a/indra/llrender/llrendertarget.cpp +++ b/indra/llrender/llrendertarget.cpp @@ -158,6 +158,8 @@ void LLRenderTarget::setColorAttachment(LLImageGL* img, LLGLuint use_name) llassert(mTex.empty()); // mTex must be empty with this mode (binding target should be done via LLImageGL) llassert(!isBoundInStack()); + U32 target = getTarget(); + if (mFBO == 0) { glGenFramebuffers(1, (GLuint*)&mFBO); @@ -174,14 +176,14 @@ void LLRenderTarget::setColorAttachment(LLImageGL* img, LLGLuint use_name) mTex.push_back(use_name); - glBindFramebuffer(GL_FRAMEBUFFER, mFBO); - glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, + glBindFramebuffer(target, mFBO); + glFramebufferTexture2D(target, GL_COLOR_ATTACHMENT0, LLTexUnit::getInternalType(mUsage), use_name, 0); stop_glerror(); check_framebuffer_status(); - glBindFramebuffer(GL_FRAMEBUFFER, sCurFBO); + glBindFramebuffer(target, sCurFBO); } void LLRenderTarget::releaseColorAttachment() @@ -194,6 +196,7 @@ void LLRenderTarget::releaseColorAttachment() glBindFramebuffer(GL_FRAMEBUFFER, mFBO); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, LLTexUnit::getInternalType(mUsage), 0, 0); glBindFramebuffer(GL_FRAMEBUFFER, sCurFBO); + LOG_GLERROR(mName + " releaseColorAttachment()"); mTex.clear(); } @@ -208,6 +211,8 @@ bool LLRenderTarget::addColorAttachment(U32 color_fmt) return true; } + U32 target = getTarget(); + U32 offset = static_cast<U32>(mTex.size()); if( offset >= 4 ) @@ -226,12 +231,76 @@ bool LLRenderTarget::addColorAttachment(U32 color_fmt) LLImageGL::generateTextures(1, &tex); gGL.getTexUnit(0)->bindManual(mUsage, tex); - stop_glerror(); - + U32 miplevel = mMipLevels; + U32 intformat = color_fmt; + U32 pixformat = GL_RGBA; + U32 pixtype = GL_UNSIGNED_BYTE; { - clear_glerror(); - LLImageGL::setManualImage(LLTexUnit::getInternalType(mUsage), 0, color_fmt, mResX, mResY, GL_RGBA, GL_UNSIGNED_BYTE, NULL, false); + //clear_glerror(); + + if(color_fmt == GL_RGB10_A2) + { + pixformat = GL_RGBA; + pixtype = GL_UNSIGNED_BYTE; + } + else if(color_fmt == GL_R11F_G11F_B10F) + { + pixformat = GL_RGB; + pixtype = GL_HALF_FLOAT; + } + else if(color_fmt == GL_R8) + { + pixformat = GL_RED; + pixtype = GL_UNSIGNED_BYTE; + } + else if(color_fmt == GL_R16F) + { + pixformat = GL_RED; + pixtype = GL_HALF_FLOAT; + } + else if(color_fmt == GL_RG16F) + { + pixformat = GL_RG; + pixtype = GL_HALF_FLOAT; + } + else if(color_fmt == GL_RGBA16F) + { + pixformat = GL_RGBA; + pixtype = GL_HALF_FLOAT; + } + else if(color_fmt == GL_RGB16F) + { + pixformat = GL_RGB; + pixtype = GL_HALF_FLOAT; + } + else if(color_fmt == GL_RGB8) + { + pixformat = GL_RGB; + pixtype = GL_UNSIGNED_BYTE; + } + else if(color_fmt == GL_RGB) + { + pixformat = GL_RGB; + pixtype = GL_UNSIGNED_BYTE; + } + else if(color_fmt == GL_RGBA) + { + pixformat = GL_RGBA; + pixtype = GL_UNSIGNED_BYTE; + } + else if(color_fmt == GL_RGBA8) + { + pixformat = GL_RGBA; + pixtype = GL_UNSIGNED_BYTE; + } + else + { + pixformat = GL_RGBA; + pixtype = GL_UNSIGNED_BYTE; + } + + LLImageGL::setManualImage(LLTexUnit::getInternalType(mUsage), 0, color_fmt, mResX, mResY, pixformat, pixtype, NULL, false); if (glGetError() != GL_NO_ERROR) { LL_WARNS() << "Could not allocate color buffer for render target." << LL_ENDL; @@ -241,32 +310,30 @@ bool LLRenderTarget::addColorAttachment(U32 color_fmt) sBytesAllocated += mResX*mResY*4; - stop_glerror(); - - if (offset == 0) { //use bilinear filtering on single texture render targets that aren't multisampled gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR); - stop_glerror(); + LOG_GLERROR(mName + " setting filtering to TFO_BILINEAR"); } else { //don't filter data attachments gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT); - stop_glerror(); + LOG_GLERROR(mName + " setting filtering to TFO_POINT"); } #if GL_VERSION_3_1 if (mUsage != LLTexUnit::TT_RECT_TEXTURE) { gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_MIRROR); - stop_glerror(); + LOG_GLERROR(mName + " setting address mode to TAM_MIRROR"); + } else #endif { // ATI doesn't support mirrored repeat for rectangular textures. gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP); - stop_glerror(); + LOG_GLERROR(mName + " setting address mode to TAM_CLAMP"); } if (mFBO) @@ -285,7 +352,7 @@ bool LLRenderTarget::addColorAttachment(U32 color_fmt) if (gDebugGL) { //bind and unbind to validate target - bindTarget(); + bindTarget(mName, mMode); flush(); } @@ -300,16 +367,15 @@ bool LLRenderTarget::allocateDepth() gGL.getTexUnit(0)->bindManual(mUsage, mDepth); U32 internal_type = LLTexUnit::getInternalType(mUsage); - stop_glerror(); - clear_glerror(); - LLImageGL::setManualImage(internal_type, 0, GL_DEPTH_COMPONENT24, mResX, mResY, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL, false); + + LLImageGL::setManualImage(internal_type, 0, GL_DEPTH_COMPONENT24, mResX, mResY, GL_DEPTH_COMPONENT, GL_FLOAT, NULL, false); gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT); sBytesAllocated += mResX*mResY*4; if (glGetError() != GL_NO_ERROR) { - LL_WARNS() << "Unable to allocate depth buffer for render target." << LL_ENDL; + LL_WARNS() << "Unable to allocate depth buffer for render target " << mName << LL_ENDL; return false; } @@ -345,6 +411,8 @@ void LLRenderTarget::shareDepthBuffer(LLRenderTarget& target) glBindFramebuffer(GL_FRAMEBUFFER, sCurFBO); + LOG_GLERROR(mName + " shareDepthBuffer()"); + target.mUseDepth = true; } } @@ -408,19 +476,32 @@ void LLRenderTarget::release() LLImageGL::deleteTextures(1, &mTex[0]); } + LOG_GLERROR(mName + " release()"); + mTex.clear(); mInternalFormat.clear(); mResX = mResY = 0; } -void LLRenderTarget::bindTarget() +void LLRenderTarget::bindTarget(std::string name_, U32 mode_) { LL_PROFILE_GPU_ZONE("bindTarget"); llassert(mFBO); llassert(!isBoundInStack()); - glBindFramebuffer(GL_FRAMEBUFFER, mFBO); + //mode_ = 0; + + mMode = mode_; + mName = name_; + + U32 target = getTarget(); + + glBindFramebuffer(target, mFBO); + LOG_GLERROR(mName+" bindTarget()"); + + //attach(); + sCurFBO = mFBO; //setup multiple render targets @@ -431,16 +512,35 @@ void LLRenderTarget::bindTarget() if (mTex.empty()) { //no color buffer to draw to + if(!mUseDepth) LL_WARNS() << mName << " HAS NO COLOR BUFFER AND NO DEPTH!!" << LL_ENDL; GLenum buffers[] = {GL_NONE}; glDrawBuffers(0, buffers); glReadBuffer(GL_NONE); } - else + else if(mMode == 0) + { + glDrawBuffers(static_cast<GLsizei>(mTex.size()), drawbuffers); + glReadBuffer(GL_COLOR_ATTACHMENT0); + + LOG_GLERROR(mName+" read and write buffers"); + + } + else if(mMode == 1) { glDrawBuffers(static_cast<GLsizei>(mTex.size()), drawbuffers); + glReadBuffer(GL_NONE); + LOG_GLERROR(mName+" draw buffer"); + } + else if(mMode == 2) + { + GLenum buffers[] = {GL_NONE}; + glDrawBuffers(0, buffers); glReadBuffer(GL_COLOR_ATTACHMENT0); + LOG_GLERROR(mName+" read buffer"); } + check_framebuffer_status(); + LOG_GLERROR(mName+" checked status"); glViewport(0, 0, mResX, mResY); sCurResX = mResX; @@ -454,24 +554,22 @@ void LLRenderTarget::clear(U32 mask_in) { LL_PROFILE_GPU_ZONE("clear"); llassert(mFBO); - U32 mask = GL_COLOR_BUFFER_BIT; - if (mUseDepth) - { - mask |= GL_DEPTH_BUFFER_BIT; + U32 mask = 0; + + if(!mTex.empty()) mask |= GL_COLOR_BUFFER_BIT; + if (mUseDepth) mask |= GL_DEPTH_BUFFER_BIT; - } if (mFBO) { check_framebuffer_status(); - stop_glerror(); glClear(mask & mask_in); - stop_glerror(); + LOG_GLERROR(mName + "clear()"); } else { LLGLEnable scissor(GL_SCISSOR_TEST); glScissor(0, 0, mResX, mResY); - stop_glerror(); + LOG_GLERROR(""); glClear(mask & mask_in); } } @@ -514,29 +612,43 @@ void LLRenderTarget::bindTexture(U32 index, S32 channel, LLTexUnit::eTextureFilt } gGL.getTexUnit(channel)->setTextureFilteringOption(filter_options); + + LOG_GLERROR(mName + " bindTexture()"); } void LLRenderTarget::flush() { LL_PROFILE_GPU_ZONE("rt flush"); + + LOG_GLERROR(mName+" rt flush() A"); + gGL.flush(); llassert(mFBO); llassert(sCurFBO == mFBO); llassert(sBoundTarget == this); - if (mGenerateMipMaps == LLTexUnit::TMG_AUTO) + if (mGenerateMipMaps == LLTexUnit::TMG_AUTO && mMode != 2) { LL_PROFILE_GPU_ZONE("rt generate mipmaps"); - bindTexture(0, 0, LLTexUnit::TFO_TRILINEAR); + //bindTexture(0, 0, LLTexUnit::TFO_TRILINEAR); + bindTexture(0, 0, LLTexUnit::TFO_ANISOTROPIC); glGenerateMipmap(GL_TEXTURE_2D); + LOG_GLERROR(mName + " glGenerateMipmap()"); } + LOG_GLERROR(mName + " rt flush() B"); + + unbind(); +} + +void LLRenderTarget::unbind() +{ if (mPreviousRT) { // a bit hacky -- pop the RT stack back two frames and push // the previous frame back on to play nice with the GL state machine sBoundTarget = mPreviousRT->mPreviousRT; - mPreviousRT->bindTarget(); + mPreviousRT->bindTarget(mPreviousRT->mName, mPreviousRT->mMode); } else { @@ -547,9 +659,10 @@ void LLRenderTarget::flush() sCurResX = gGLViewport[2]; sCurResY = gGLViewport[3]; glReadBuffer(GL_BACK); - GLenum drawbuffers[] = {GL_BACK}; - glDrawBuffers(1, drawbuffers); + glDrawBuffer(GL_BACK); } + + LOG_GLERROR(mName + " rt unbind()"); } bool LLRenderTarget::isComplete() const @@ -604,3 +717,13 @@ void LLRenderTarget::swapFBORefs(LLRenderTarget& other) std::swap(mFBO, other.mFBO); std::swap(mTex, other.mTex); } + +U32 LLRenderTarget::getTarget() +{ + U32 target = GL_FRAMEBUFFER; + + if(mMode == 1) target = GL_DRAW_FRAMEBUFFER; + else if(mMode == 2) target = GL_READ_FRAMEBUFFER; + + return target; +} diff --git a/indra/llrender/llrendertarget.h b/indra/llrender/llrendertarget.h index cd3290cf66..ce3025f280 100644 --- a/indra/llrender/llrendertarget.h +++ b/indra/llrender/llrendertarget.h @@ -126,7 +126,7 @@ public: // If an LLRenderTarget is currently bound, stores a reference to that LLRenderTarget // and restores previous binding on flush() (maintains a stack of Render Targets) // Asserts that this target is not currently bound in the stack - void bindTarget(); + void bindTarget(std::string name_ = "nd", U32 mode_ = 0); //clear render targer, clears depth buffer if present, //uses scissor rect if in copy-to-texture mode @@ -158,6 +158,7 @@ public: // If an LLRenderTarget was bound when bindTarget was called, binds that RenderTarget for rendering (maintains RT stack) // asserts that this target is currently bound void flush(); + void unbind(); //Returns TRUE if target is ready to be rendered into. //That is, if the target has been allocated with at least @@ -174,11 +175,15 @@ public: static LLRenderTarget* sBoundTarget; + U32 mMode; + std::string mName; + protected: U32 mResX; U32 mResY; std::vector<U32> mTex; std::vector<U32> mInternalFormat; + std::vector<U32> mPixFormat; U32 mFBO; LLRenderTarget* mPreviousRT = nullptr; @@ -188,6 +193,10 @@ protected: U32 mMipLevels; LLTexUnit::eTextureType mUsage; + +private: + U32 getTarget(); + }; #endif diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp index 4807c12226..6a3f88f9d3 100644 --- a/indra/llrender/llshadermgr.cpp +++ b/indra/llrender/llshadermgr.cpp @@ -571,7 +571,7 @@ GLuint LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_lev } else { - shader_code_text[shader_code_count++] = strdup("#version 400\n"); + shader_code_text[shader_code_count++] = strdup("#version 410\n"); } } else if (major_version == 3) @@ -1501,6 +1501,18 @@ void LLShaderMgr::initAttribsAndUniforms() mReservedUniforms.push_back("searchTex"); mReservedUniforms.push_back("blendTex"); + mReservedUniforms.push_back("bloomEMap"); + mReservedUniforms.push_back("bloomBlurredMap"); + mReservedUniforms.push_back("bloomHorizontal"); + mReservedUniforms.push_back("bloomBlurRadius"); + mReservedUniforms.push_back("bloomExtractBrightness"); + mReservedUniforms.push_back("bloomStrength"); + mReservedUniforms.push_back("bloomExtractEmissive"); + mReservedUniforms.push_back("bloomExtractEmissive2"); + mReservedUniforms.push_back("bloomExtractORM"); + mReservedUniforms.push_back("bloomExtractMetal"); + mReservedUniforms.push_back("bloomExtractNonMetal"); + llassert(mReservedUniforms.size() == END_RESERVED_UNIFORMS); std::set<std::string> dupe_check; diff --git a/indra/llrender/llshadermgr.h b/indra/llrender/llshadermgr.h index 46788841a5..8b0bfc6bbe 100644 --- a/indra/llrender/llshadermgr.h +++ b/indra/llrender/llshadermgr.h @@ -341,6 +341,18 @@ public: SMAA_SEARCH_TEX, // "searchTex" SMAA_BLEND_TEX, // "blendTex" + BLOOM_EMAP, // "bloomEMap" + BLOOM_BMAP, // "bloomBlurredMap" + BLOOM_BLURH, // "bloomHorizontal" + BLOOM_BLUR_RADIUS, // "bloomRadius" + BLOOM_EXTRACT_BRIGHTNESS, // "bloomExtractBrightness" + BLOOM_STRENGTH, // "bloomStrength" + BLOOM_EXTRACT_EMISSIVE, // "bloomExtractEmissive" + BLOOM_EXTRACT_EMISSIVE2, // "bloomExtractEmissive2" + BLOOM_EXTRACT_ORM, // "bloomExtractORM" + BLOOM_EXTRACT_METAL, // "bloomExtractMetal" + BLOOM_EXTRACT_NONMETAL, // "bloomExtractNonMetal" + END_RESERVED_UNIFORMS } eGLSLReservedUniforms; // clang-format on diff --git a/indra/llrender/llvertexbuffer.cpp b/indra/llrender/llvertexbuffer.cpp index ac6db0b34f..43d780a383 100644 --- a/indra/llrender/llvertexbuffer.cpp +++ b/indra/llrender/llvertexbuffer.cpp @@ -345,7 +345,7 @@ public: void allocate(GLenum type, U32 size, GLuint& name, U8*& data) override { LL_PROFILE_ZONE_SCOPED_CATEGORY_VERTEX; - STOP_GLERROR; + llassert(type == GL_ARRAY_BUFFER || type == GL_ELEMENT_ARRAY_BUFFER); llassert(name == 0); // non zero name indicates a gl name that wasn't freed llassert(data == nullptr); // non null data indicates a buffer that wasn't freed @@ -355,10 +355,19 @@ public: { //allocate a new buffer LL_PROFILE_GPU_ZONE("vbo alloc"); - // ON OS X, we don't allocate a VBO until the last possible moment - // in unmapBuffer + data = (U8*) ll_aligned_malloc_16(size); - STOP_GLERROR; + + if (type == GL_ARRAY_BUFFER) + { + glGenBuffers(1, &name); + LLVertexBuffer::sGLRenderBuffer = name; + } + else + { + glGenBuffers(1, &name); + LLVertexBuffer::sGLRenderIndices = name; + } } } @@ -374,12 +383,12 @@ public: } mAllocated -= size; - STOP_GLERROR; + if (name) { delete_buffers(1, &name); } - STOP_GLERROR; + //LOG_GLERROR("LLAppleVBOPool::free()"); } }; @@ -783,7 +792,6 @@ void LLVertexBuffer::drawElements(U32 mode, const LLVector4a* pos, const LLVecto LL_PROFILE_ZONE_SCOPED_CATEGORY_VERTEX; llassert(LLGLSLShader::sCurBoundShaderPtr != NULL); - STOP_GLERROR; gGL.syncMatrices(); @@ -909,10 +917,8 @@ void LLVertexBuffer::drawRange(U32 mode, U32 start, U32 end, U32 count, U32 indi llassert(mGLBuffer == sGLRenderBuffer); llassert(mGLIndices == sGLRenderIndices); gGL.syncMatrices(); - STOP_GLERROR; glDrawRangeElements(sGLMode[mode], start, end, count, mIndicesType, (GLvoid*) (indices_offset * (size_t) mIndicesStride)); - STOP_GLERROR; } void LLVertexBuffer::drawRangeFast(U32 mode, U32 start, U32 end, U32 count, U32 indices_offset) const @@ -935,9 +941,8 @@ void LLVertexBuffer::drawArrays(U32 mode, U32 first, U32 count) const llassert(mGLIndices == sGLRenderIndices); gGL.syncMatrices(); - STOP_GLERROR; glDrawArrays(sGLMode[mode], first, count); - STOP_GLERROR; + LOG_GLERROR("LLVertexBuffer::drawArrays()"); } //static @@ -970,10 +975,8 @@ void LLVertexBuffer::initClass(LLWindow* window) //static void LLVertexBuffer::unbind() { - STOP_GLERROR; glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); - STOP_GLERROR; sGLRenderBuffer = 0; sGLRenderIndices = 0; } @@ -1366,7 +1369,7 @@ void LLVertexBuffer::flush_vbo(GLenum target, U32 start, U32 end, void* data, U8 // _mapBuffer to tag the buffer for flushing to GL _mapBuffer(); LL_PROFILE_ZONE_NAMED_CATEGORY_VERTEX("vb memcpy"); - STOP_GLERROR; + //LOG_GLERROR("LLVertexBuffer::flush_vbo()"); // copy into mapped buffer memcpy(dst+start, data, end-start+1); } @@ -1412,7 +1415,6 @@ void LLVertexBuffer::_mapBuffer() void LLVertexBuffer::_unmapBuffer() { - STOP_GLERROR; if (!mMapped) { return; @@ -1428,14 +1430,14 @@ void LLVertexBuffer::_unmapBuffer() if (gGLManager.mIsApple) { - STOP_GLERROR; + LOG_GLERROR("LLVertexBuffer::_unmapBuffer() - apple 1"); if (mMappedData) { - if (mGLBuffer) + if(mGLBuffer == 0) { - delete_buffers(1, &mGLBuffer); + LL_WARNS() << "mGLBuffer is ZERO in unmapbuffer" << LL_ENDL; + glGenBuffers(1, &mGLBuffer); } - mGLBuffer = gen_buffer(); glBindBuffer(GL_ARRAY_BUFFER, mGLBuffer); sGLRenderBuffer = mGLBuffer; glBufferData(GL_ARRAY_BUFFER, mSize, mMappedData, GL_STATIC_DRAW); @@ -1445,16 +1447,16 @@ void LLVertexBuffer::_unmapBuffer() glBindBuffer(GL_ARRAY_BUFFER, mGLBuffer); sGLRenderBuffer = mGLBuffer; } - STOP_GLERROR; + LOG_GLERROR("LLVertexBuffer::_unmapBuffer() - apple 2"); if (mMappedIndexData) { - if (mGLIndices) + if (mGLIndices == 0) { - delete_buffers(1, &mGLIndices); + LL_WARNS() << "mGLIndices is ZERO in unmapbuffer" << LL_ENDL; + glGenBuffers(1, &mGLIndices); } - mGLIndices = gen_buffer(); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mGLIndices); sGLRenderIndices = mGLIndices; @@ -1465,7 +1467,7 @@ void LLVertexBuffer::_unmapBuffer() glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mGLIndices); sGLRenderIndices = mGLIndices; } - STOP_GLERROR; + LOG_GLERROR("LLVertexBuffer::_unmapBuffer() - apple 3"); } else { @@ -1656,11 +1658,10 @@ bool LLVertexBuffer::getClothWeightStrider(LLStrider<LLVector4>& strider, U32 in // Set for rendering void LLVertexBuffer::setBuffer() { - STOP_GLERROR; if (mMapped) { - LL_WARNS_ONCE() << "Missing call to unmapBuffer or flushBuffers" << LL_ENDL; + LL_WARNS() << "Missing call to unmapBuffer or flushBuffers" << LL_ENDL; _unmapBuffer(); } @@ -1680,6 +1681,11 @@ void LLVertexBuffer::setBuffer() if (sGLRenderBuffer != mGLBuffer) { + if(mGLBuffer == 0) + { + LL_WARNS() << "mGLBuffer is ZERO: sGLRenderBuffer=" << sGLRenderBuffer << LL_ENDL; + } + glBindBuffer(GL_ARRAY_BUFFER, mGLBuffer); sGLRenderBuffer = mGLBuffer; @@ -1697,14 +1703,14 @@ void LLVertexBuffer::setBuffer() sGLRenderIndices = mGLIndices; } - STOP_GLERROR; + LOG_GLERROR("LLVertexBuffer::setBuffer()"); } // virtual (default) void LLVertexBuffer::setupVertexBuffer() { - STOP_GLERROR; + LOG_GLERROR("LLVertexBuffer::setupVertexBuffer()"); U8* base = nullptr; AttributeType loc; @@ -1712,98 +1718,141 @@ void LLVertexBuffer::setupVertexBuffer() U32 data_mask = LLGLSLShader::sCurBoundShaderPtr->mAttributeMask; + if (data_mask & MAP_VERTEX) + { + loc = TYPE_VERTEX; + ptr = (void*)(base + mOffsets[TYPE_VERTEX]); + glVertexAttribPointer(loc, 3, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_VERTEX], ptr); + + LOG_GLERROR("LLVertexBuffer::setupVertexBuffer TYPE_VERTEX"); + } + if (data_mask & MAP_NORMAL) { loc = TYPE_NORMAL; ptr = (void*)(base + mOffsets[TYPE_NORMAL]); glVertexAttribPointer(loc, 3, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_NORMAL], ptr); + + LOG_GLERROR("LLVertexBuffer::setupVertexBuffer TYPE_NORMAL"); } - if (data_mask & MAP_TEXCOORD3) - { - loc = TYPE_TEXCOORD3; - ptr = (void*)(base + mOffsets[TYPE_TEXCOORD3]); - glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_TEXCOORD3], ptr); - } - if (data_mask & MAP_TEXCOORD2) + + if (data_mask & MAP_TEXCOORD0) { - loc = TYPE_TEXCOORD2; - ptr = (void*)(base + mOffsets[TYPE_TEXCOORD2]); - glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_TEXCOORD2], ptr); + loc = TYPE_TEXCOORD0; + //glEnableVertexAttribArray(loc); + ptr = (void*)(base + mOffsets[TYPE_TEXCOORD0]); + glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_TEXCOORD0], ptr); + + LOG_GLERROR("LLVertexBuffer::setupVertexBuffer TYPE_TEXCOORD0"); } + if (data_mask & MAP_TEXCOORD1) { loc = TYPE_TEXCOORD1; ptr = (void*)(base + mOffsets[TYPE_TEXCOORD1]); glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_TEXCOORD1], ptr); + + LOG_GLERROR("LLVertexBuffer::setupVertexBuffer TYPE_TEXCOORD1"); } - if (data_mask & MAP_TANGENT) + + if (data_mask & MAP_TEXCOORD2) { - loc = TYPE_TANGENT; - ptr = (void*)(base + mOffsets[TYPE_TANGENT]); - glVertexAttribPointer(loc, 4, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_TANGENT], ptr); + loc = TYPE_TEXCOORD2; + ptr = (void*)(base + mOffsets[TYPE_TEXCOORD2]); + glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_TEXCOORD2], ptr); + + LOG_GLERROR("LLVertexBuffer::setupVertexBuffer TYPE_TEXCOORD2"); } - if (data_mask & MAP_TEXCOORD0) + + if (data_mask & MAP_TEXCOORD3) { - loc = TYPE_TEXCOORD0; - ptr = (void*)(base + mOffsets[TYPE_TEXCOORD0]); - glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_TEXCOORD0], ptr); + loc = TYPE_TEXCOORD3; + ptr = (void*)(base + mOffsets[TYPE_TEXCOORD3]); + glVertexAttribPointer(loc, 2, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_TEXCOORD3], ptr); + + LOG_GLERROR("LLVertexBuffer::setupVertexBuffer TYPE_TEXCOORD3"); } + if (data_mask & MAP_COLOR) { loc = TYPE_COLOR; //bind emissive instead of color pointer if emissive is present ptr = (data_mask & MAP_EMISSIVE) ? (void*)(base + mOffsets[TYPE_EMISSIVE]) : (void*)(base + mOffsets[TYPE_COLOR]); glVertexAttribPointer(loc, 4, GL_UNSIGNED_BYTE, GL_TRUE, LLVertexBuffer::sTypeSize[TYPE_COLOR], ptr); + + LOG_GLERROR("LLVertexBuffer::setupVertexBuffer TYPE_COLOR"); } + if (data_mask & MAP_EMISSIVE) { loc = TYPE_EMISSIVE; ptr = (void*)(base + mOffsets[TYPE_EMISSIVE]); glVertexAttribPointer(loc, 4, GL_UNSIGNED_BYTE, GL_TRUE, LLVertexBuffer::sTypeSize[TYPE_EMISSIVE], ptr); + LOG_GLERROR("LLVertexBuffer::setupVertexBuffer TYPE_EMISSIVE"); + if (!(data_mask & MAP_COLOR)) { //map emissive to color channel when color is not also being bound to avoid unnecessary shader swaps loc = TYPE_COLOR; glVertexAttribPointer(loc, 4, GL_UNSIGNED_BYTE, GL_TRUE, LLVertexBuffer::sTypeSize[TYPE_EMISSIVE], ptr); + + LOG_GLERROR("LLVertexBuffer::setupVertexBuffer TYPE_COLOR"); } } + + if (data_mask & MAP_TANGENT) + { + loc = TYPE_TANGENT; + ptr = (void*)(base + mOffsets[TYPE_TANGENT]); + glVertexAttribPointer(loc, 4, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_TANGENT], ptr); + + LOG_GLERROR("LLVertexBuffer::setupVertexBuffer TYPE_TANGENT"); + } + if (data_mask & MAP_WEIGHT) { loc = TYPE_WEIGHT; ptr = (void*)(base + mOffsets[TYPE_WEIGHT]); glVertexAttribPointer(loc, 1, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_WEIGHT], ptr); + + LOG_GLERROR("LLVertexBuffer::setupVertexBuffer TYPE_WEIGHT"); } + if (data_mask & MAP_WEIGHT4) { loc = TYPE_WEIGHT4; ptr = (void*)(base + mOffsets[TYPE_WEIGHT4]); glVertexAttribPointer(loc, 4, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_WEIGHT4], ptr); + + LOG_GLERROR("LLVertexBuffer::setupVertexBuffer TYPE_WEIGHT4"); } - if (data_mask & MAP_JOINT) - { - loc = TYPE_JOINT; - ptr = (void*)(base + mOffsets[TYPE_JOINT]); - glVertexAttribIPointer(loc, 4, GL_UNSIGNED_SHORT, LLVertexBuffer::sTypeSize[TYPE_JOINT], ptr); - } + if (data_mask & MAP_CLOTHWEIGHT) { loc = TYPE_CLOTHWEIGHT; ptr = (void*)(base + mOffsets[TYPE_CLOTHWEIGHT]); glVertexAttribPointer(loc, 4, GL_FLOAT, GL_TRUE, LLVertexBuffer::sTypeSize[TYPE_CLOTHWEIGHT], ptr); + + LOG_GLERROR("LLVertexBuffer::setupVertexBuffer TYPE_CLOTHWEIGHT"); } + + if (data_mask & MAP_JOINT) + { + loc = TYPE_JOINT; + ptr = (void*)(base + mOffsets[TYPE_JOINT]); + glVertexAttribIPointer(loc, 4, GL_UNSIGNED_SHORT, LLVertexBuffer::sTypeSize[TYPE_JOINT], ptr); + + LOG_GLERROR("LLVertexBuffer::setupVertexBuffer TYPE_JOINT"); + } + if (data_mask & MAP_TEXTURE_INDEX) { loc = TYPE_TEXTURE_INDEX; ptr = (void*)(base + mOffsets[TYPE_VERTEX] + 12); glVertexAttribIPointer(loc, 1, GL_UNSIGNED_INT, LLVertexBuffer::sTypeSize[TYPE_VERTEX], ptr); + + LOG_GLERROR("LLVertexBuffer::setupVertexBuffer TYPE_TEXTURE_INDEX"); } - if (data_mask & MAP_VERTEX) - { - loc = TYPE_VERTEX; - ptr = (void*)(base + mOffsets[TYPE_VERTEX]); - glVertexAttribPointer(loc, 3, GL_FLOAT, GL_FALSE, LLVertexBuffer::sTypeSize[TYPE_VERTEX], ptr); - } - STOP_GLERROR; } void LLVertexBuffer::setPositionData(const LLVector4a* data) diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml index 4a45456cfc..c93da4c576 100644 --- a/indra/newview/app_settings/settings.xml +++ b/indra/newview/app_settings/settings.xml @@ -8558,7 +8558,7 @@ <key>Type</key> <string>F32</string> <key>Value</key> - <real>1.4</real> + <real>1.0</real> </map> <key>RenderShadowBlurSamples</key> <map> @@ -9337,9 +9337,9 @@ <key>Persist</key> <integer>1</integer> <key>Type</key> - <string>U32</string> + <string>F32</string> <key>Value</key> - <integer>1</integer> + <integer>1.0</integer> </map> <key>RenderShaderLightingMaxLevel</key> <map> @@ -14363,7 +14363,77 @@ <!-- megapahit settings --> - <key>MPVBufferOptiMode</key> + <key>MPLowColorPrecision</key> + <map> + <key>Comment</key> + <string>Enable / Disable lower precision buffers encoding</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>Boolean</string> + <key>Value</key> + <integer>1</integer> + </map> + <key>MPNoGLDebug</key> + <map> + <key>Comment</key> + <string>Enable / Disable GL Debug</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>Boolean</string> + <key>Value</key> + <integer>1</integer> + </map> + <key>MPGamma</key> + <map> + <key>Comment</key> + <string>Enable / Disable Gamma</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>Boolean</string> + <key>Value</key> + <integer>1</integer> + </map> + <key>MPTone</key> + <map> + <key>Comment</key> + <string>Enable / Disable Tonemap</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>Boolean</string> + <key>Value</key> + <integer>1</integer> + </map> + <key>MPGlow</key> + <map> + <key>Comment</key> + <string>Enable / Disable Glow</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>Boolean</string> + <key>Value</key> + <integer>1</integer> + </map> + <key>MPLuminanceMipmap</key> + <map> + <key>Comment</key> + <string> + Luminance Map Mipmaps: + (set to 0 to fix post-processing slowdowns) + 0:no + 1:yes + </string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>U32</string> + <key>Value</key> + <integer>1</integer> + </map> <map> <key>Comment</key> <string> @@ -14379,6 +14449,17 @@ <key>Value</key> <integer>0</integer> </map> + <key>MPDumbCopy</key> + <map> + <key>Comment</key> + <string>Add a useless copy in pipeline::renderFinalize()</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>Boolean</string> + <key>Value</key> + <real>0</real> + </map> <key>MPRenderShadowOpti</key> <map> <key>Comment</key> @@ -14386,10 +14467,131 @@ <key>Persist</key> <integer>1</integer> <key>Type</key> - <string>S32</string> + <string>U32</string> + <key>Value</key> + <integer>0</integer> + </map> + <key>MPRenderShadowMaxDist</key> + <map> + <key>Comment</key> + <string>Shadows Max Draw distance</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>F32</string> + <key>Value</key> + <integer>64</integer> + </map> + <key>MPRenderBloom</key> + <map> + <key>Comment</key> + <string>Automatic bloom (n blur iterations, 0: Disable)</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>U32</string> <key>Value</key> <integer>0</integer> </map> + <key>MPBloomExtractBrightness</key> + <map> + <key>Comment</key> + <string>Auto bloom: Min extracted brightness</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>F32</string> + <key>Value</key> + <real>0.20</real> + </map> + <key>MPBloomExtractMetal</key> + <map> + <key>Comment</key> + <string>Auto bloom: Metal roughness limit filter</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>F32</string> + <key>Value</key> + <real>0.40</real> + </map> + <key>MPBloomExtractNonMetal</key> + <map> + <key>Comment</key> + <string>Auto bloom: Non Metal roughness limit filter</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>F32</string> + <key>Value</key> + <real>0.0</real> + </map> + <key>MPBloomStrength</key> + <map> + <key>Comment</key> + <string>Auto bloom Strength (0.1 to 1.5)</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>F32</string> + <key>Value</key> + <real>1.0</real> + </map> + <key>MPBloomBlurRadius</key> + <map> + <key>Comment</key> + <string>Auto bloom: Radius</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>F32</string> + <key>Value</key> + <real>1.5</real> + </map> + <key>MPBloomBlurRadiusAdd</key> + <map> + <key>Comment</key> + <string>Auto bloom: Radius add</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>F32</string> + <key>Value</key> + <real>0.9</real> + </map> + <key>MPRenderProbeUpdatePeriod</key> + <map> + <key>Comment</key> + <string>Delay between probes updates</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>F32</string> + <key>Value</key> + <real>15.0</real> + </map> + <key>MPRenderProbeSlowDown</key> + <map> + <key>Comment</key> + <string>Slow down probes updates</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>F32</string> + <key>Value</key> + <real>0.05</real> + </map> + <key>MPRenderProbeProgressive</key> + <map> + <key>Comment</key> + <string>Calculate Radiance progressively</string> + <key>Persist</key> + <integer>1</integer> + <key>Type</key> + <string>Boolean</string> + <key>Value</key> + <real>0</real> + </map> <key>MPVCameraCollapsed</key> <map> <key>Comment</key> diff --git a/indra/newview/app_settings/shaders/class1/deferred/SMAA.glsl b/indra/newview/app_settings/shaders/class1/deferred/SMAA.glsl index fdb77cce6e..60a8300352 100644 --- a/indra/newview/app_settings/shaders/class1/deferred/SMAA.glsl +++ b/indra/newview/app_settings/shaders/class1/deferred/SMAA.glsl @@ -1351,6 +1351,10 @@ float4 SMAABlendingWeightCalculationPS(float2 texcoord, //----------------------------------------------------------------------------- // Neighborhood Blending Pixel Shader (Third Pass) +vec3 srgb_to_linear(vec3 cs); +vec4 srgb_to_linear4(vec4 cs); +vec3 linear_to_srgb(vec3 cl); + float4 SMAANeighborhoodBlendingPS(float2 texcoord, float4 offset, SMAATexture2D(colorTex), @@ -1369,6 +1373,7 @@ float4 SMAANeighborhoodBlendingPS(float2 texcoord, SMAA_BRANCH if (dot(a, float4(1.0, 1.0, 1.0, 1.0)) < 1e-5) { float4 color = SMAASampleLevelZero(colorTex, texcoord); + color.rgb = srgb_to_linear(color.rgb); #if SMAA_REPROJECTION float2 velocity = SMAA_DECODE_VELOCITY(SMAASampleLevelZero(velocityTex, texcoord)); @@ -1377,6 +1382,8 @@ float4 SMAANeighborhoodBlendingPS(float2 texcoord, color.a = sqrt(5.0 * length(velocity)); #endif + color.rgb = linear_to_srgb(color.rgb); + return color; } else { bool h = max(a.x, a.z) > max(a.y, a.w); // max(horizontal) > max(vertical) @@ -1393,8 +1400,15 @@ float4 SMAANeighborhoodBlendingPS(float2 texcoord, // We exploit bilinear filtering to mix current pixel with the chosen // neighbor: - float4 color = blendingWeight.x * SMAASampleLevelZero(colorTex, blendingCoord.xy); - color += blendingWeight.y * SMAASampleLevelZero(colorTex, blendingCoord.zw); + //float4 color = blendingWeight.x * SMAASampleLevelZero(colorTex, blendingCoord.xy); + //color += blendingWeight.y * SMAASampleLevelZero(colorTex, blendingCoord.zw); + float4 color = SMAASampleLevelZero(colorTex, blendingCoord.xy); + color.rgb = srgb_to_linear(color.rgb); + color = blendingWeight.x * color; + + float4 color2 = SMAASampleLevelZero(colorTex, blendingCoord.zw); + color2.rgb = srgb_to_linear(color2.rgb); + color += blendingWeight.y * color2; #if SMAA_REPROJECTION // Antialias velocity for proper reprojection in a later stage: @@ -1405,6 +1419,7 @@ float4 SMAANeighborhoodBlendingPS(float2 texcoord, color.a = sqrt(5.0 * length(velocity)); #endif + color.rgb = linear_to_srgb(color.rgb); return color; } } diff --git a/indra/newview/app_settings/shaders/class1/deferred/avatarAlphaMaskShadowF.glsl b/indra/newview/app_settings/shaders/class1/deferred/avatarAlphaMaskShadowF.glsl index f1e0295859..084a334346 100644 --- a/indra/newview/app_settings/shaders/class1/deferred/avatarAlphaMaskShadowF.glsl +++ b/indra/newview/app_settings/shaders/class1/deferred/avatarAlphaMaskShadowF.glsl @@ -23,7 +23,7 @@ * $/LicenseInfo$ */ -out vec4 frag_color; +//out vec4 frag_color; uniform float minimum_alpha; uniform sampler2D diffuseMap; @@ -49,5 +49,5 @@ void main() } } - frag_color = vec4(1,1,1,1); + //frag_color = vec4(1,1,1,1); } diff --git a/indra/newview/app_settings/shaders/class1/deferred/avatarAlphaShadowF.glsl b/indra/newview/app_settings/shaders/class1/deferred/avatarAlphaShadowF.glsl index 18ce998cb6..5986e8e462 100644 --- a/indra/newview/app_settings/shaders/class1/deferred/avatarAlphaShadowF.glsl +++ b/indra/newview/app_settings/shaders/class1/deferred/avatarAlphaShadowF.glsl @@ -23,7 +23,7 @@ * $/LicenseInfo$ */ -out vec4 frag_color; +//out vec4 frag_color; uniform float minimum_alpha; @@ -51,5 +51,5 @@ void main() } } - frag_color = vec4(1,1,1,1); + //frag_color = vec4(1,1,1,1); } diff --git a/indra/newview/app_settings/shaders/class1/deferred/avatarShadowF.glsl b/indra/newview/app_settings/shaders/class1/deferred/avatarShadowF.glsl index 37dcbbd328..4396ae89a4 100644 --- a/indra/newview/app_settings/shaders/class1/deferred/avatarShadowF.glsl +++ b/indra/newview/app_settings/shaders/class1/deferred/avatarShadowF.glsl @@ -25,10 +25,10 @@ /*[EXTRA_CODE_HERE]*/ -out vec4 frag_color; +//out vec4 frag_color; void main() { - frag_color = vec4(1,1,1,1); + //frag_color = vec4(1,1,1,1); } diff --git a/indra/newview/app_settings/shaders/class1/deferred/pbrShadowAlphaBlendF.glsl b/indra/newview/app_settings/shaders/class1/deferred/pbrShadowAlphaBlendF.glsl index dbaab9bbda..90d81ab6b2 100644 --- a/indra/newview/app_settings/shaders/class1/deferred/pbrShadowAlphaBlendF.glsl +++ b/indra/newview/app_settings/shaders/class1/deferred/pbrShadowAlphaBlendF.glsl @@ -23,7 +23,7 @@ * $/LicenseInfo$ */ -out vec4 frag_color; +//out vec4 frag_color; uniform sampler2D diffuseMap; @@ -52,5 +52,5 @@ void main() } } - frag_color = vec4(1,1,1,1); + //frag_color = vec4(1,1,1,1); } diff --git a/indra/newview/app_settings/shaders/class1/deferred/pbrShadowAlphaMaskF.glsl b/indra/newview/app_settings/shaders/class1/deferred/pbrShadowAlphaMaskF.glsl index 07a2218db2..2b314db51a 100644 --- a/indra/newview/app_settings/shaders/class1/deferred/pbrShadowAlphaMaskF.glsl +++ b/indra/newview/app_settings/shaders/class1/deferred/pbrShadowAlphaMaskF.glsl @@ -23,7 +23,7 @@ * $/LicenseInfo$ */ -out vec4 frag_color; +//out vec4 frag_color; uniform sampler2D diffuseMap; @@ -42,5 +42,5 @@ void main() discard; } - frag_color = vec4(1,1,1,1); + //frag_color = vec4(1,1,1,1); } diff --git a/indra/newview/app_settings/shaders/class1/deferred/shadowAlphaMaskF.glsl b/indra/newview/app_settings/shaders/class1/deferred/shadowAlphaMaskF.glsl index f208ac746b..a37e970feb 100644 --- a/indra/newview/app_settings/shaders/class1/deferred/shadowAlphaMaskF.glsl +++ b/indra/newview/app_settings/shaders/class1/deferred/shadowAlphaMaskF.glsl @@ -25,7 +25,7 @@ /*[EXTRA_CODE_HERE]*/ -out vec4 frag_color; +//out vec4 frag_color; in vec4 post_pos; in float target_pos_x; @@ -59,5 +59,5 @@ void main() } } - frag_color = vec4(1,1,1,1); + //frag_color = vec4(1,1,1,1); } diff --git a/indra/newview/app_settings/shaders/class1/deferred/shadowF.glsl b/indra/newview/app_settings/shaders/class1/deferred/shadowF.glsl index b55d769fd6..c4e4c4d051 100644 --- a/indra/newview/app_settings/shaders/class1/deferred/shadowF.glsl +++ b/indra/newview/app_settings/shaders/class1/deferred/shadowF.glsl @@ -23,9 +23,9 @@ * $/LicenseInfo$ */ -out vec4 frag_color; +//out vec4 frag_color; void main() { - frag_color = vec4(1,1,1,1); + //frag_color = vec4(1,1,1,1); } diff --git a/indra/newview/app_settings/shaders/class1/deferred/shadowUtil.glsl b/indra/newview/app_settings/shaders/class1/deferred/shadowUtil.glsl index 6f7bd2bf3c..033c2f924a 100644 --- a/indra/newview/app_settings/shaders/class1/deferred/shadowUtil.glsl +++ b/indra/newview/app_settings/shaders/class1/deferred/shadowUtil.glsl @@ -113,8 +113,8 @@ float sampleDirectionalShadow(vec3 pos, vec3 norm, vec2 pos_screen) if (spos.z > -shadow_clip.w) { vec4 lpos; - vec4 near_split = shadow_clip*-0.75; - vec4 far_split = shadow_clip*-1.25; + vec4 near_split = shadow_clip*-0.9; + vec4 far_split = shadow_clip*-1.1; vec4 transition_domain = near_split-far_split; float weight = 0.0; @@ -131,7 +131,10 @@ float sampleDirectionalShadow(vec3 pos, vec3 norm, vec2 pos_screen) shadow += contrib; weight += w; } - shadow += max((pos.z+shadow_clip.z)/(shadow_clip.z-shadow_clip.w)*2.0-1.0, 0.0); + + //shadow += max( (pos.z+shadow_clip.z) / (shadow_clip.z-shadow_clip.w) * 2.0 - 1.0, 0.0); + shadow += max( (pos.z+shadow_clip.z) / (shadow_clip.z-shadow_clip.w) * 1.0, 0.0); + //shadow -= max( (shadow_clip.z + pos.z) / (shadow_clip.z - shadow_clip.w) , 0.0); } if (spos.z < near_split.y && spos.z > far_split.z) diff --git a/indra/newview/app_settings/shaders/class1/deferred/treeShadowF.glsl b/indra/newview/app_settings/shaders/class1/deferred/treeShadowF.glsl index 33a5efa45d..4579d4fbe0 100644 --- a/indra/newview/app_settings/shaders/class1/deferred/treeShadowF.glsl +++ b/indra/newview/app_settings/shaders/class1/deferred/treeShadowF.glsl @@ -26,7 +26,7 @@ /*[EXTRA_CODE_HERE]*/ -out vec4 frag_color; +//out vec4 frag_color; uniform float minimum_alpha; @@ -43,5 +43,5 @@ void main() discard; } - frag_color = vec4(1,1,1,1); + //frag_color = vec4(1,1,1,1); } diff --git a/indra/newview/app_settings/shaders/class1/effects/bloomBlurF.glsl b/indra/newview/app_settings/shaders/class1/effects/bloomBlurF.glsl new file mode 100644 index 0000000000..0efbbdce96 --- /dev/null +++ b/indra/newview/app_settings/shaders/class1/effects/bloomBlurF.glsl @@ -0,0 +1,37 @@ +out vec4 frag_color; + +in vec2 vary_texcoord0; + +uniform sampler2D bloomEMap; + +uniform bool bloomHorizontal; +uniform float bloomBlurRadius = 1.5; + +uniform float weight[5] = float[] (0.227027, 0.1945946, 0.1216216, 0.054054, 0.016216); + +void main() +{ + vec2 size = vec2(bloomBlurRadius, bloomBlurRadius); + + vec2 tex_offset = size / textureSize(bloomEMap, 0); // gets size of single texel + vec3 result = texture(bloomEMap, vary_texcoord0).rgb * weight[0]; // current fragment's contribution + + if(bloomHorizontal) + { + for(int i = 1; i < 5; i++) + { + result += texture(bloomEMap, vary_texcoord0 + vec2(tex_offset.x * i, 0.0)).rgb * weight[i]; + result += texture(bloomEMap, vary_texcoord0 - vec2(tex_offset.x * i, 0.0)).rgb * weight[i]; + } + } + else + { + for(int i = 1; i < 5; i++) + { + result += texture(bloomEMap, vary_texcoord0 + vec2(0.0, tex_offset.y * i)).rgb * weight[i]; + result += texture(bloomEMap, vary_texcoord0 - vec2(0.0, tex_offset.y * i)).rgb * weight[i]; + } + } + + frag_color = vec4(result, 1.0); +}
\ No newline at end of file diff --git a/indra/newview/app_settings/shaders/class1/effects/bloomBlurV.glsl b/indra/newview/app_settings/shaders/class1/effects/bloomBlurV.glsl new file mode 100644 index 0000000000..e40b60ed3c --- /dev/null +++ b/indra/newview/app_settings/shaders/class1/effects/bloomBlurV.glsl @@ -0,0 +1,8 @@ +in vec3 position; +out vec2 vary_texcoord0; + +void main() +{ + gl_Position = vec4(position, 1.0); + vary_texcoord0.xy = position.xy * 0.5 + 0.5; +}
\ No newline at end of file diff --git a/indra/newview/app_settings/shaders/class1/effects/bloomCombineF.glsl b/indra/newview/app_settings/shaders/class1/effects/bloomCombineF.glsl new file mode 100644 index 0000000000..31a6e10fa4 --- /dev/null +++ b/indra/newview/app_settings/shaders/class1/effects/bloomCombineF.glsl @@ -0,0 +1,23 @@ +out vec4 frag_color; + +in vec2 vary_texcoord0; + +uniform sampler2D diffuseMap; +uniform sampler2D bloomBlurredMap; + +uniform float bloomStrength; + +void main() +{ + vec4 hdrColor = texture(diffuseMap, vary_texcoord0); + vec3 bloomColor = texture(bloomBlurredMap, vary_texcoord0).rgb; + vec4 result = vec4(0.0); + + result.r = min(hdrColor.r + bloomStrength * bloomColor.r, 1.0); + result.g = min(hdrColor.g + bloomStrength * bloomColor.g, 1.0); + result.b = min(hdrColor.b + bloomStrength * bloomColor.b, 1.0); + result.a = hdrColor.a; + + //bloomColor += hdrColor.rgb; + frag_color = result; +}
\ No newline at end of file diff --git a/indra/newview/app_settings/shaders/class1/effects/bloomCombineV.glsl b/indra/newview/app_settings/shaders/class1/effects/bloomCombineV.glsl new file mode 100644 index 0000000000..e40b60ed3c --- /dev/null +++ b/indra/newview/app_settings/shaders/class1/effects/bloomCombineV.glsl @@ -0,0 +1,8 @@ +in vec3 position; +out vec2 vary_texcoord0; + +void main() +{ + gl_Position = vec4(position, 1.0); + vary_texcoord0.xy = position.xy * 0.5 + 0.5; +}
\ No newline at end of file diff --git a/indra/newview/app_settings/shaders/class1/effects/bloomExtractF.glsl b/indra/newview/app_settings/shaders/class1/effects/bloomExtractF.glsl new file mode 100644 index 0000000000..8fb10d8698 --- /dev/null +++ b/indra/newview/app_settings/shaders/class1/effects/bloomExtractF.glsl @@ -0,0 +1,81 @@ +out vec4 frag_color; + +uniform sampler2D diffuseMap; +uniform sampler2D bloomExtractORM; // orm +uniform sampler2D bloomExtractEmissive; // emissive +uniform sampler2D bloomExtractEmissive2; // emissive 2 + +uniform float bloomExtractBrightness = 0.9; +uniform float bloomExtractMetal = 0.20; +uniform float bloomExtractNonMetal = 0.20; + +in vec2 vary_texcoord0; + +void main() +{ + vec4 col = texture(diffuseMap, vary_texcoord0.xy); + + //int valid = 0; + //float brightness = dot(col.rgb, vec3(0.2126, 0.7152, 0.0722)); + float brightness = dot(col.rgb, vec3(0.3, 0.5, 0.2)); + + if(brightness < bloomExtractBrightness) + { + discard; + return; + } + + vec3 emi = texture(bloomExtractEmissive, vary_texcoord0.xy).rgb; + if(emi.r + emi.g + emi.b > 0.01) + { + discard; + return; + } + + emi = texture(bloomExtractEmissive2, vary_texcoord0.xy).rgb; + if(emi.r + emi.g + emi.b > 0.01) + { + discard; + return; + } + + vec4 orm = texture(bloomExtractORM, vary_texcoord0.xy); + + if(orm.r < 0.7) + { + discard; + return; + } + + if(bloomExtractMetal == 1.0 && bloomExtractNonMetal == 1.0) + { + frag_color = vec4(col.rgb, 0.0); + return; + } + + if(orm.b < 0.15) + { + // non metal + if(orm.g > bloomExtractNonMetal) + { + discard; + return; + } + } + else if(orm.b > 0.8) + { + // metal + if(orm.g > bloomExtractMetal) + { + discard; + return; + } + } + else + { + discard; + return; + } + + frag_color = vec4(col.rgb, 0.0); +}
\ No newline at end of file diff --git a/indra/newview/app_settings/shaders/class1/effects/bloomExtractV.glsl b/indra/newview/app_settings/shaders/class1/effects/bloomExtractV.glsl new file mode 100644 index 0000000000..e40b60ed3c --- /dev/null +++ b/indra/newview/app_settings/shaders/class1/effects/bloomExtractV.glsl @@ -0,0 +1,8 @@ +in vec3 position; +out vec2 vary_texcoord0; + +void main() +{ + gl_Position = vec4(position, 1.0); + vary_texcoord0.xy = position.xy * 0.5 + 0.5; +}
\ No newline at end of file diff --git a/indra/newview/featuretable_mac.txt b/indra/newview/featuretable_mac.txt index 3233afc28d..396ece9dc1 100644 --- a/indra/newview/featuretable_mac.txt +++ b/indra/newview/featuretable_mac.txt @@ -69,7 +69,7 @@ RenderMaxTextureIndex 1 16 RenderGLContextCoreProfile 1 1 RenderGLMultiThreadedTextures 1 1 RenderGLMultiThreadedMedia 1 1 -RenderAppleUseMultGL 1 1 +RenderAppleUseMultGL 1 0 RenderReflectionsEnabled 1 1 RenderReflectionProbeDetail 1 2 RenderScreenSpaceReflections 1 1 @@ -129,7 +129,8 @@ RenderTonemapType 1 1 RenderTonemapMix 1 0.7 RenderDisableVintageMode 1 0 RenderMaxTextureResolution 1 512 -RenderReflectionProbeCount 1 8 +RenderReflectionProbeCount 1 4 +RenderReflectionProbeDrawDistance 1 16.0 // @@ -152,7 +153,7 @@ RenderTerrainPBRDetail 1 -1 RenderTerrainPBRPlanarSampleCount 1 1 RenderTransparentWater 1 0 RenderTreeLODFactor 1 0.5 -RenderVolumeLODFactor 1 1.125 +RenderVolumeLODFactor 1 2.0 RenderDeferredSSAO 1 0 RenderShadowDetail 1 0 WLSkyDetail 1 96 @@ -173,7 +174,8 @@ RenderTonemapType 1 1 RenderTonemapMix 1 0.7 RenderDisableVintageMode 1 0 RenderMaxTextureResolution 1 1024 -RenderReflectionProbeCount 1 32 +RenderReflectionProbeCount 1 16 +RenderReflectionProbeDrawDistance 1 24.0 // // Medium Graphics Settings (standard) @@ -195,7 +197,7 @@ RenderTerrainPBRDetail 1 0 RenderTerrainPBRPlanarSampleCount 1 1 RenderTransparentWater 1 0 RenderTreeLODFactor 1 0.5 -RenderVolumeLODFactor 1 1.25 +RenderVolumeLODFactor 1 2.5 RenderDeferredSSAO 1 0 RenderShadowDetail 1 0 WLSkyDetail 1 96 @@ -216,6 +218,7 @@ RenderTonemapType 1 1 RenderTonemapMix 1 0.7 RenderMaxTextureResolution 1 2048 RenderReflectionProbeCount 1 64 +RenderReflectionProbeDrawDistance 1 32.0 // // Medium High Graphics Settings @@ -237,7 +240,7 @@ RenderTerrainPBRDetail 1 0 RenderTerrainPBRPlanarSampleCount 1 1 RenderTransparentWater 1 0 RenderTreeLODFactor 1 0.5 -RenderVolumeLODFactor 1 1.375 +RenderVolumeLODFactor 1 3.5 RenderDeferredSSAO 1 0 RenderShadowDetail 1 0 WLSkyDetail 1 96 @@ -279,7 +282,7 @@ RenderTerrainPBRDetail 1 0 RenderTerrainPBRPlanarSampleCount 1 3 RenderTransparentWater 1 1 RenderTreeLODFactor 1 0.5 -RenderVolumeLODFactor 1 1.5 +RenderVolumeLODFactor 1 3.8 RenderDeferredSSAO 1 1 RenderShadowDetail 1 1 WLSkyDetail 1 96 @@ -321,7 +324,7 @@ RenderTerrainPBRDetail 1 0 RenderTerrainPBRPlanarSampleCount 1 3 RenderTransparentWater 1 1 RenderTreeLODFactor 1 0.5 -RenderVolumeLODFactor 1 1.75 +RenderVolumeLODFactor 1 4.0 RenderDeferredSSAO 1 1 RenderShadowDetail 1 2 WLSkyDetail 1 96 @@ -362,7 +365,7 @@ RenderTerrainPBRDetail 1 0 RenderTerrainPBRPlanarSampleCount 1 3 RenderTransparentWater 1 1 RenderTreeLODFactor 1 1.0 -RenderVolumeLODFactor 1 2.0 +RenderVolumeLODFactor 1 4.0 WindLightUseAtmosShaders 1 1 WLSkyDetail 1 128 RenderDeferredSSAO 1 1 @@ -406,7 +409,7 @@ RenderCompressTextures 1 0 // list safe RenderAnisotropic 1 0 -RenderAvatarMaxNonImpostors 1 16 +RenderAvatarMaxNonImpostors 1 3 RenderAvatarMaxComplexity 1 80000 RenderLocalLightCount 1 0 RenderMaxPartCount 1 1024 diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp index 44276d8767..5d107e69db 100644 --- a/indra/newview/llappviewer.cpp +++ b/indra/newview/llappviewer.cpp @@ -592,6 +592,8 @@ static void settings_modify() LLVOSurfacePatch::sLODFactor = gSavedSettings.getF32("RenderTerrainLODFactor"); LLVOSurfacePatch::sLODFactor *= LLVOSurfacePatch::sLODFactor; //square lod factor to get exponential range of [1,4] gDebugGL = gDebugGLSession || gDebugSession; + bool noGLDebug = gSavedSettings.getBOOL("MPNoGLDebug"); + if(noGLDebug) gDebugGL = false; gDebugPipeline = gSavedSettings.getBOOL("RenderDebugPipeline"); } @@ -1351,12 +1353,11 @@ bool LLAppViewer::frame() bool LLAppViewer::doFrame() { U32 fpsLimitMaxFps = (U32)gSavedSettings.getU32("MaxFPS"); - if(fpsLimitMaxFps>120) fpsLimitMaxFps=0; + if(fpsLimitMaxFps > 120) fpsLimitMaxFps = 0; using TimePoint = std::chrono::steady_clock::time_point; - - U64 fpsLimitSleepFor = 0; - TimePoint fpsLimitFrameStartTime = std::chrono::steady_clock::now(); + U64 additionalSleepTime = 0; + TimePoint frameStartTime = std::chrono::steady_clock::now(); #ifdef LL_DISCORD { @@ -1535,18 +1536,6 @@ bool LLAppViewer::doFrame() } } - if(fpsLimitMaxFps > 0) - { - auto elapsed = std::chrono::steady_clock::now() - fpsLimitFrameStartTime; - - long long fpsLimitFrameTime = std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count(); - U64 desired_time_us = (U32)(1000000.f / fpsLimitMaxFps); - if((fpsLimitFrameTime+1000) < desired_time_us) - { - fpsLimitSleepFor = (desired_time_us - fpsLimitFrameTime - 1000) * 1.0; - } - } - { LL_PROFILE_ZONE_NAMED_CATEGORY_APP("df pauseMainloopTimeout"); pingMainloopTimeout("Main:Sleep"); @@ -1559,13 +1548,25 @@ bool LLAppViewer::doFrame() //LL_RECORD_BLOCK_TIME(SLEEP2); LL_PROFILE_ZONE_WARN("Sleep2"); - if(fpsLimitSleepFor) + auto elapsed = std::chrono::steady_clock::now() - frameStartTime; + long long frameTime = std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count(); + + if(fpsLimitMaxFps > 0) { -#if LL_WINDOWS - std::this_thread::sleep_for(std::chrono::microseconds(fpsLimitSleepFor)); -#else - usleep(fpsLimitSleepFor); -#endif + U64 desired_time_us = (U32)(1000000.f / fpsLimitMaxFps); + if((frameTime+1000) < desired_time_us) + { + additionalSleepTime = 0.92 * (F64)(desired_time_us - frameTime); + if(additionalSleepTime < 200) + { + additionalSleepTime = 0; + } + } + } + + if(additionalSleepTime > 0) + { + std::this_thread::sleep_for(std::chrono::microseconds(additionalSleepTime)); } // yield some time to the os based on command line option @@ -1661,6 +1662,9 @@ bool LLAppViewer::doFrame() LL_PROFILE_ZONE_NAMED_CATEGORY_APP("df resumeMainloopTimeout"); resumeMainloopTimeout(); } + + //swap(); + pingMainloopTimeout("Main:End"); } } diff --git a/indra/newview/lldrawpoolbump.cpp b/indra/newview/lldrawpoolbump.cpp index bf593bff07..c9470fe977 100644 --- a/indra/newview/lldrawpoolbump.cpp +++ b/indra/newview/lldrawpoolbump.cpp @@ -911,7 +911,8 @@ void LLBumpImageList::onSourceUpdated(LLViewerTexture* src, EBumpEffect bump_cod // generate normal map in empty texture { - sRenderTarget.bindTarget(); + sRenderTarget.bindTarget("", 1); + //sRenderTarget.clear(); LLGLDepthTest depth(GL_FALSE); LLGLDisable cull(GL_CULL_FACE); diff --git a/indra/newview/lldrawpoolwater.cpp b/indra/newview/lldrawpoolwater.cpp index 7d58511d41..424bb02ae7 100644 --- a/indra/newview/lldrawpoolwater.cpp +++ b/indra/newview/lldrawpoolwater.cpp @@ -119,7 +119,8 @@ void LLDrawPoolWater::beginPostDeferredPass(S32 pass) LLRenderTarget& depth_src = gPipeline.mRT->deferredScreen; LLRenderTarget& dst = gPipeline.mWaterDis; - dst.bindTarget(); + dst.bindTarget("", 1); + //dst.clear(); gCopyDepthProgram.bind(); S32 diff_map = gCopyDepthProgram.getTextureChannel(LLShaderMgr::DIFFUSE_MAP); diff --git a/indra/newview/llface.cpp b/indra/newview/llface.cpp index fb4db9a216..e4b81ba00a 100644 --- a/indra/newview/llface.cpp +++ b/indra/newview/llface.cpp @@ -648,7 +648,7 @@ void LLFace::renderOneWireframe(const LLColor4 &color, F32 fogCfx, bool wirefram LLGLEnable offset(GL_POLYGON_OFFSET_LINE); #endif glPolygonOffset(3.f, 3.f); - glLineWidth(5.f); + //glLineWidth(5.f); #if GL_VERSION_1_1 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); #endif diff --git a/indra/newview/llfasttimerview.cpp b/indra/newview/llfasttimerview.cpp index aa2578fec6..ac052d35e4 100644 --- a/indra/newview/llfasttimerview.cpp +++ b/indra/newview/llfasttimerview.cpp @@ -518,7 +518,8 @@ void LLFastTimerView::exportCharts(const std::string& base, const std::string& t //render charts gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); - buffer.bindTarget(); + buffer.bindTarget("", 1); + buffer.clear(); for (std::set<std::string>::iterator iter = chart_names.begin(); iter != chart_names.end(); ++iter) { @@ -1057,8 +1058,7 @@ void LLFastTimerView::drawLineGraph() //fatten highlighted timer if (mHoverID == idp) { - gGL.flush(); - glLineWidth(3); + LLRender2D::setLineWidth(3.0); } llassert(idp->getIndex() < sTimerColors.size()); @@ -1118,8 +1118,7 @@ void LLFastTimerView::drawLineGraph() if (mHoverID == idp) { - gGL.flush(); - glLineWidth(1); + LLRender2D::setLineWidth(1.f); } if (idp->getTreeNode().mCollapsed) diff --git a/indra/newview/llfloaterperformance.h b/indra/newview/llfloaterperformance.h index 6cca85a009..48e7f4913f 100644 --- a/indra/newview/llfloaterperformance.h +++ b/indra/newview/llfloaterperformance.h @@ -33,6 +33,7 @@ class LLCharacter; class LLCheckBoxCtrl; class LLNameListCtrl; class LLTextBox; +class LLSliderCtrl; class LLFloaterPerformance : public LLFloater { diff --git a/indra/newview/llfloaterpreference.cpp b/indra/newview/llfloaterpreference.cpp index 585032870e..334f9cb692 100644 --- a/indra/newview/llfloaterpreference.cpp +++ b/indra/newview/llfloaterpreference.cpp @@ -2359,6 +2359,7 @@ private: }; static LLPanelInjector<LLPanelPreferenceGraphics> t_pref_graph("panel_preference_graphics"); +static LLPanelInjector<LLPanelPreferenceGraphics3> t_pref_graph3("panel_preference_graphics3"); static LLPanelInjector<LLPanelPreferencePrivacy> t_pref_privacy("panel_preference_privacy"); bool LLPanelPreferenceGraphics::postBuild() @@ -2528,6 +2529,165 @@ void LLPanelPreferenceGraphics::setHardwareDefaults() resetDirtyChilds(); } +// LLPanelPreferenceGraphics3 (Visuals Effects) + +bool LLPanelPreferenceGraphics3::postBuild() +{ + getChild<LLButton>("MPBalancedButton")->setCommitCallback(boost::bind(&LLPanelPreferenceGraphics3::onMPRecommanded, this)); + return LLPanelPreference::postBuild(); +} + +void LLPanelPreferenceGraphics3::draw() +{ + LLPanelPreference::draw(); +} + +bool LLPanelPreferenceGraphics3::hasDirtyChilds() +{ + LLFloater* advanced = LLFloaterReg::findTypedInstance<LLFloater>("prefs_graphics_advanced"); + std::list<LLView*> view_stack; + view_stack.push_back(this); + if (advanced) + { + view_stack.push_back(advanced); + } + while(!view_stack.empty()) + { + // Process view on top of the stack + LLView* curview = view_stack.front(); + view_stack.pop_front(); + + LLUICtrl* ctrl = dynamic_cast<LLUICtrl*>(curview); + if (ctrl) + { + if (ctrl->isDirty()) + { + LLControlVariable* control = ctrl->getControlVariable(); + if (control) + { + std::string control_name = control->getName(); + if (!control_name.empty()) + { + return true; + } + } + } + } + // Push children onto the end of the work stack + for (child_list_t::const_iterator iter = curview->getChildList()->begin(); + iter != curview->getChildList()->end(); ++iter) + { + view_stack.push_back(*iter); + } + } + + return false; +} + +void LLPanelPreferenceGraphics3::resetDirtyChilds() +{ + LLFloater* advanced = LLFloaterReg::findTypedInstance<LLFloater>("prefs_graphics_advanced"); + std::list<LLView*> view_stack; + view_stack.push_back(this); + if (advanced) + { + view_stack.push_back(advanced); + } + while(!view_stack.empty()) + { + // Process view on top of the stack + LLView* curview = view_stack.front(); + view_stack.pop_front(); + + LLUICtrl* ctrl = dynamic_cast<LLUICtrl*>(curview); + if (ctrl) + { + ctrl->resetDirty(); + } + // Push children onto the end of the work stack + for (child_list_t::const_iterator iter = curview->getChildList()->begin(); + iter != curview->getChildList()->end(); ++iter) + { + view_stack.push_back(*iter); + } + } +} + +void LLPanelPreferenceGraphics3::cancel(const std::vector<std::string> settings_to_skip) +{ + LLPanelPreference::cancel(settings_to_skip); +} +void LLPanelPreferenceGraphics3::saveSettings() +{ + resetDirtyChilds(); + std::string preset_graphic_active = gSavedSettings.getString("PresetGraphicActive"); + if (preset_graphic_active.empty()) + { + LLFloaterPreference* instance = LLFloaterReg::findTypedInstance<LLFloaterPreference>("preferences"); + if (instance) + { + //don't restore previous preset after closing Preferences + instance->saveGraphicsPreset(preset_graphic_active); + } + } + LLPanelPreference::saveSettings(); +} + +void LLPanelPreferenceGraphics3::onMPRecommanded() +{ + //LL_WARNS() << "onClickMPRecommanded()" << LL_ENDL; + + // LOD + + gSavedSettings.setF32("RenderVolumeLODFactor", 3.5); + gSavedSettings.setF32("RenderAvatarPhysicsLODFactor", 1.0); + + // AA + + gSavedSettings.setU32("RenderFSAAType", 2); + gSavedSettings.setU32("RenderFSAASamples", 2); + + // Shadows + + gSavedSettings.setS32("RenderShadowDetail", 0); + gSavedSettings.setF32("MPRenderShadowMaxDist", 40.0); + gSavedSettings.setF32("RenderShadowResolutionScale", 2.0); + gSavedSettings.setF32("RenderShadowBlurSize", 0.2); + gSavedSettings.setBOOL("RenderDeferredSSAO", 0); + + // Bloom + + gSavedSettings.setU32("MPRenderBloom", 0); + gSavedSettings.setF32("MPBloomBlurRadius", 1.0); + gSavedSettings.setF32("MPBloomBlurRadiusAdd", 0.6); + gSavedSettings.setF32("MPBloomExtractBrightness", 0.1); + gSavedSettings.setF32("MPBloomStrength", 1.0); + + gSavedSettings.setF32("MPBloomExtractMetal", 0.4); + gSavedSettings.setF32("MPBloomExtractNonMetal", 0.0); + + // Probes + + gSavedSettings.setS32("RenderReflectionProbeDetail", 0); + gSavedSettings.setS32("RenderReflectionProbeLevel", 1); + gSavedSettings.setU32("RenderReflectionProbeCount", 32); + gSavedSettings.setU32("RenderReflectionProbeResolution", 128); + gSavedSettings.setF32("RenderReflectionProbeDrawDistance", 24.0); + gSavedSettings.setF32("RenderDefaultProbeUpdatePeriod", 20.0); + gSavedSettings.setF32("MPRenderProbeUpdatePeriod", 30.0); + gSavedSettings.setF32("MPRenderProbeSlowDown", 0.02); + + // Misc + + gSavedSettings.setBOOL("RenderDisableVintageMode", true); + gSavedSettings.setBOOL("RenderTransparentWater", true); + gSavedSettings.setBOOL("MPLowColorPrecision", true); + + gSavedSettings.setBOOL("RenderGLMultiThreadedTextures", false); + gSavedSettings.setBOOL("RenderAppleUseMultGL", false); + gSavedSettings.setBOOL("MPNoGLDebug", true); +} + //------------------------LLPanelPreferenceControls-------------------------------- static LLPanelInjector<LLPanelPreferenceControls> t_pref_contrls("panel_preference_controls"); diff --git a/indra/newview/llfloaterpreference.h b/indra/newview/llfloaterpreference.h index fa9c421a8f..2c357f0551 100644 --- a/indra/newview/llfloaterpreference.h +++ b/indra/newview/llfloaterpreference.h @@ -313,6 +313,26 @@ private: LOG_CLASS(LLPanelPreferenceGraphics); }; +class LLPanelPreferenceGraphics3 : public LLPanelPreference +{ +public: + bool postBuild(); + void draw(); + void cancel(const std::vector<std::string> settings_to_skip = {}); + void saveSettings(); + void resetDirtyChilds(); + void onMPRecommanded(); + +protected: + bool hasDirtyChilds(); + + +private: + + + LOG_CLASS(LLPanelPreferenceGraphics3); +}; + class LLPanelPreferenceControls : public LLPanelPreference, public LLKeyBindResponderInterface { LOG_CLASS(LLPanelPreferenceControls); diff --git a/indra/newview/llfloaterpreferencesgraphicsadvanced.cpp b/indra/newview/llfloaterpreferencesgraphicsadvanced.cpp index 94b95b21c2..a8a1e507a8 100644 --- a/indra/newview/llfloaterpreferencesgraphicsadvanced.cpp +++ b/indra/newview/llfloaterpreferencesgraphicsadvanced.cpp @@ -274,9 +274,7 @@ void LLFloaterPreferenceGraphicsAdvanced::setMaxNonImpostorsText(U32 value, LLTe void LLFloaterPreferenceGraphicsAdvanced::disableUnavailableSettings() { LLComboBox* ctrl_shadows = getChild<LLComboBox>("ShadowDetail"); - LLComboBox* ctrl_shadows_quality = getChild<LLComboBox>("MPShadowQuality"); LLTextBox* shadows_text = getChild<LLTextBox>("RenderShadowDetailText"); - LLTextBox* shadows_quality_text = getChild<LLTextBox>("RenderShadowQualityText"); LLCheckBoxCtrl* ctrl_ssao = getChild<LLCheckBoxCtrl>("UseSSAO"); LLCheckBoxCtrl* ctrl_dof = getChild<LLCheckBoxCtrl>("UseDoF"); LLSliderCtrl* sky = getChild<LLSliderCtrl>("SkyMeshDetail"); @@ -292,9 +290,7 @@ void LLFloaterPreferenceGraphicsAdvanced::disableUnavailableSettings() //deferred needs windlight, disable deferred ctrl_shadows->setEnabled(false); ctrl_shadows->setValue(0); - ctrl_shadows_quality->setEnabled(false); shadows_text->setEnabled(false); - shadows_quality_text->setEnabled(false); ctrl_ssao->setEnabled(false); ctrl_ssao->setValue(false); @@ -308,9 +304,7 @@ void LLFloaterPreferenceGraphicsAdvanced::disableUnavailableSettings() { ctrl_shadows->setEnabled(false); ctrl_shadows->setValue(0); - ctrl_shadows_quality->setEnabled(false); shadows_text->setEnabled(false); - shadows_quality_text->setEnabled(false); ctrl_ssao->setEnabled(false); ctrl_ssao->setValue(false); @@ -331,9 +325,7 @@ void LLFloaterPreferenceGraphicsAdvanced::disableUnavailableSettings() { ctrl_shadows->setEnabled(false); ctrl_shadows->setValue(0); - ctrl_shadows_quality->setEnabled(false); shadows_text->setEnabled(false); - shadows_quality_text->setEnabled(false); } // Vintage mode @@ -363,9 +355,7 @@ void LLFloaterPreferenceGraphicsAdvanced::refreshEnabledState() LLCheckBoxCtrl* ctrl_ssao = getChild<LLCheckBoxCtrl>("UseSSAO"); LLCheckBoxCtrl* ctrl_dof = getChild<LLCheckBoxCtrl>("UseDoF"); LLComboBox* ctrl_shadow = getChild<LLComboBox>("ShadowDetail"); - LLComboBox* ctrl_shadow_quality = getChild<LLComboBox>("MPShadowQuality"); LLTextBox* shadow_text = getChild<LLTextBox>("RenderShadowDetailText"); - LLTextBox* shadows_quality_text = getChild<LLTextBox>("RenderShadowQualityText"); // note, okay here to get from ctrl_deferred as it's twin, ctrl_deferred2 will alway match it enabled = enabled && LLFeatureManager::getInstance()->isFeatureAvailable("RenderDeferredSSAO");// && ctrl_deferred->get(); @@ -378,9 +368,7 @@ void LLFloaterPreferenceGraphicsAdvanced::refreshEnabledState() enabled = enabled && LLFeatureManager::getInstance()->isFeatureAvailable("RenderShadowDetail"); ctrl_shadow->setEnabled(enabled); - ctrl_shadow_quality->setEnabled(enabled); shadow_text->setEnabled(enabled); - shadows_quality_text->setEnabled(enabled); // Hardware settings diff --git a/indra/newview/llglsandbox.cpp b/indra/newview/llglsandbox.cpp index 112008172e..fffc520d9c 100644 --- a/indra/newview/llglsandbox.cpp +++ b/indra/newview/llglsandbox.cpp @@ -728,8 +728,7 @@ void LLViewerObjectList::renderObjectBeacons() S32 line_width = debug_beacon.mLineWidth; if (line_width != last_line_width) { - gGL.flush(); - glLineWidth( (F32)line_width ); + LLRender2D::setLineWidth(line_width); last_line_width = line_width; } @@ -758,8 +757,7 @@ void LLViewerObjectList::renderObjectBeacons() S32 line_width = debug_beacon.mLineWidth; if (line_width != last_line_width) { - gGL.flush(); - glLineWidth( (F32)line_width ); + LLRender2D::setLineWidth(line_width); last_line_width = line_width; } @@ -772,8 +770,7 @@ void LLViewerObjectList::renderObjectBeacons() gGL.end(); } - gGL.flush(); - glLineWidth(1.f); + LLRender2D::setLineWidth(1.f); for (std::vector<LLDebugBeacon>::iterator iter = mDebugBeacons.begin(); iter != mDebugBeacons.end(); ++iter) { @@ -808,7 +805,9 @@ void LLSky::renderSunMoonBeacons(const LLVector3& pos_agent, const LLVector3& di { pos_end.mV[i] = pos_agent.mV[i] + (50 * direction.mV[i]); } - glLineWidth((GLfloat)LLPipeline::DebugBeaconLineWidth); + + LLRender2D::setLineWidth((GLfloat)LLPipeline::DebugBeaconLineWidth); + gGL.begin(LLRender::LINES); color.mV[3] *= 0.5f; gGL.color4fv(color.mV); @@ -818,9 +817,7 @@ void LLSky::renderSunMoonBeacons(const LLVector3& pos_agent, const LLVector3& di gGL.vertex3fv(pos_end.mV); gGL.end(); - gGL.flush(); - glLineWidth(1.f); - + LLRender2D::setLineWidth(1.f); } //----------------------------------------------------------------------------- @@ -977,7 +974,7 @@ F32 gpu_benchmark() delete[] pixels; return -1.f; } - dest[i].bindTarget(); + dest[i].bindTarget("", 1); dest[i].clear(); dest[i].flush(); @@ -1039,7 +1036,7 @@ F32 gpu_benchmark() // run GPU timer benchmark { ShaderProfileHelper initProfile; - dest[0].bindTarget(); + dest[0].bindTarget("benchmark", 1); gBenchmarkProgram.bind(); for (S32 c = 0; c < samples; ++c) { diff --git a/indra/newview/llgltfmaterialpreviewmgr.cpp b/indra/newview/llgltfmaterialpreviewmgr.cpp index da1f1a466f..0b792efa1f 100644 --- a/indra/newview/llgltfmaterialpreviewmgr.cpp +++ b/indra/newview/llgltfmaterialpreviewmgr.cpp @@ -425,6 +425,8 @@ bool LLGLTFPreviewTexture::render() if (!mShouldRender) { return false; } + LL_WARNS() << "LLGLTFPreviewTexture:render()" << LL_ENDL; + glClearColor(0, 0, 0, 0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); @@ -520,19 +522,41 @@ bool LLGLTFPreviewTexture::render() // *HACK: Hide mExposureMap from generateExposure gPipeline.mExposureMap.swapFBORefs(gPipeline.mLastExposure); + //bool hdr = gPipeline.has_hdr(); + bool hdr = true; + + if (hdr) + { gPipeline.copyScreenSpaceReflections(&screen, &gPipeline.mSceneMap); gPipeline.generateLuminance(&screen, &gPipeline.mLuminanceMap); gPipeline.generateExposure(&gPipeline.mLuminanceMap, &gPipeline.mExposureMap, /*use_history = */ false); - gPipeline.gammaCorrect(&screen, &gPipeline.mPostMap); + } + + U16 activeRT = 0; + gPipeline.gammaCorrect(&screen, &gPipeline.mPostMaps[activeRT]); + LLVertexBuffer::unbind(); - gPipeline.generateGlow(&gPipeline.mPostMap); - gPipeline.combineGlow(&gPipeline.mPostMap, &screen); - gPipeline.renderDoF(&screen, &gPipeline.mPostMap); - gPipeline.applyFXAA(&gPipeline.mPostMap, &screen); + + gPipeline.generateGlow(&gPipeline.mPostMaps[activeRT]); + gPipeline.combineGlow(&gPipeline.mPostMaps[activeRT], &gPipeline.mPostMaps[1-activeRT]); + activeRT = 1-activeRT; + + if(gPipeline.renderDoF(&gPipeline.mPostMaps[activeRT], &gPipeline.mPostMaps[1-activeRT])) + { + activeRT = 1-activeRT; + } + + if(gPipeline.applyFXAA(&gPipeline.mPostMaps[activeRT], &gPipeline.mPostMaps[1-activeRT])) + { + activeRT = 1-activeRT; + } // *HACK: Restore mExposureMap (it will be consumed by generateExposure next frame) gPipeline.mExposureMap.swapFBORefs(gPipeline.mLastExposure); + gPipeline.copyRenderTarget(&gPipeline.mPostMaps[activeRT], &screen); + + // Final render gDeferredPostNoDoFProgram.bind(); diff --git a/indra/newview/llmodelpreview.cpp b/indra/newview/llmodelpreview.cpp index 044d08faf1..01d4ccecdd 100644 --- a/indra/newview/llmodelpreview.cpp +++ b/indra/newview/llmodelpreview.cpp @@ -3717,7 +3717,6 @@ bool LLModelPreview::render() buffer->drawRange(LLRender::TRIANGLES, 0, buffer->getNumVerts() - 1, buffer->getNumIndices(), 0); gGL.diffuseColor4fv(PREVIEW_PSYH_EDGE_COL.mV); - glLineWidth(PREVIEW_PSYH_EDGE_WIDTH); #if GL_VERSION_1_1 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); #endif @@ -3726,7 +3725,6 @@ bool LLModelPreview::render() #if GL_VERSION_1_1 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); #endif - glLineWidth(1.f); buffer->unmapBuffer(); } @@ -3738,7 +3736,6 @@ bool LLModelPreview::render() // only do this if mDegenerate was set in the preceding mesh checks [Check this if the ordering ever breaks] if (mHasDegenerate) { - glLineWidth(PREVIEW_DEG_EDGE_WIDTH); #if GL_VERSION_1_1 glPointSize(PREVIEW_DEG_POINT_SIZE); #endif @@ -3810,7 +3807,7 @@ bool LLModelPreview::render() gGL.popMatrix(); } - glLineWidth(1.f); + //glLineWidth(1.f); #if GL_VERSION_1_1 glPointSize(1.f); #endif @@ -3934,7 +3931,7 @@ bool LLModelPreview::render() { gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); gGL.diffuseColor4fv(PREVIEW_EDGE_COL.mV); - glLineWidth(PREVIEW_EDGE_WIDTH); + //glLineWidth(PREVIEW_EDGE_WIDTH); #if GL_VERSION_1_1 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); #endif @@ -3942,7 +3939,6 @@ bool LLModelPreview::render() #if GL_VERSION_1_1 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); #endif - glLineWidth(1.f); } } } diff --git a/indra/newview/llreflectionmap.h b/indra/newview/llreflectionmap.h index a818793550..9d960f5f9c 100644 --- a/indra/newview/llreflectionmap.h +++ b/indra/newview/llreflectionmap.h @@ -103,6 +103,9 @@ public: // last time this probe was bound for rendering F32 mLastBindTime = 0.f; + // Next update time + F32 mNextUpdateTime = 0.f; + // cube map used to sample this environment map LLPointer<LLCubeMapArray> mCubeArray; S32 mCubeIndex = -1; // index into cube map array or -1 if not currently stored in cube map array @@ -110,6 +113,9 @@ public: // probe has had at least one full update and is ready to render bool mComplete = false; + // number of tiees the probe has been completed + U32 mCompletedCount = 0; + // fade in parameter for this probe F32 mFadeIn = 0.f; diff --git a/indra/newview/llreflectionmapmanager.cpp b/indra/newview/llreflectionmapmanager.cpp index c1815ad57e..d247d3260e 100644 --- a/indra/newview/llreflectionmapmanager.cpp +++ b/indra/newview/llreflectionmapmanager.cpp @@ -54,6 +54,7 @@ #endif LLPointer<LLImageGL> gEXRImage; +//LLTrace::BlockTimerStatHandle FTM_RENDER_RADIANCE("Render Radiance"); void load_exr(const std::string& filename) { @@ -226,6 +227,25 @@ void LLReflectionMapManager::update() static LLCachedControl<S32> sLevel(gSavedSettings, "RenderReflectionProbeLevel", 3); static LLCachedControl<U32> sReflectionProbeCount(gSavedSettings, "RenderReflectionProbeCount", 256U); static LLCachedControl<S32> sProbeDynamicAllocation(gSavedSettings, "RenderReflectionProbeDynamicAllocation", -1); + + static LLCachedControl<F32> sProbeUpdateSlowDown(gSavedSettings, "MPRenderProbeSlowDown", 0.f); + + bool realtime = sDetail >= (S32)LLReflectionMapManager::DetailLevel::REALTIME; + + if(sProbeUpdateSlowDown > 0.0) + { + if ( mLastUpdate > 0.f ) + { + F32 elapsed = gFrameTimeSeconds - mLastUpdate; + if (elapsed > 0.0 && elapsed < sProbeUpdateSlowDown) + { + return; + } + } + } + + mLastUpdate = gFrameTimeSeconds; + mResetFade = llmin((F32)(mResetFade + gFrameIntervalSeconds * 2.f), 1.f); { @@ -275,9 +295,16 @@ void LLReflectionMapManager::update() static LLCachedControl<bool> render_hdr(gSavedSettings, "RenderHDREnabled", true); + U32 color_fmt = render_hdr ? GL_R11F_G11F_B10F : GL_RGB8; + + static LLCachedControl<bool> MPLowColorPrecision(gSavedSettings, "MPLowColorPrecision", 0); + if(MPLowColorPrecision) + { + color_fmt = GL_RGB8; + } + if (!mRenderTarget.isComplete()) { - U32 color_fmt = render_hdr ? GL_R11F_G11F_B10F : GL_RGB8; U32 targetRes = mProbeResolution * 4; // super sample mRenderTarget.allocate(targetRes, targetRes, color_fmt, true); } @@ -290,7 +317,7 @@ void LLReflectionMapManager::update() mMipChain.resize(count); for (U32 i = 0; i < count; ++i) { - mMipChain[i].allocate(res, res, render_hdr ? GL_R11F_G11F_B10F : GL_RGB8); + mMipChain[i].allocate(res, res, color_fmt); res /= 2; } } @@ -328,8 +355,6 @@ void LLReflectionMapManager::update() bool did_update = false; - bool realtime = sDetail >= (S32)LLReflectionMapManager::DetailLevel::REALTIME; - LLReflectionMap* closestDynamic = nullptr; LLReflectionMap* oldestProbe = nullptr; @@ -362,6 +387,9 @@ void LLReflectionMapManager::update() probe->mCubeArray = nullptr; probe->mCubeIndex = -1; probe->mComplete = false; + probe->mCompletedCount = 0; + probe->mLastUpdateTime = 0.0; + probe->mNextUpdateTime = 0.0; probe->mFadeIn = 0; } } @@ -385,6 +413,9 @@ void LLReflectionMapManager::update() mResetFade = llmin((F32)(mResetFade + gFrameIntervalSeconds * 2.f), 1.f); + static LLCachedControl<F32> sDefaultUpdatePeriod(gSavedSettings, "RenderDefaultProbeUpdatePeriod", 2.f); + static LLCachedControl<F32> sMPUpdatePeriod(gSavedSettings, "MPRenderProbeUpdatePeriod", 2.f); + for (unsigned int i = 0; i < mProbes.size(); ++i) { LLReflectionMap* probe = mProbes[i]; @@ -401,6 +432,8 @@ void LLReflectionMapManager::update() continue; } + // Calculating distance + LLVector4a d; if (probe != mDefaultProbe) @@ -412,13 +445,14 @@ void LLReflectionMapManager::update() d.setSub(camera_pos, probe->mOrigin); probe->mDistance = d.getLength3().getF32() - probe->mRadius; } - else if (probe->mComplete) + else if (mDefaultProbe->mComplete) { // make default probe have a distance of 64m for the purposes of prioritization (if it's already been generated once) probe->mDistance = 64.f; } else { + probe->mNextUpdateTime = 0.f; probe->mDistance = -4096.f; //boost priority of default probe when it's not complete } @@ -427,8 +461,13 @@ void LLReflectionMapManager::update() probe->autoAdjustOrigin(); probe->mFadeIn = llmin((F32) (probe->mFadeIn + gFrameIntervalSeconds), 1.f); } + + // Guess oldest probe + if (probe->mOccluded && probe->mComplete) { + // occluded probe + if (oldestOccluded == nullptr) { oldestOccluded = probe; @@ -465,6 +504,8 @@ void LLReflectionMapManager::update() } } + // realtime + if (realtime && closestDynamic != nullptr) { LL_PROFILE_ZONE_NAMED_CATEGORY_DISPLAY("rmmu - realtime"); @@ -480,16 +521,17 @@ void LLReflectionMapManager::update() { updateProbeFace(closestDynamic, i); } + if(mRealtimeRadiancePass) updateProbeRadiance(closestDynamic); + else updateProbeIrradiance(closestDynamic); mRealtimeRadiancePass = !mRealtimeRadiancePass; // restore "isRadiancePass" mRadiancePass = radiance_pass; } - static LLCachedControl<F32> sUpdatePeriod(gSavedSettings, "RenderDefaultProbeUpdatePeriod", 2.f); - if ((gFrameTimeSeconds - mDefaultProbe->mLastUpdateTime) < sUpdatePeriod) + if ((gFrameTimeSeconds - mDefaultProbe->mLastUpdateTime) < sDefaultUpdatePeriod) { - if (sLevel == 0) + if (sLevel == 0 && mDefaultProbe->mComplete) { // when probes are disabled don't update the default probe more often than the prescribed update period oldestProbe = nullptr; } @@ -505,11 +547,33 @@ void LLReflectionMapManager::update() LLReflectionMap* probe = oldestProbe; llassert(probe->mCubeIndex != -1); + bool shouldUpdate = true; + + if( probe->mNextUpdateTime > 0.f && gFrameTimeSeconds < probe->mNextUpdateTime) + { + shouldUpdate = false; + } + + if(shouldUpdate) + { probe->autoAdjustOrigin(); sUpdateCount++; mUpdatingProbe = probe; + + if(probe->mCompletedCount < 2) + { + LL_WARNS() << "we program a short delay for this probe" << LL_ENDL; + probe->mNextUpdateTime = gFrameTimeSeconds + fmax( ((F32)sMPUpdatePeriod / 2.0), 0.25); + } + else + { + LL_WARNS() << "we program a long delay for this probe" << LL_ENDL; + probe->mNextUpdateTime = gFrameTimeSeconds + fmax( (F32)sMPUpdatePeriod, 0.25); + } + doProbeUpdate(); + } } if (oldestOccluded) @@ -717,11 +781,32 @@ void LLReflectionMapManager::doProbeUpdate() LL_PROFILE_ZONE_SCOPED_CATEGORY_DISPLAY; llassert(mUpdatingProbe != nullptr); - updateProbeFace(mUpdatingProbe, mUpdatingFace); + static LLCachedControl<bool> mp_progressive(gSavedSettings, "MPRenderProbeProgressive", false); + + if(mUpdatingFace < 6) + { + updateProbeFace(mUpdatingProbe, mUpdatingFace, mp_progressive); + } + else if(mp_progressive) + { + if(isRadiancePass()) + { + //updateProbeRadiance(mUpdatingProbe); + } + else updateProbeIrradiance(mUpdatingProbe); + } + else + { + if(isRadiancePass()) + { + updateProbeRadiance(mUpdatingProbe); + } + else updateProbeIrradiance(mUpdatingProbe); + } bool debug_updates = gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_PROBE_UPDATES) && mUpdatingProbe->mViewerObject; - if (++mUpdatingFace == 6) + if (mUpdatingFace == 6) { if (debug_updates) { @@ -732,17 +817,24 @@ void LLReflectionMapManager::doProbeUpdate() if (isRadiancePass()) { mUpdatingProbe->mComplete = true; + mUpdatingProbe->mCompletedCount++; mUpdatingProbe = nullptr; mRadiancePass = false; + LL_WARNS() << "probe updated !" << LL_ENDL; } else { mRadiancePass = true; } } - else if (debug_updates) + else { + ++mUpdatingFace; + + if (debug_updates) + { mUpdatingProbe->mViewerObject->setDebugText(llformat("%.1f", (F32)gFrameTimeSeconds), LLColor4(1, 1, 0, 1)); + } } } @@ -754,7 +846,7 @@ void LLReflectionMapManager::doProbeUpdate() // The next six passes render the scene with both radiance and irradiance into the same scratch space cube map and generate a simple mip chain. // At the end of these passes, a radiance map is generated for this probe and placed into the radiance cube map array at the index for this probe. // In effect this simulates single-bounce lighting. -void LLReflectionMapManager::updateProbeFace(LLReflectionMap* probe, U32 face) +void LLReflectionMapManager::updateProbeFace(LLReflectionMap* probe, U32 face, bool progressive) { // hacky hot-swap of camera specific render targets gPipeline.mRT = &gPipeline.mAuxillaryRT; @@ -795,7 +887,7 @@ void LLReflectionMapManager::updateProbeFace(LLReflectionMap* probe, U32 face) sourceIdx += 1; } - gGL.setColorMask(true, true); + gGL.setColorMask(true, false); LLGLDepthTest depth(GL_FALSE, GL_FALSE); LLGLDisable cull(GL_CULL_FACE); LLGLDisable blend(GL_BLEND); @@ -829,7 +921,8 @@ void LLReflectionMapManager::updateProbeFace(LLReflectionMap* probe, U32 face) // horizontal gGaussianProgram.uniform2f(direction, 1.f, 0.f); gGL.getTexUnit(diffuseChannel)->bind(screen_rt); - mRenderTarget.bindTarget(); + mRenderTarget.bindTarget("", 1); + mRenderTarget.clear(0); gPipeline.mScreenTriangleVB->setBuffer(); gPipeline.mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); mRenderTarget.flush(); @@ -837,7 +930,8 @@ void LLReflectionMapManager::updateProbeFace(LLReflectionMap* probe, U32 face) // vertical gGaussianProgram.uniform2f(direction, 0.f, 1.f); gGL.getTexUnit(diffuseChannel)->bind(&mRenderTarget); - screen_rt->bindTarget(); + screen_rt->bindTarget("", 1); + screen_rt->clear(0); gPipeline.mScreenTriangleVB->setBuffer(); gPipeline.mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); screen_rt->flush(); @@ -852,7 +946,10 @@ void LLReflectionMapManager::updateProbeFace(LLReflectionMap* probe, U32 face) for (int i = 0; i < mMipChain.size(); ++i) { LL_PROFILE_GPU_ZONE("probe mip"); - mMipChain[i].bindTarget(); + + mMipChain[i].bindTarget("probe face ", 0); + mMipChain[i].clear(0); + if (i == 0) { gGL.getTexUnit(diffuseChannel)->bind(screen_rt); @@ -897,16 +994,127 @@ void LLReflectionMapManager::updateProbeFace(LLReflectionMap* probe, U32 face) gReflectionMipProgram.unbind(); } - if (face == 5) + if(progressive) { - mMipChain[0].bindTarget(); - static LLStaticHashedString sSourceIdx("sourceIdx"); + if(isRadiancePass()) updateProbeRadianceOnFace(probe, face, sourceIdx); + } - if (isRadiancePass()) + // if(isRadiancePass()) updateProbeRadianceOnFace(probe, face, sourceIdx); + // else updateProbeIrradianceOnFace(probe, face, sourceIdx); +} + +// ===================== IRRADIANCE ================================ + +void LLReflectionMapManager::updateProbeIrradiance(LLReflectionMap* probe) +{ + LL_PROFILE_GPU_ZONE("probe irradiance gen"); + + static LLStaticHashedString sMipLevel("mipLevel"); + static LLStaticHashedString sRoughness("roughness"); + static LLStaticHashedString sWidth("u_width"); + + S32 sourceIdx = mReflectionProbeCount; + + if (probe != mUpdatingProbe) + { // this is the "realtime" probe that's updating every frame, use the secondary scratch space channel + sourceIdx += 1; + } + + gGL.setColorMask(true, false); + LLGLDepthTest depth(GL_FALSE, GL_FALSE); + LLGLDisable cull(GL_CULL_FACE); + LLGLDisable blend(GL_BLEND); + + static LLStaticHashedString sSourceIdx("sourceIdx"); + + LL_WARNS() << "IRRADIANCE 1" << LL_ENDL; + + mMipChain[0].bindTarget("irradiance", 0); + mMipChain[0].clear(0); + + gIrradianceGenProgram.bind(); + +#if GL_VERSION_4_0 + S32 channel = gIrradianceGenProgram.enableTexture(LLShaderMgr::REFLECTION_PROBES, LLTexUnit::TT_CUBE_MAP_ARRAY); + mTexture->bind(channel); +#endif + + gIrradianceGenProgram.uniform1i(sSourceIdx, sourceIdx); + gIrradianceGenProgram.uniform1f(LLShaderMgr::REFLECTION_PROBE_MAX_LOD, mMaxProbeLOD); + + mVertexBuffer->setBuffer(); + + int start_mip = 0; + // find the mip target to start with based on irradiance map resolution + for (start_mip = 0; start_mip < mMipChain.size(); ++start_mip) + { + if (mMipChain[start_mip].getWidth() == LL_IRRADIANCE_MAP_RESOLUTION) { - //generate radiance map (even if this is not the irradiance map, we need the mip chain for the irradiance map) - gRadianceGenProgram.bind(); - mVertexBuffer->setBuffer(); + break; + } + } + + int i = start_mip; + + //LL_PROFILE_GPU_ZONE("probe irradiance gen"); + + glViewport(0, 0, mMipChain[i].getWidth(), mMipChain[i].getHeight()); + + for (int cf = 0; cf < 6; ++cf) + { + LLCoordFrame frame; + frame.lookAt(LLVector3(0, 0, 0), LLCubeMapArray::sClipToCubeLookVecs[cf], LLCubeMapArray::sClipToCubeUpVecs[cf]); + + F32 mat[16]; + frame.getOpenGLRotation(mat); + gGL.loadMatrix(mat); + + mVertexBuffer->drawArrays(gGL.TRIANGLE_STRIP, 0, 4); + + S32 res = mMipChain[i].getWidth(); +#if GL_VERSION_4_0 + mIrradianceMaps->bind(channel); + glCopyTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, i - start_mip, 0, 0, probe->mCubeIndex * 6 + cf, 0, 0, res, res); + mTexture->bind(channel); +#endif + //mMipChain[0].clear(0); + } + + mMipChain[0].flush(); + gIrradianceGenProgram.unbind(); +} + +// ==================== RADIANCE =========================== + +void LLReflectionMapManager::updateProbeRadiance(LLReflectionMap* probe) +{ + LL_PROFILE_GPU_ZONE("probe radiance gen"); + static LLStaticHashedString sMipLevel("mipLevel"); + static LLStaticHashedString sRoughness("roughness"); + static LLStaticHashedString sWidth("u_width"); + + S32 sourceIdx = mReflectionProbeCount; + + if (probe != mUpdatingProbe) + { // this is the "realtime" probe that's updating every frame, use the secondary scratch space channel + sourceIdx += 1; + } + + gGL.setColorMask(true, false); + LLGLDepthTest depth(GL_FALSE, GL_FALSE); + LLGLDisable cull(GL_CULL_FACE); + LLGLDisable blend(GL_BLEND); + + static LLStaticHashedString sSourceIdx("sourceIdx"); + + LL_WARNS() << "RADIANCE" << LL_ENDL; + //LL_RECORD_BLOCK_TIME(FTM_RENDER_RADIANCE); + + mMipChain[0].bindTarget("radiance", 0); + mMipChain[0].clear(); + + gRadianceGenProgram.bind(); + mVertexBuffer->setBuffer(); #if GL_VERSION_4_0 S32 channel = gRadianceGenProgram.enableTexture(LLShaderMgr::REFLECTION_PROBES, LLTexUnit::TT_CUBE_MAP_ARRAY); @@ -915,22 +1123,19 @@ void LLReflectionMapManager::updateProbeFace(LLReflectionMap* probe, U32 face) gRadianceGenProgram.uniform1i(sSourceIdx, sourceIdx); gRadianceGenProgram.uniform1f(LLShaderMgr::REFLECTION_PROBE_MAX_LOD, mMaxProbeLOD); gRadianceGenProgram.uniform1f(LLShaderMgr::REFLECTION_PROBE_STRENGTH, 1.f); + gRadianceGenProgram.uniform1i(sWidth, mProbeResolution); U32 res = mMipChain[0].getWidth(); for (int i = 0; i < mMipChain.size(); ++i) { - LL_PROFILE_GPU_ZONE("probe radiance gen"); - static LLStaticHashedString sMipLevel("mipLevel"); - static LLStaticHashedString sRoughness("roughness"); - static LLStaticHashedString sWidth("u_width"); + glViewport(0, 0, res, res); - gRadianceGenProgram.uniform1f(sRoughness, (F32)i / (F32)(mMipChain.size() - 1)); gRadianceGenProgram.uniform1f(sMipLevel, (GLfloat)i); - gRadianceGenProgram.uniform1i(sWidth, mProbeResolution); + gRadianceGenProgram.uniform1f(sRoughness, (F32)i / (F32)(mMipChain.size() - 1)); for (int cf = 0; cf < 6; ++cf) - { // for each cube face + { LLCoordFrame frame; frame.lookAt(LLVector3(0, 0, 0), LLCubeMapArray::sClipToCubeLookVecs[cf], LLCubeMapArray::sClipToCubeUpVecs[cf]); @@ -943,21 +1148,44 @@ void LLReflectionMapManager::updateProbeFace(LLReflectionMap* probe, U32 face) #if GL_VERSION_4_0 glCopyTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, i, 0, 0, probe->mCubeIndex * 6 + cf, 0, 0, res, res); #endif + LOG_GLERROR("glCopyTexSubImage3D"); } if (i != mMipChain.size() - 1) { res /= 2; - glViewport(0, 0, res, res); } - } + } gRadianceGenProgram.unbind(); - } - else - { - //generate irradiance map + mMipChain[0].flush(); + //mTexture->unbind(); +} + +// ================== PER FACE ======================= + +void LLReflectionMapManager::updateProbeIrradianceOnFace(LLReflectionMap* probe, U32 face, S32 sourceIdx) +{ + LL_PROFILE_GPU_ZONE("probe irradiance gen"); + + static LLStaticHashedString sMipLevel("mipLevel"); + static LLStaticHashedString sRoughness("roughness"); + static LLStaticHashedString sWidth("u_width"); + + gGL.setColorMask(true, false); + LLGLDepthTest depth(GL_FALSE, GL_FALSE); + LLGLDisable cull(GL_CULL_FACE); + LLGLDisable blend(GL_BLEND); + + static LLStaticHashedString sSourceIdx("sourceIdx"); + + //LL_WARNS() << "IRRADIANCE" << LL_ENDL; + + mMipChain[0].bindTarget("irradiance", 0); + //mMipChain[0].clear(); + gIrradianceGenProgram.bind(); + #if GL_VERSION_4_0 S32 channel = gIrradianceGenProgram.enableTexture(LLShaderMgr::REFLECTION_PROBES, LLTexUnit::TT_CUBE_MAP_ARRAY); mTexture->bind(channel); @@ -977,13 +1205,11 @@ void LLReflectionMapManager::updateProbeFace(LLReflectionMap* probe, U32 face) } } - //for (int i = start_mip; i < mMipChain.size(); ++i) - { int i = start_mip; - LL_PROFILE_GPU_ZONE("probe irradiance gen"); glViewport(0, 0, mMipChain[i].getWidth(), mMipChain[i].getHeight()); - for (int cf = 0; cf < 6; ++cf) - { // for each cube face + + int cf = face; + { LLCoordFrame frame; frame.lookAt(LLVector3(0, 0, 0), LLCubeMapArray::sClipToCubeLookVecs[cf], LLCubeMapArray::sClipToCubeUpVecs[cf]); @@ -993,20 +1219,81 @@ void LLReflectionMapManager::updateProbeFace(LLReflectionMap* probe, U32 face) mVertexBuffer->drawArrays(gGL.TRIANGLE_STRIP, 0, 4); - S32 res = mMipChain[i].getWidth(); #if GL_VERSION_4_0 + S32 res = mMipChain[i].getWidth(); mIrradianceMaps->bind(channel); glCopyTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, i - start_mip, 0, 0, probe->mCubeIndex * 6 + cf, 0, 0, res, res); - mTexture->bind(channel); #endif - } } - } mMipChain[0].flush(); gIrradianceGenProgram.unbind(); + mTexture->unbind(); +} + +void LLReflectionMapManager::updateProbeRadianceOnFace(LLReflectionMap* probe, U32 face, S32 sourceIdx) +{ + LL_PROFILE_GPU_ZONE("probe radiance gen"); + static LLStaticHashedString sMipLevel("mipLevel"); + static LLStaticHashedString sRoughness("roughness"); + static LLStaticHashedString sWidth("u_width"); + + gGL.setColorMask(true, false); + LLGLDepthTest depth(GL_FALSE, GL_FALSE); + LLGLDisable cull(GL_CULL_FACE); + LLGLDisable blend(GL_BLEND); + + static LLStaticHashedString sSourceIdx("sourceIdx"); + + mMipChain[0].bindTarget("radiance", 0); + mMipChain[0].clear(0); + + gRadianceGenProgram.bind(); + mVertexBuffer->setBuffer(); + + S32 channel = gRadianceGenProgram.enableTexture(LLShaderMgr::REFLECTION_PROBES, LLTexUnit::TT_CUBE_MAP_ARRAY); + mTexture->bind(channel); + + gRadianceGenProgram.uniform1i(sSourceIdx, sourceIdx); + gRadianceGenProgram.uniform1f(LLShaderMgr::REFLECTION_PROBE_MAX_LOD, mMaxProbeLOD); + gRadianceGenProgram.uniform1f(LLShaderMgr::REFLECTION_PROBE_STRENGTH, 1.f); + gRadianceGenProgram.uniform1i(sWidth, mProbeResolution); + + U32 res = mMipChain[0].getWidth(); + + for (int i = 0; i < mMipChain.size(); ++i) + { + glViewport(0, 0, res, res); + + gRadianceGenProgram.uniform1f(sMipLevel, (GLfloat)i); + gRadianceGenProgram.uniform1f(sRoughness, (F32)i / (F32)(mMipChain.size() - 1)); + + int cf = face; + { + LLCoordFrame frame; + frame.lookAt(LLVector3(0, 0, 0), LLCubeMapArray::sClipToCubeLookVecs[cf], LLCubeMapArray::sClipToCubeUpVecs[cf]); + + F32 mat[16]; + frame.getOpenGLRotation(mat); + gGL.loadMatrix(mat); + + mVertexBuffer->drawArrays(gGL.TRIANGLE_STRIP, 0, 4); + + glCopyTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, i, 0, 0, probe->mCubeIndex * 6 + cf, 0, 0, res, res); + LOG_GLERROR("glCopyTexSubImage3D"); + //mMipChain[0].clear(0); + } + + if (i != mMipChain.size() - 1) + { + res /= 2; + } } + + gRadianceGenProgram.unbind(); + mMipChain[0].flush(); + mTexture->unbind(); } void LLReflectionMapManager::reset() @@ -1426,8 +1713,13 @@ void LLReflectionMapManager::initReflectionMaps() { static LLCachedControl<U32> ref_probe_res(gSavedSettings, "RenderReflectionProbeResolution", 128U); U32 probe_resolution = nhpo2(llclamp(ref_probe_res(), (U32)64, (U32)512)); - if (mTexture.isNull() || mReflectionProbeCount != mDynamicProbeCount || mProbeResolution != probe_resolution || mReset) + + bool shouldInit = mTexture.isNull() || mReflectionProbeCount != mDynamicProbeCount || mProbeResolution != probe_resolution || mReset; + + if (shouldInit) { + //LL_WARNS() << "====== initReflectionMaps() =======" << LL_ENDL; + if(mProbeResolution != probe_resolution) { mRenderTarget.release(); @@ -1444,6 +1736,8 @@ void LLReflectionMapManager::initReflectionMaps() mTexture->getWidth() != mProbeResolution || mReflectionProbeCount + 2 != mTexture->getCount()) { + static LLCachedControl<bool> render_hdr(gSavedSettings, "RenderHDREnabled", true); + if (mTexture) { mTexture = new LLCubeMapArray(*mTexture, mProbeResolution, mReflectionProbeCount + 2); @@ -1454,8 +1748,6 @@ void LLReflectionMapManager::initReflectionMaps() { mTexture = new LLCubeMapArray(); - static LLCachedControl<bool> render_hdr(gSavedSettings, "RenderHDREnabled", true); - // store mReflectionProbeCount+2 cube maps, final two cube maps are used for render target and radiance map generation // source) mTexture->allocate(mProbeResolution, 3, mReflectionProbeCount + 2, true, render_hdr); @@ -1477,7 +1769,9 @@ void LLReflectionMapManager::initReflectionMaps() for (auto& probe : mProbes) { probe->mLastUpdateTime = 0.f; + probe->mNextUpdateTime = 0.f; probe->mComplete = false; + probe->mCompletedCount = 0; probe->mProbeIndex = -1; probe->mCubeArray = nullptr; probe->mCubeIndex = -1; @@ -1503,8 +1797,13 @@ void LLReflectionMapManager::initReflectionMaps() mDefaultProbe->mRadius = 4096.f; mDefaultProbe->mProbeIndex = 0; mDefaultProbe->mComplete = default_complete; + mDefaultProbe->mCompletedCount = 0; + mDefaultProbe->mLastUpdateTime = 0.f; + mDefaultProbe->mNextUpdateTime = 0.f; touch_default_probe(mDefaultProbe); + + LL_WARNS() << "====== END initReflectionMaps() =======" << LL_ENDL; } if (mVertexBuffer.isNull()) diff --git a/indra/newview/llreflectionmapmanager.h b/indra/newview/llreflectionmapmanager.h index 0719c28134..b874bb1c17 100644 --- a/indra/newview/llreflectionmapmanager.h +++ b/indra/newview/llreflectionmapmanager.h @@ -210,7 +210,14 @@ private: void doProbeUpdate(); // update the specified face of the specified probe - void updateProbeFace(LLReflectionMap* probe, U32 face); + void updateProbeFace(LLReflectionMap* probe, U32 face, bool progressive = false); + + void updateProbeIrradiance(LLReflectionMap* probe); + void updateProbeRadiance(LLReflectionMap* probe); + + void updateProbeIrradianceOnFace(LLReflectionMap* probe, U32 face, S32 sourceIdx); + void updateProbeRadianceOnFace(LLReflectionMap* probe, U32 face, S32 sourceIdx); + // list of active reflection maps std::vector<LLPointer<LLReflectionMap> > mProbes; @@ -267,6 +274,8 @@ private: bool mPaused = false; F32 mResumeTime = 0.f; + F32 mLastUpdate = 0.f; + ReflectionProbeData mProbeData; }; diff --git a/indra/newview/llselectmgr.cpp b/indra/newview/llselectmgr.cpp index 8286054787..95474a8aaa 100644 --- a/indra/newview/llselectmgr.cpp +++ b/indra/newview/llselectmgr.cpp @@ -6531,7 +6531,7 @@ void LLSelectMgr::renderSilhouettes(bool for_hud) gGL.popMatrix(); gGL.popMatrix(); - glLineWidth(1.f); + //glLineWidth(1.f); #if GL_VERSION_1_1 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); #endif diff --git a/indra/newview/llsnapshotlivepreview.cpp b/indra/newview/llsnapshotlivepreview.cpp index 68b4ab381a..445132632b 100644 --- a/indra/newview/llsnapshotlivepreview.cpp +++ b/indra/newview/llsnapshotlivepreview.cpp @@ -238,11 +238,11 @@ void LLSnapshotLivePreview::drawPreviewRect(S32 offset_x, S32 offset_y, LLColor4 { F32 line_width ; glGetFloatv(GL_LINE_WIDTH, &line_width) ; - glLineWidth(2.0f * line_width) ; + //glLineWidth(2.0f * line_width) ; LLColor4 color(0.0f, 0.0f, 0.0f, 1.0f) ; gl_rect_2d( mPreviewRect.mLeft + offset_x, mPreviewRect.mTop + offset_y, mPreviewRect.mRight + offset_x, mPreviewRect.mBottom + offset_y, color, false ) ; - glLineWidth(line_width) ; + //glLineWidth(line_width) ; //draw four alpha rectangles to cover areas outside of the snapshot image if(!mKeepAspectRatio) diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp index a90ff73578..a147cb4657 100644 --- a/indra/newview/llspatialpartition.cpp +++ b/indra/newview/llspatialpartition.cpp @@ -1661,12 +1661,12 @@ void renderOctree(LLSpatialGroup* group) gGL.diffuseColor4f(1,0,0,group->mBuilt); gGL.flush(); - glLineWidth(5.f); + //glLineWidth(5.f); const LLVector4a* bounds = group->getObjectBounds(); drawBoxOutline(bounds[0], bounds[1]); - gGL.flush(); - glLineWidth(1.f); + //gGL.flush(); + //glLineWidth(1.f); gGL.flush(); const LLVOAvatar* lastAvatar = nullptr; @@ -1978,12 +1978,11 @@ void renderBoundingBox(LLDrawable* drawable, bool set_color = true) if (vobj && vobj->onActiveList()) { gGL.flush(); - glLineWidth(llmax(4.f*sinf(gFrameTimeSeconds*2.f)+1.f, 1.f)); - //glLineWidth(4.f*(sinf(gFrameTimeSeconds*2.f)*0.25f+0.75f)); - stop_glerror(); + //glLineWidth(llmax(4.f*sinf(gFrameTimeSeconds*2.f)+1.f, 1.f)); + stop_glerror(); drawBoxOutline(pos,size); gGL.flush(); - glLineWidth(1.f); + //glLineWidth(1.f); } else { @@ -2897,7 +2896,7 @@ public: if (i == 1) { gGL.flush(); - glLineWidth(3.f); + //glLineWidth(3.f); } gGL.begin(LLRender::TRIANGLES); @@ -2916,7 +2915,7 @@ public: if (i == 1) { gGL.flush(); - glLineWidth(1.f); + //glLineWidth(1.f); } } } diff --git a/indra/newview/llstatusbar.cpp b/indra/newview/llstatusbar.cpp index bda75c16e7..7d397cddcc 100644 --- a/indra/newview/llstatusbar.cpp +++ b/indra/newview/llstatusbar.cpp @@ -307,9 +307,21 @@ void LLStatusBar::refresh() mFpsUpdateTimer->reset(); S32 fps = (S32) llround(LLTrace::get_frame_recording().getPeriodMedianPerSec(LLStatViewer::FPS, 50)); + if(fps < 1) fps = 1; + + S32 minFps = (S32) llround(LLTrace::get_frame_recording().getPeriodMinPerSec(LLStatViewer::FPS, 50)); + S32 maxFps = (S32) llround(LLTrace::get_frame_recording().getPeriodMaxPerSec(LLStatViewer::FPS, 50)); + + F32 fpsQuality = (F32)minFps / (F32)fps; + std::string fpsStr = std::to_string(fps); - //mTextFps->setText(fpsStr); + mTextFps->setLabel(fpsStr); + + if(fpsQuality < 0.5) mTextFps->setColor(LLColor4(0.6,0.0,0.0)); + else if(fpsQuality < 0.7) mTextFps->setColor(LLColor4(0.7,0.5,0.0)); + else if(fpsQuality < 0.9) mTextFps->setColor(LLColor4(0.5,0.7,0.0)); + else mTextFps->setColor(LLColor4(0.0, 0.7, 0.15)); } // update clock every 10 seconds diff --git a/indra/newview/llterrainpaintmap.cpp b/indra/newview/llterrainpaintmap.cpp index c7a82013e4..8cb926a110 100644 --- a/indra/newview/llterrainpaintmap.cpp +++ b/indra/newview/llterrainpaintmap.cpp @@ -86,9 +86,10 @@ bool LLTerrainPaintMap::bakeHeightNoiseIntoPBRPaintMapRGB(const LLViewerRegion& return false; } gGL.getTexUnit(0)->disable(); - stop_glerror(); - scratch_target.bindTarget(); + LOG_GLERROR(""); + + scratch_target.bindTarget("", 1); glClearColor(0, 0, 0, 0); scratch_target.clear(); @@ -276,7 +277,7 @@ bool LLTerrainPaintMap::bakeHeightNoiseIntoPBRPaintMapRGB(const LLViewerRegion& LL_WARNS() << "Failed to copy framebuffer to paintmap" << LL_ENDL; } glGenerateMipmap(GL_TEXTURE_2D); - stop_glerror(); + LOG_GLERROR("LLTerrainPainMap::bakeHeightNoiseIntoPBRPaintMapRGB() - glGenerateMipmap"); scratch_target.flush(); diff --git a/indra/newview/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp index 6e790e4fca..ac0147002e 100644 --- a/indra/newview/llviewerdisplay.cpp +++ b/indra/newview/llviewerdisplay.cpp @@ -709,6 +709,8 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot) if (!gDisconnected && !LLApp::isExiting()) { + // =========== MIRRORS ============= + // Render mirrors and associated hero probes before we render the rest of the scene. // This ensures the scene state in the hero probes are exactly the same as the rest of the scene before we render it. if (gPipeline.RenderMirrors && !gSnapshot) @@ -734,12 +736,14 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot) display_update_camera(); stop_glerror(); + // =========== ENV: SKY, WATER ============= { LL_PROFILE_ZONE_NAMED_CATEGORY_DISPLAY("Env Update"); // update all the sky/atmospheric/water settings LLEnvironment::instance().update(LLViewerCamera::getInstance()); } + // =========== EFFECTS (?) ============= // *TODO: merge these two methods { LL_PROFILE_ZONE_NAMED_CATEGORY_DISPLAY("HUD Update"); @@ -748,6 +752,7 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot) stop_glerror(); } + // =========== GEOMETRY ============= { LL_PROFILE_ZONE_NAMED_CATEGORY_DISPLAY("Update Geom"); const F32 max_geom_update_time = 0.005f*10.f*gFrameIntervalSeconds.value(); // 50 ms/second update time @@ -778,6 +783,8 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot) LLGLState::checkStates(); + // =========== OCCLUSION ============= + static LLCullResult result; LLViewerCamera::sCurCameraID = LLViewerCamera::CAMERA_WORLD; LLPipeline::sUnderWaterRender = LLViewerCamera::getInstance()->cameraUnderWater(); @@ -803,12 +810,18 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot) if (!for_snapshot) { - if (gFrameCount > 1 && !for_snapshot) - { //for some reason, ATI 4800 series will error out if you - //try to generate a shadow before the first frame is through + + // =========== SHADOWS ============= + + S32 RenderShadowDetail = gSavedSettings.getS32("RenderShadowDetail"); + + if(RenderShadowDetail > 0 && gFrameCount > 1) + { gPipeline.generateSunShadow(*LLViewerCamera::getInstance()); } + // =========== IMPOSTORS ============= + LLVertexBuffer::unbind(); LLGLState::checkStates(); @@ -832,6 +845,9 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot) glClear(GL_DEPTH_BUFFER_BIT); } + + // =========== IMAGES ============= + ////////////////////////////////////// // // Update images, using the image stats generated during object update/culling @@ -870,6 +886,9 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot) LLGLState::checkStates(); + + // =========== SORTING OBJECTS ============= + /////////////////////////////////// // // StateSort @@ -903,6 +922,9 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot) LLPipeline::sUseOcclusion = occlusion; + + // =========== SKY ============= + { LLAppViewer::instance()->pingMainloopTimeout("Display:Sky"); LL_PROFILE_ZONE_NAMED_CATEGORY_ENVIRONMENT("update sky"); //LL_RECORD_BLOCK_TIME(FTM_UPDATE_SKY); @@ -954,6 +976,9 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot) // gGL.popMatrix(); //} + + // =========== DEFERRED ============= + LLPipeline::sUnderWaterRender = LLViewerCamera::getInstance()->cameraUnderWater(); LLGLState::checkStates(); @@ -962,7 +987,7 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot) gGL.setColorMask(true, true); - gPipeline.mRT->deferredScreen.bindTarget(); + gPipeline.mRT->deferredScreen.bindTarget("", 1); if (gUseWireframe) { constexpr F32 g = 0.5f; @@ -974,6 +999,9 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot) } gPipeline.mRT->deferredScreen.clear(); + + // =========== RENDER GEOMETRY ============= + gGL.setColorMask(true, false); LLAppViewer::instance()->pingMainloopTimeout("Display:RenderGeom"); @@ -984,7 +1012,11 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot) LL_PROFILE_ZONE_NAMED_CATEGORY_DISPLAY("display - 5") LLViewerCamera::sCurCameraID = LLViewerCamera::CAMERA_WORLD; + + // =========== RENDER DEPTH PREPASS (UNUSED) ============= + static LLCachedControl<bool> render_depth_pre_pass(gSavedSettings, "RenderDepthPrePass", false); + if (render_depth_pre_pass) { gGL.setColorMask(false, false); @@ -1010,6 +1042,8 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot) gPipeline.renderGeomDeferred(*LLViewerCamera::getInstance(), true); } + // =========== UNBIND TEXTURES ============= + { LL_PROFILE_ZONE_NAMED_CATEGORY_DISPLAY("Texture Unbind"); for (S32 i = 0; i < gGLManager.mNumTextureImageUnits; i++) @@ -1022,11 +1056,15 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot) } } + // =========== FLUSH ============= + LLAppViewer::instance()->pingMainloopTimeout("Display:RenderFlush"); LLRenderTarget &rt = (gPipeline.sRenderDeferred ? gPipeline.mRT->deferredScreen : gPipeline.mRT->screen); rt.flush(); + // =========== RENDER DEFERRED ============= + if (LLPipeline::sRenderDeferred) { gPipeline.renderDeferredLighting(); @@ -1039,10 +1077,14 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot) LLSceneMonitor::getInstance()->capture(); } + // =========== RENDER UI ============= + LLAppViewer::instance()->pingMainloopTimeout("Display:RenderUI"); if (!for_snapshot) { + gGL.flush(); render_ui(); + gGL.flush(); swap(); } @@ -1053,8 +1095,6 @@ void display(bool rebuild, F32 zoom_factor, int subfield, bool for_snapshot) LLAppViewer::instance()->pingMainloopTimeout("Display:FrameStats"); - stop_glerror(); - display_stats(); LLAppViewer::instance()->pingMainloopTimeout("Display:Done"); @@ -1204,7 +1244,7 @@ void display_cube_face() gGL.setColorMask(true, true); glClearColor(0.f, 0.f, 0.f, 0.f); - gPipeline.generateSunShadow(*LLViewerCamera::getInstance()); + //gPipeline.generateSunShadow(*LLViewerCamera::getInstance()); glClear(GL_DEPTH_BUFFER_BIT); // | GL_STENCIL_BUFFER_BIT); @@ -1232,7 +1272,7 @@ void display_cube_face() gGL.setColorMask(true, true); - gPipeline.mRT->deferredScreen.bindTarget(); + gPipeline.mRT->deferredScreen.bindTarget("", 1); if (gUseWireframe) { glClearColor(0.5f, 0.5f, 0.5f, 1.f); @@ -1669,7 +1709,7 @@ void render_ui_3d() LLHUDObject::renderAllForTimer(); } - stop_glerror(); + LOG_GLERROR("render_ui_3d()"); } void render_ui_2d() @@ -1719,7 +1759,7 @@ void render_ui_2d() gl_rect_2d(-half_width, half_height, half_width, -half_height, false); gGL.popMatrix(); gUIProgram.unbind(); - stop_glerror(); + LOG_GLERROR(""); } @@ -1730,7 +1770,7 @@ void render_ui_2d() LLView::sIsRectDirty = false; LLRect t_rect; - gPipeline.mUIScreen.bindTarget(); + gPipeline.mUIScreen.bindTarget("", 1); gGL.setColorMask(true, true); { constexpr S32 pad = 8; @@ -1788,6 +1828,8 @@ void render_ui_2d() // reset current origin for font rendering, in case of tiling render LLFontGL::sCurOrigin.set(0, 0); + + LOG_GLERROR("render_ui_2d()"); } void render_disconnected_background() diff --git a/indra/newview/llviewerparceloverlay.cpp b/indra/newview/llviewerparceloverlay.cpp index e36ad0e722..0bb03cdd60 100755 --- a/indra/newview/llviewerparceloverlay.cpp +++ b/indra/newview/llviewerparceloverlay.cpp @@ -809,7 +809,7 @@ void LLViewerParcelOverlay::renderPropertyLinesOnMinimap(F32 scale_pixels_per_me const S32 GRIDS_PER_EDGE = mParcelGridsPerEdge; gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); - glLineWidth(1.0f); + //glLineWidth(1.0f); gGL.color4fv(parcel_outline_color); for (S32 i = 0; i <= GRIDS_PER_EDGE; i++) { diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp index 7ef13c3a35..753652f168 100644 --- a/indra/newview/llviewershadermgr.cpp +++ b/indra/newview/llviewershadermgr.cpp @@ -137,6 +137,10 @@ LLGLSLShader gGlowProgram; LLGLSLShader gGlowExtractProgram; LLGLSLShader gPostScreenSpaceReflectionProgram; +LLGLSLShader gBloomExtractProgram; +LLGLSLShader gBloomBlurProgram; +LLGLSLShader gBloomCombineProgram; + // Deferred rendering shaders LLGLSLShader gDeferredImpostorProgram; LLGLSLShader gDeferredDiffuseProgram; @@ -1003,6 +1007,52 @@ bool LLViewerShaderMgr::loadShadersEffects() if (success) { + gBloomExtractProgram.mName = "Bloom Extract Shader"; + gBloomExtractProgram.mShaderFiles.clear(); + gBloomExtractProgram.mShaderFiles.push_back(make_pair("effects/bloomExtractV.glsl", GL_VERTEX_SHADER)); + gBloomExtractProgram.mShaderFiles.push_back(make_pair("effects/bloomExtractF.glsl", GL_FRAGMENT_SHADER)); + gBloomExtractProgram.mShaderLevel = mShaderLevel[SHADER_EFFECT]; + + success = gBloomExtractProgram.createShader(); + if (!success) + { + LL_WARNS() << "gBloomExtractProgram creation ERROR" << LL_ENDL; + //LLPipeline::sRenderGlow = false; + } + } + + if (success) + { + gBloomBlurProgram.mName = "Bloom Blur Shader"; + gBloomBlurProgram.mShaderFiles.clear(); + gBloomBlurProgram.mShaderFiles.push_back(make_pair("effects/bloomBlurV.glsl", GL_VERTEX_SHADER)); + gBloomBlurProgram.mShaderFiles.push_back(make_pair("effects/bloomBlurF.glsl", GL_FRAGMENT_SHADER)); + gBloomBlurProgram.mShaderLevel = mShaderLevel[SHADER_EFFECT]; + + success = gBloomBlurProgram.createShader(); + if(!success) + { + LL_WARNS() << "gBloomBlurProgram creation ERROR" << LL_ENDL; + } + } + + if (success) + { + gBloomCombineProgram.mName = "Bloom Combine Shader"; + gBloomCombineProgram.mShaderFiles.clear(); + gBloomCombineProgram.mShaderFiles.push_back(make_pair("effects/bloomCombineV.glsl", GL_VERTEX_SHADER)); + gBloomCombineProgram.mShaderFiles.push_back(make_pair("effects/bloomCombineF.glsl", GL_FRAGMENT_SHADER)); + gBloomCombineProgram.mShaderLevel = mShaderLevel[SHADER_EFFECT]; + + success = gBloomCombineProgram.createShader(); + if(!success) + { + LL_WARNS() << "gBloomCombineProgram creation ERROR" << LL_ENDL; + } + } + + if (success) + { gGlowProgram.mName = "Glow Shader (Post)"; gGlowProgram.mShaderFiles.clear(); gGlowProgram.mShaderFiles.push_back(make_pair("effects/glowV.glsl", GL_VERTEX_SHADER)); diff --git a/indra/newview/llviewershadermgr.h b/indra/newview/llviewershadermgr.h index 7ad2da9464..4d16c12630 100644 --- a/indra/newview/llviewershadermgr.h +++ b/indra/newview/llviewershadermgr.h @@ -298,6 +298,10 @@ extern LLGLSLShader gHUDPBRAlphaProgram; // GLTF shaders extern LLGLSLShader gGLTFPBRMetallicRoughnessProgram; +extern LLGLSLShader gBloomExtractProgram; +extern LLGLSLShader gBloomBlurProgram; +extern LLGLSLShader gBloomCombineProgram; + // Encodes detail level for dropping textures, in accordance with the GLTF spec where possible // 0 is highest detail, -1 drops emissive, etc // Dropping metallic roughness is off-spec - Reserve for potato machines as needed diff --git a/indra/newview/llviewertexturelist.cpp b/indra/newview/llviewertexturelist.cpp index 7e14c621ad..5bbcd8f09f 100644 --- a/indra/newview/llviewertexturelist.cpp +++ b/indra/newview/llviewertexturelist.cpp @@ -1146,6 +1146,8 @@ F32 LLViewerTextureList::updateImagesCreateTextures(F32 max_time) // just in case we downres textures, bind downresmap and copy program gPipeline.mDownResMap.bindTarget(); + //gPipeline.mDownResMap.clear(); + gCopyProgram.bind(); gPipeline.mScreenTriangleVB->setBuffer(); @@ -1155,7 +1157,7 @@ F32 LLViewerTextureList::updateImagesCreateTextures(F32 max_time) // do at least 5 and make sure we don't get too far behind even if it violates // the time limit. If we don't downscale quickly the viewer will hit swap and may // freeze. - S32 min_count = (S32)mCreateTextureList.size() / 20 + 5; + S32 min_count = (S32)mCreateTextureList.size() / 20 + 3; create_timer.reset(); while (!mDownScaleQueue.empty()) diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp index d3af22a9d9..9e52ed9a12 100644 --- a/indra/newview/llviewerwindow.cpp +++ b/indra/newview/llviewerwindow.cpp @@ -4829,21 +4829,13 @@ void LLViewerWindow::saveImageLocal(LLImageFormatted *image, const snapshot_save auto err = 0; auto extension("." + image->getExtension()); auto now = LLDate::now(); - static LLCachedControl<bool> snapshot_timestamp(gSavedSettings, "SnapshotTimestamp", true) ; do { filepath = sSnapshotDir; filepath += gDirUtilp->getDirDelimiter(); filepath += sSnapshotBaseName; - if (snapshot_timestamp) - { filepath += now.toLocalDateString("_%Y-%m-%d_%H%M%S"); filepath += llformat("%.2d", i); - } - else if (is_snapshot_name_loc_set) - { - filepath += llformat("_%.3d", i); - } filepath += extension; llstat stat_info; @@ -5045,7 +5037,7 @@ bool LLViewerWindow::rawSnapshot(LLImageRaw *raw, S32 image_width, S32 image_hei mWorldViewRectRaw.set(0, image_height, image_width, 0); LLViewerCamera::getInstance()->setViewHeightInPixels( mWorldViewRectRaw.getHeight() ); LLViewerCamera::getInstance()->setAspect( getWorldViewAspectRatio() ); - scratch_space.bindTarget(); + scratch_space.bindTarget("", 0); } else { @@ -5312,7 +5304,7 @@ bool LLViewerWindow::simpleSnapshot(LLImageRaw* raw, S32 image_width, S32 image_ { mWorldViewRectRaw.set(0, image_height, image_width, 0); - scratch_space.bindTarget(); + scratch_space.bindTarget("", 0); } else { diff --git a/indra/newview/llvoavatar.cpp b/indra/newview/llvoavatar.cpp index c6f8160c0d..10b5b7514c 100644 --- a/indra/newview/llvoavatar.cpp +++ b/indra/newview/llvoavatar.cpp @@ -5463,7 +5463,7 @@ U32 LLVOAvatar::renderImpostor(LLColor4U color, S32 diffuse_channel) gGL.begin(LLRender::LINES); gGL.color4f(1.f,1.f,1.f,1.f); F32 thickness = llmax(F32(5.0f-5.0f*(gFrameTimeSeconds-mLastImpostorUpdateFrameTime)),1.0f); - glLineWidth(thickness); + //glLineWidth(thickness); gGL.vertex3fv((pos+left-up).mV); gGL.vertex3fv((pos-left-up).mV); gGL.vertex3fv((pos-left-up).mV); diff --git a/indra/newview/mpfloatertuning.cpp b/indra/newview/mpfloatertuning.cpp index 1a3e4cf718..23f8c21e70 100644 --- a/indra/newview/mpfloatertuning.cpp +++ b/indra/newview/mpfloatertuning.cpp @@ -39,47 +39,37 @@ MPFloaterTuning::MPFloaterTuning(const LLSD& key) : LLFloater(key) { } -void MPFloaterTuning::syncFromPreferenceSetting(void *user_data) -{ - MPFloaterTuning *self = static_cast<MPFloaterTuning*>(user_data); +bool MPFloaterTuning::postBuild() +{ U32 fps = gSavedSettings.getU32("MaxFPS"); if(fps==0) fps=132; - LLSliderCtrl* fpsSliderCtrl = self->getChild<LLSliderCtrl>("fpsSlider"); - fpsSliderCtrl->setValue(fps,FALSE); + mFpsSlider = getChild<LLSliderCtrl>("fpsSliderCtrl"); + mFpsSlider->setCommitCallback(boost::bind(&MPFloaterTuning::onFpsSliderChanged, this)); - LLTextBox* fpsText = self->getChild<LLTextBox>("fpsText"); - if(fps>120) fpsText->setValue("no limit"); - else fpsText->setValue(std::to_string(fps)+" fps"); -} - -bool MPFloaterTuning::postBuild() -{ - LLSliderCtrl* fpsSliderCtrl = getChild<LLSliderCtrl>("fpsSlider"); - fpsSliderCtrl->setMinValue(12); - fpsSliderCtrl->setMaxValue(132); - fpsSliderCtrl->setSliderMouseUpCallback(boost::bind(&MPFloaterTuning::onFinalCommit,this)); + mFpsSlider->setValue(fps, false); - LLTextBox* fpsText = getChild<LLTextBox>("fpsText"); - fpsText->setValue(""); + mFpsTextBox = getChild<LLTextBox>("fpsTextCtrl"); + mFpsTextBox->setValue(""); - syncFromPreferenceSetting(this); + if(fps>120) mFpsTextBox->setValue("no limit"); + else if(fps==0) mFpsTextBox->setValue("no limit"); + else mFpsTextBox->setValue(std::to_string(fps)+" fps"); - return TRUE; + return true; } // Do send-to-the-server work when slider drag completes, or new // value entered as text. -void MPFloaterTuning::onFinalCommit() +void MPFloaterTuning::onFpsSliderChanged() { - LLSliderCtrl* fpsSliderCtrl = getChild<LLSliderCtrl>("fpsSlider"); - U32 fps = (U32)fpsSliderCtrl->getValueF32(); + U32 fps = (U32)mFpsSlider->getValueF32(); gSavedSettings.setU32("MaxFPS",fps); - LLTextBox* fpsText = getChild<LLTextBox>("fpsText"); - if(fps>120) fpsText->setValue("no limit"); - else fpsText->setValue(std::to_string(fps)+" fps"); + if(fps>120) mFpsTextBox->setValue("no limit"); + else if(fps==0) mFpsTextBox->setValue("no limit"); + else mFpsTextBox->setValue(std::to_string(fps)+" fps"); } void MPFloaterTuning::onClose(bool app_quitting) diff --git a/indra/newview/mpfloatertuning.h b/indra/newview/mpfloatertuning.h index 9e9c7f174f..bebdaa9952 100644 --- a/indra/newview/mpfloatertuning.h +++ b/indra/newview/mpfloatertuning.h @@ -29,20 +29,28 @@ #include "llfloater.h" +class LLSliderCtrl; +class LLTextBox; + class MPFloaterTuning: public LLFloater { -public: + public: + MPFloaterTuning(const LLSD& key); bool postBuild(); void onFinalCommit(); - static void syncFromPreferenceSetting(void *user_data); - - //void updateEditEnabled(); /*virtual*/ void onClose(bool app_quitting); + + private: + + LLSliderCtrl* mFpsSlider = nullptr; + LLTextBox* mFpsTextBox = nullptr; + + void onFpsSliderChanged(); }; #endif diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp index 6b3a5b1892..b373532aa0 100644 --- a/indra/newview/pipeline.cpp +++ b/indra/newview/pipeline.cpp @@ -141,7 +141,7 @@ bool LLPipeline::WindLightUseAtmosShaders; bool LLPipeline::RenderDeferred; F32 LLPipeline::RenderDeferredSunWash; U32 LLPipeline::RenderFSAAType; -U32 LLPipeline::RenderResolutionDivisor; +F32 LLPipeline::RenderResolutionDivisor; bool LLPipeline::RenderUIBuffer; S32 LLPipeline::RenderShadowDetail; S32 LLPipeline::MPRenderShadowOpti; @@ -229,6 +229,9 @@ const F32 ALPHA_BLEND_CUTOFF = 0.598f; const F32 DEFERRED_LIGHT_FALLOFF = 0.5f; const U32 DEFERRED_VB_MASK = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_TEXCOORD1; +const U32 SHADOWS_RESX = 1024; +const U32 SHADOWS_RESY = 768; + extern S32 gBoxFrame; extern bool gDisplaySwapBuffers; extern bool gDebugGL; @@ -268,6 +271,7 @@ LLTrace::BlockTimerStatHandle FTM_STATESORT("Sort Draw State"); LLTrace::BlockTimerStatHandle FTM_PIPELINE("Pipeline"); LLTrace::BlockTimerStatHandle FTM_CLIENT_COPY("Client Copy"); LLTrace::BlockTimerStatHandle FTM_RENDER_DEFERRED("Deferred Shading"); +LLTrace::BlockTimerStatHandle FTM_RENDER_SHADOWS("Shadows"); LLTrace::BlockTimerStatHandle FTM_RENDER_UI_HUD("HUD"); LLTrace::BlockTimerStatHandle FTM_RENDER_UI_3D("3D"); @@ -346,18 +350,20 @@ void validate_framebuffer_object(); // target -- RenderTarget to add attachments to bool addDeferredAttachments(LLRenderTarget& target, bool for_impostor = false) { - U32 orm = GL_RGBA; + U32 orm = GL_RGBA8; U32 norm = GL_RGBA16F; U32 emissive = GL_RGB16F; + static LLCachedControl<bool> MPLowColorPrecision(gSavedSettings, "MPLowColorPrecision", 0); + static LLCachedControl<bool> has_emissive(gSavedSettings, "RenderEnableEmissiveBuffer", false); static LLCachedControl<bool> has_hdr(gSavedSettings, "RenderHDREnabled", true); bool hdr = has_hdr() && gGLManager.mGLVersion > 4.05f; - if (!hdr) + if (!hdr || MPLowColorPrecision) { norm = GL_RGB10_A2; - emissive = GL_RGB; + emissive = GL_RGB8; } bool valid = true; @@ -429,7 +435,7 @@ void LLPipeline::init() mInitialized = true; - stop_glerror(); + LOG_GLERROR("LLPipeline::init()"); //create render pass pools getPool(LLDrawPool::POOL_WATEREXCLUSION); @@ -701,7 +707,8 @@ void LLPipeline::cleanup() void LLPipeline::destroyGL() { - stop_glerror(); + LOG_GLERROR("LLPipeline::destroyGL()"); + unloadShaders(); mHighlightFaces.clear(); @@ -730,9 +737,9 @@ void LLPipeline::resizeShadowTexture() { releaseSunShadowTargets(); releaseSpotShadowTargets(); - GLuint resX = gViewerWindow->getWorldViewWidthRaw(); - GLuint resY = gViewerWindow->getWorldViewHeightRaw(); - allocateShadowBuffer(resX, resY); + //GLuint resX = gViewerWindow->getWorldViewWidthRaw(); + //GLuint resY = gViewerWindow->getWorldViewHeightRaw(); + allocateShadowBuffer(SHADOWS_RESX, SHADOWS_RESY); gResizeShadowTexture = false; } @@ -762,6 +769,12 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY) return ret == FBO_SUCCESS_FULLRES; } +void LLPipeline::renderTriangle() +{ + gPipeline.mScreenTriangleVB->setBuffer(); + gPipeline.mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); +} + LLPipeline::eFBOStatus LLPipeline::doAllocateScreenBuffer(U32 resX, U32 resY) { @@ -843,28 +856,31 @@ bool LLPipeline::allocateScreenBufferInternal(U32 resX, U32 resY) mRT->width = resX; mRT->height = resY; - U32 res_mod = RenderResolutionDivisor; + F32 res_mod = fmin(RenderResolutionDivisor, 4.0); + + LL_WARNS() << "res_mod=" << res_mod << " resX=" << resX << " resY=" << resY << LL_ENDL; - if (res_mod > 1 && res_mod < resX && res_mod < resY) + if (res_mod >= 0.5 && res_mod <= 4.0) { - resX /= res_mod; - resY /= res_mod; + resX = (U32)(floor((F32)resX / res_mod)); + resY = (U32)(floor((F32)resY / res_mod)); + LL_WARNS() << "res_mod=" << res_mod << " resX=" << resX << " resY=" << resY << LL_ENDL; } S32 shadow_detail = RenderShadowDetail; bool ssao = RenderDeferredSSAO; //allocate deferred rendering color buffers - if (!mRT->deferredScreen.allocate(resX, resY, GL_RGBA, true)) return false; + if (!mRT->deferredScreen.allocate(resX, resY, GL_RGBA8, true)) return false; if (!addDeferredAttachments(mRT->deferredScreen)) return false; - GLuint screenFormat = hdr ? GL_RGBA16F : GL_RGBA; + GLuint screenFormat = hdr ? GL_RGBA16F : GL_RGBA8; - if (!mRT->screen.allocate(resX, resY, GL_RGBA16F)) return false; + if (!mRT->screen.allocate(resX, resY, screenFormat)) return false; mRT->deferredScreen.shareDepthBuffer(mRT->screen); - if (shadow_detail > 0 || ssao || RenderDepthOfField) + if (hdr || shadow_detail > 0 || ssao || RenderDepthOfField) { //only need mRT->deferredLight for shadows OR ssao OR dof if (!mRT->deferredLight.allocate(resX, resY, screenFormat)) return false; } @@ -873,13 +889,14 @@ bool LLPipeline::allocateScreenBufferInternal(U32 resX, U32 resY) mRT->deferredLight.release(); } - allocateShadowBuffer(resX, resY); + //allocateShadowBuffer(resX, resY); + allocateShadowBuffer(SHADOWS_RESX, SHADOWS_RESY); if (!gCubeSnapshot) // hack to not re-allocate various targets for cube snapshots { if (RenderUIBuffer) { - if (!mUIScreen.allocate(resX, resY, GL_RGBA)) + if (!mUIScreen.allocate(resX, resY, GL_RGBA8)) { return false; } @@ -887,10 +904,10 @@ bool LLPipeline::allocateScreenBufferInternal(U32 resX, U32 resY) if (RenderFSAAType > 0) { - if (!mFXAAMap.allocate(resX, resY, GL_RGBA)) return false; + if (!mFXAAMap.allocate(resX, resY, GL_RGBA8)) return false; if (RenderFSAAType == 2) { - if (!mSMAABlendBuffer.allocate(resX, resY, GL_RGBA, false)) return false; + if (!mSMAABlendBuffer.allocate(resX, resY, GL_RGBA8, false)) return false; } } else @@ -911,7 +928,10 @@ bool LLPipeline::allocateScreenBufferInternal(U32 resX, U32 resY) mSceneMap.release(); } - mPostMap.allocate(resX, resY, screenFormat); + //mPostMaps[0].allocate(resX, resY, screenFormat); + //mPostMaps[1].allocate(resX, resY, screenFormat); + mPostMaps[0].allocate(resX, resY, GL_RGBA); + mPostMaps[1].allocate(resX, resY, GL_RGBA); // The water exclusion mask needs its own depth buffer so we can take care of the problem of multiple water planes. // Should we ever make water not just a plane, it also aids with that as well as the water planes will be rendered into the mask. @@ -924,9 +944,9 @@ bool LLPipeline::allocateScreenBufferInternal(U32 resX, U32 resY) // used to scale down textures // See LLViwerTextureList::updateImagesCreateTextures and LLImageGL::scaleDown - mDownResMap.allocate(1024, 1024, GL_RGBA); + mDownResMap.allocate(1024, 1024, GL_RGBA8); - mBakeMap.allocate(LLAvatarAppearanceDefines::SCRATCH_TEX_WIDTH, LLAvatarAppearanceDefines::SCRATCH_TEX_HEIGHT, GL_RGBA); + mBakeMap.allocate(LLAvatarAppearanceDefines::SCRATCH_TEX_WIDTH, LLAvatarAppearanceDefines::SCRATCH_TEX_HEIGHT, GL_RGBA8); } //HACK make screenbuffer allocations start failing after 30 seconds if (gSavedSettings.getBOOL("SimulateFBOFailure")) @@ -936,7 +956,7 @@ bool LLPipeline::allocateScreenBufferInternal(U32 resX, U32 resY) gGL.getTexUnit(0)->disable(); - stop_glerror(); + LOG_GLERROR("LLPipeline::allocateScreenBufferInternal end"); return true; } @@ -950,15 +970,18 @@ bool LLPipeline::allocateShadowBuffer(U32 resX, U32 resY) S32 shadow_detail = RenderShadowDetail; F32 scale = gCubeSnapshot ? 1.0f : llmax(0.5f, RenderShadowResolutionScale); // Don't scale probe shadow maps - U32 sun_shadow_map_width = BlurHappySize(resX, scale); - U32 sun_shadow_map_height = BlurHappySize(resY, scale); + //U32 sun_shadow_map_width = BlurHappySize(resX, scale); + //U32 sun_shadow_map_height = BlurHappySize(resY, scale); + U32 sun_shadow_map_width = resX * scale; + U32 sun_shadow_map_height = resY * scale; if (shadow_detail > 0) { //allocate 4 sun shadow maps for (U32 i = 0; i < 4; i++) { - if (!mRT->shadow[i].allocate(sun_shadow_map_width, sun_shadow_map_height, 0, true)) + if (!mRT->shadow[i].allocate(sun_shadow_map_width, sun_shadow_map_height, 0, true, LLTexUnit::TT_TEXTURE, LLTexUnit::TMG_NONE)) { + LL_WARNS() << "failed allocating shadow buffer " << i << " w:" << sun_shadow_map_width << " h:" << sun_shadow_map_height << LL_ENDL; return false; } } @@ -1058,10 +1081,9 @@ void LLPipeline::refreshCachedSettings() RenderDeferred = true; // DEPRECATED -- gSavedSettings.getBOOL("RenderDeferred"); RenderDeferredSunWash = gSavedSettings.getF32("RenderDeferredSunWash"); RenderFSAAType = gSavedSettings.getU32("RenderFSAAType"); - RenderResolutionDivisor = gSavedSettings.getU32("RenderResolutionDivisor"); + RenderResolutionDivisor = gSavedSettings.getF32("RenderResolutionDivisor"); RenderUIBuffer = gSavedSettings.getBOOL("RenderUIBuffer"); RenderShadowDetail = gSavedSettings.getS32("RenderShadowDetail"); - MPRenderShadowOpti = gSavedSettings.getS32("MPRenderShadowOpti"); RenderShadowSplits = gSavedSettings.getS32("RenderShadowSplits"); RenderDeferredSSAO = gSavedSettings.getBOOL("RenderDeferredSSAO"); RenderShadowResolutionScale = gSavedSettings.getF32("RenderShadowResolutionScale"); @@ -1152,6 +1174,13 @@ void LLPipeline::releaseGLBuffers() { assertInitialized(); + mBloomMap.release(); + + for (U32 i = 0; i < 2; i++) + { + mBloomBlur[i].release(); + } + if (mNoiseMap) { LLImageGL::deleteTextures(1, &mNoiseMap); @@ -1184,7 +1213,8 @@ void LLPipeline::releaseGLBuffers() mWaterExclusionMask.release(); - mPostMap.release(); + mPostMaps[0].release(); + mPostMaps[1].release(); mFXAAMap.release(); @@ -1272,23 +1302,28 @@ void LLPipeline::releaseSpotShadowTargets() void LLPipeline::createGLBuffers() { LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE; - stop_glerror(); + LOG_GLERROR("LLPipeline::createGLBuffers()"); assertInitialized(); - stop_glerror(); - GLuint resX = gViewerWindow->getWorldViewWidthRaw(); GLuint resY = gViewerWindow->getWorldViewHeightRaw(); // allocate screen space glow buffers const U32 glow_res = llmax(1, llmin(512, 1 << gSavedSettings.getS32("RenderGlowResolutionPow"))); const bool glow_hdr = gSavedSettings.getBOOL("RenderGlowHDR"); - const U32 glow_color_fmt = glow_hdr ? GL_RGBA16F : GL_RGBA; + const U32 glow_color_fmt = glow_hdr ? GL_RGBA16F : GL_RGBA8; for (U32 i = 0; i < 3; i++) { mGlow[i].allocate(512, glow_res, glow_color_fmt); } + mBloomMap.allocate(resX/2.0, resY/2.0, glow_color_fmt); + + for (U32 i = 0; i < 2; i++) + { + mBloomBlur[i].allocate(resX/2.0, resY/2.0, glow_color_fmt); + } + allocateScreenBuffer(resX, resY); // Do not zero out mRT dimensions here. allocateScreenBuffer() above // already sets the correct dimensions. Zeroing them caused resizeShadowTexture() @@ -1397,7 +1432,7 @@ void LLPipeline::createGLBuffers() gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, mSMAASampleMap); LLImageGL::setManualImage(LLTexUnit::getInternalType(LLTexUnit::TT_TEXTURE), 0, GL_RGB, raw_image->getWidth(), raw_image->getHeight(), format, GL_UNSIGNED_BYTE, raw_image->getData(), false); - stop_glerror(); + LOG_GLERROR("LLPipeline::createGLBuffers after setManualImage"); gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR); gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP); } @@ -1457,11 +1492,7 @@ void LLPipeline::createLUTBuffers() } U32 pix_format = GL_R16F; -#if 0 && LL_DARWIN - // Need to work around limited precision with 10.6.8 and older drivers - // - pix_format = GL_R32F; -#endif + LLImageGL::generateTextures(1, &mLightFunc); gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, mLightFunc); LLImageGL::setManualImage(LLTexUnit::getInternalType(LLTexUnit::TT_TEXTURE), 0, pix_format, lightResX, lightResY, GL_RED, GL_FLOAT, ls, false); @@ -1474,7 +1505,7 @@ void LLPipeline::createLUTBuffers() } mPbrBrdfLut.allocate(512, 512, GL_RG16F); - mPbrBrdfLut.bindTarget(); + mPbrBrdfLut.bindTarget("mPbrBrdfLut", 1); if (gDeferredGenBrdfLutProgram.isComplete()) { @@ -1498,13 +1529,13 @@ void LLPipeline::createLUTBuffers() mPbrBrdfLut.flush(); mExposureMap.allocate(1, 1, GL_R16F); - mExposureMap.bindTarget(); + mExposureMap.bindTarget("mExposureMap", 1); glClearColor(1, 1, 1, 0); mExposureMap.clear(); glClearColor(0, 0, 0, 0); mExposureMap.flush(); - mLuminanceMap.allocate(256, 256, GL_R16F, false, LLTexUnit::TT_TEXTURE); + mLuminanceMap.allocate(256, 256, GL_R16F, false, LLTexUnit::TT_TEXTURE, LLTexUnit::TMG_AUTO); mLastExposure.allocate(1, 1, GL_R16F); } @@ -2529,7 +2560,7 @@ void LLPipeline::updateCull(LLCamera& camera, LLCullResult& result) gSky.mVOSkyp->mDrawable->setVisible(camera); sCull->pushDrawable(gSky.mVOSkyp->mDrawable); gSky.updateCull(); - stop_glerror(); + LOG_GLERROR("LLPipeline::updateCull sky"); } if (hasRenderType(LLPipeline::RENDER_TYPE_WL_SKY) && @@ -2539,6 +2570,7 @@ void LLPipeline::updateCull(LLCamera& camera, LLCullResult& result) { gSky.mVOWLSkyp->mDrawable->setVisible(camera); sCull->pushDrawable(gSky.mVOWLSkyp->mDrawable); + LOG_GLERROR("LLPipeline::updateCull pushDrawable"); } } @@ -2691,6 +2723,8 @@ void LLPipeline::doOcclusion(LLCamera& camera) gGL.setColorMask(true, true); } + + LOG_GLERROR("LLPipeline::doOcclusion()"); } bool LLPipeline::updateDrawableGeom(LLDrawable* drawablep) @@ -2860,6 +2894,7 @@ void LLPipeline::updateGeom(F32 max_dtime) } updateMovedList(mMovedBridge); + LOG_GLERROR("LLPipeline::updateGeom()"); } void LLPipeline::markVisible(LLDrawable *drawablep, LLCamera& camera) @@ -3858,6 +3893,8 @@ void render_hud_elements() } gUIProgram.unbind(); + + LOG_GLERROR("LLPipeline::render_hud_elements()"); } static inline void bindHighlightProgram(LLGLSLShader& program) @@ -3962,6 +3999,8 @@ void LLPipeline::renderHighlights() unbindHighlightProgram(gHighlightSpecularProgram); } } + + LOG_GLERROR("LLPipeline::renderHighlights()"); } //debug use @@ -3971,6 +4010,7 @@ void LLPipeline::renderGeomDeferred(LLCamera& camera, bool do_occlusion) { LLAppViewer::instance()->pingMainloopTimeout("Pipeline:RenderGeomDeferred"); LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_GEOMETRY); + LL_RECORD_BLOCK_TIME(FTM_RENDER_GEOMETRY); LL_PROFILE_GPU_ZONE("renderGeomDeferred"); llassert(!sRenderingHUDs); @@ -3999,6 +4039,7 @@ void LLPipeline::renderGeomDeferred(LLCamera& camera, bool do_occlusion) bool occlude = LLPipeline::sUseOcclusion > 1 && do_occlusion && !LLGLSLShader::sProfileEnabled; setupHWLights(); + LOG_GLERROR("LLPipeline::renderGeomDeferred() setupHWLights"); { LL_PROFILE_ZONE_NAMED_CATEGORY_DRAWPOOL("deferred pools"); @@ -4087,7 +4128,7 @@ void LLPipeline::renderGeomDeferred(LLCamera& camera, bool do_occlusion) } } iter1 = iter2; - stop_glerror(); + LOG_GLERROR(""); } gGLLastMatrix = NULL; @@ -4110,6 +4151,7 @@ void LLPipeline::renderGeomPostDeferred(LLCamera& camera) { LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; LL_PROFILE_GPU_ZONE("renderGeomPostDeferred"); + LL_RECORD_BLOCK_TIME(FTM_RENDER_DEFERRED); if (gUseWireframe) { @@ -4226,7 +4268,7 @@ void LLPipeline::renderGeomPostDeferred(LLCamera& camera) } } iter1 = iter2; - stop_glerror(); + LOG_GLERROR("after pools"); } gGLLastMatrix = NULL; @@ -4246,6 +4288,8 @@ void LLPipeline::renderGeomPostDeferred(LLCamera& camera) { glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); } + + LOG_GLERROR("LLPipeline::renderGeomPostDeferred()"); } void LLPipeline::renderGeomShadow(LLCamera& camera) @@ -4305,11 +4349,12 @@ void LLPipeline::renderGeomShadow(LLCamera& camera) } } iter1 = iter2; - stop_glerror(); + LOG_GLERROR(""); } gGLLastMatrix = NULL; gGL.loadMatrix(gGLModelView); + LOG_GLERROR("LLPipeline::renderGeomShadow()"); } @@ -4340,7 +4385,7 @@ void LLPipeline::renderPhysicsDisplay() LLGLEnable(GL_POLYGON_OFFSET_LINE); glPolygonOffset(3.f, 3.f); - glLineWidth(3.f); + //glLineWidth(3.f); LLGLEnable blend(GL_BLEND); gGL.setSceneBlendType(LLRender::BT_ALPHA); @@ -4382,7 +4427,7 @@ void LLPipeline::renderPhysicsDisplay() glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); } } - glLineWidth(1.f); + //glLineWidth(1.f); gDebugProgram.unbind(); } @@ -4467,7 +4512,7 @@ void LLPipeline::renderDebug() if ( pathfindingConsole->isRenderNavMesh() ) { gGL.flush(); - glLineWidth(2.0f); + //glLineWidth(2.0f); LLGLEnable cull(GL_CULL_FACE); LLGLDisable blend(GL_BLEND); @@ -4491,7 +4536,7 @@ void LLPipeline::renderDebug() gGL.flush(); glPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); - glLineWidth(1.0f); + //glLineWidth(1.0f); gGL.flush(); } //User designated path @@ -4547,7 +4592,6 @@ void LLPipeline::renderDebug() LLGLDisable cull(i >= 2 ? GL_CULL_FACE : 0); gGL.flush(); - glPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); //get rid of some z-fighting @@ -4607,11 +4651,11 @@ void LLPipeline::renderDebug() gPathfindingProgram.uniform1f(sTint, 1.f); gPathfindingProgram.uniform1f(sAlphaScale, 1.f); - glLineWidth(gSavedSettings.getF32("PathfindingLineWidth")); + //glLineWidth(gSavedSettings.getF32("PathfindingLineWidth")); LLGLDisable blendOut(GL_BLEND); llPathingLibInstance->renderNavMeshShapesVBO( render_order[i] ); gGL.flush(); - glLineWidth(1.f); + //glLineWidth(1.f); } glPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); @@ -4634,7 +4678,7 @@ void LLPipeline::renderDebug() LLGLEnable blend(GL_BLEND); LLGLDepthTest depth(GL_TRUE, GL_FALSE, GL_GREATER); gGL.flush(); - glLineWidth(2.0f); + //glLineWidth(2.0f); LLGLEnable cull(GL_CULL_FACE); gPathfindingProgram.uniform1f(sTint, gSavedSettings.getF32("PathfindingXRayTint")); @@ -4661,7 +4705,7 @@ void LLPipeline::renderDebug() gPathfindingProgram.bind(); gGL.flush(); - glLineWidth(1.0f); + //glLineWidth(1.0f); } glPolygonOffset(0.f, 0.f); @@ -4798,12 +4842,11 @@ void LLPipeline::renderDebug() LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("probe debug display"); bindDeferredShader(gReflectionProbeDisplayProgram, NULL); - mScreenTriangleVB->setBuffer(); LLGLEnable blend(GL_BLEND); LLGLDepthTest depth(GL_FALSE); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); unbindDeferredShader(gReflectionProbeDisplayProgram); } @@ -6792,6 +6835,8 @@ void LLPipeline::resetVertexBuffers(LLDrawable* drawable) facep->clearVertexBuffer(); } } + + LOG_GLERROR("LLPipeline::resetVertexBuffers()"); } void LLPipeline::renderObjects(U32 type, bool texture, bool batch_texture, bool rigged) @@ -6811,6 +6856,7 @@ void LLPipeline::renderObjects(U32 type, bool texture, bool batch_texture, bool gGL.loadMatrix(gGLModelView); gGLLastMatrix = NULL; + LOG_GLERROR("LLPipeline::renderObjects()"); } void LLPipeline::renderGLTFObjects(U32 type, bool texture, bool rigged) @@ -6839,6 +6885,7 @@ void LLPipeline::renderGLTFObjects(U32 type, bool texture, bool rigged) { LL::GLTFSceneManager::instance().render(true, true); } + LOG_GLERROR("LLPipeline::renderGLTFObjects()"); } // Currently only used for shadows -Cosmic,2023-04-19 @@ -6919,6 +6966,7 @@ void LLPipeline::renderAlphaObjects(bool rigged) gGL.loadMatrix(gGLModelView); gGLLastMatrix = NULL; + LOG_GLERROR("LLPipeline::renderAlphaObjects()"); } // Currently only used for shadows -Cosmic,2023-04-19 @@ -6937,6 +6985,7 @@ void LLPipeline::renderMaskedObjects(U32 type, bool texture, bool batch_texture, } gGL.loadMatrix(gGLModelView); gGLLastMatrix = NULL; + LOG_GLERROR("LLPipeline::renderMaskedObjects()"); } // Currently only used for shadows -Cosmic,2023-04-19 @@ -6955,6 +7004,7 @@ void LLPipeline::renderFullbrightMaskedObjects(U32 type, bool texture, bool batc } gGL.loadMatrix(gGLModelView); gGLLastMatrix = NULL; + LOG_GLERROR("LLPipeline::renderFullbrightMaskedObjects()"); } void apply_cube_face_rotation(U32 face) @@ -7017,11 +7067,12 @@ void LLPipeline::bindScreenToTexture() } -static LLTrace::BlockTimerStatHandle FTM_RENDER_BLOOM("Bloom"); +static LLTrace::BlockTimerStatHandle FTM_RENDER_BLOOM("Post processing"); void LLPipeline::visualizeBuffers(LLRenderTarget* src, LLRenderTarget* dst, U32 bufferIndex) { - dst->bindTarget(); + dst->bindTarget("visualizeBuffers", 1); + dst->clear(); gDeferredBufferVisualProgram.bind(); gDeferredBufferVisualProgram.bindTexture(LLShaderMgr::DEFERRED_DIFFUSE, src, false, LLTexUnit::TFO_BILINEAR, bufferIndex); @@ -7031,8 +7082,7 @@ void LLPipeline::visualizeBuffers(LLRenderTarget* src, LLRenderTarget* dst, U32 else gDeferredBufferVisualProgram.uniform1f(mipLevel, 8); - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); gDeferredBufferVisualProgram.unbind(); dst->flush(); } @@ -7043,7 +7093,8 @@ void LLPipeline::generateLuminance(LLRenderTarget* src, LLRenderTarget* dst) { LL_PROFILE_GPU_ZONE("luminance sample"); - dst->bindTarget(); + dst->bindTarget("generateLuminance", 0); + dst->clear(); LLGLDepthTest depth(GL_FALSE, GL_FALSE); @@ -7074,14 +7125,15 @@ void LLPipeline::generateLuminance(LLRenderTarget* src, LLRenderTarget* dst) static LLStaticHashedString diffuse_luminance_scale_s("diffuse_luminance_scale"); gLuminanceProgram.uniform1f(diffuse_luminance_scale_s, diffuse_luminance_scale); - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); dst->flush(); // note -- unbind AFTER the glGenerateMipMap so time in generatemipmap can be profiled under "Luminance" // also note -- keep an eye on the performance of glGenerateMipmap, might need to replace it with a mip generation shader gLuminanceProgram.unbind(); } + + LOG_GLERROR("LLPipeline::generateLuminance()"); } void LLPipeline::generateExposure(LLRenderTarget* src, LLRenderTarget* dst, bool use_history) { @@ -7092,17 +7144,15 @@ void LLPipeline::generateExposure(LLRenderTarget* src, LLRenderTarget* dst, bool if (use_history) { // copy last frame's exposure into mLastExposure - mLastExposure.bindTarget(); + mLastExposure.bindTarget("mLastExposure", 1); gCopyProgram.bind(); gGL.getTexUnit(0)->bind(dst); - - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); - + renderTriangle(); mLastExposure.flush(); } - dst->bindTarget(); + dst->bindTarget("generateExposure", 1); + //dst->clear(); LLGLDepthTest depth(GL_FALSE, GL_FALSE); @@ -7185,23 +7235,24 @@ void LLPipeline::generateExposure(LLRenderTarget* src, LLRenderTarget* dst, bool shader->uniform4f(dynamic_exposure_params, dynamic_exposure_coefficient, exp_min, exp_max, dynamic_exposure_speed_error); shader->uniform4f(dynamic_exposure_params2, sky->getHDROffset(should_auto_adjust()), exp_min, exp_max, dynamic_exposure_speed_target); - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); if (use_history) { - gGL.getTexUnit(channel)->unbind(mLastExposure.getUsage()); + //gGL.getTexUnit(channel)->unbind(mLastExposure.getUsage()); } shader->unbind(); dst->flush(); } + + LOG_GLERROR("LLPipeline::generateExposure()"); } extern LLPointer<LLImageGL> gEXRImage; void LLPipeline::tonemap(LLRenderTarget* src, LLRenderTarget* dst) { - dst->bindTarget(); + dst->bindTarget("tonemap", 1); // gamma correct lighting { LL_PROFILE_GPU_ZONE("tonemap"); @@ -7221,7 +7272,7 @@ void LLPipeline::tonemap(LLRenderTarget* src, LLRenderTarget* dst) shader.bind(); - S32 channel = 0; + //S32 channel = 0; shader.bindTexture(LLShaderMgr::DEFERRED_DIFFUSE, src, false, LLTexUnit::TFO_POINT); @@ -7243,18 +7294,19 @@ void LLPipeline::tonemap(LLRenderTarget* src, LLRenderTarget* dst) shader.uniform1i(tonemap_type, tonemap_type_setting); shader.uniform1f(tonemap_mix, psky->getTonemapMix(should_auto_adjust())); - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); - gGL.getTexUnit(channel)->unbind(src->getUsage()); + //gGL.getTexUnit(channel)->unbind(src->getUsage()); shader.unbind(); } dst->flush(); + LOG_GLERROR("LLPipeline::tonemap()"); } void LLPipeline::gammaCorrect(LLRenderTarget* src, LLRenderTarget* dst) { - dst->bindTarget(); + dst->bindTarget("gammaCorrect", 1); + dst->clear(); // gamma correct lighting { LL_PROFILE_GPU_ZONE("gamma correct"); @@ -7272,12 +7324,12 @@ void LLPipeline::gammaCorrect(LLRenderTarget* src, LLRenderTarget* dst) shader.bindTexture(LLShaderMgr::DEFERRED_DIFFUSE, src, false, LLTexUnit::TFO_POINT); shader.uniform2f(LLShaderMgr::DEFERRED_SCREEN_RES, (GLfloat)src->getWidth(), (GLfloat)src->getHeight()); - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); shader.unbind(); } dst->flush(); + LOG_GLERROR("LLPipeline::gammaCorrect()"); } void LLPipeline::copyScreenSpaceReflections(LLRenderTarget* src, LLRenderTarget* dst) @@ -7290,7 +7342,7 @@ void LLPipeline::copyScreenSpaceReflections(LLRenderTarget* src, LLRenderTarget* LLRenderTarget& depth_src = mRT->deferredScreen; - dst->bindTarget(); + dst->bindTarget("copyScreenSpaceReflections", 1); dst->clear(); gCopyDepthProgram.bind(); @@ -7300,11 +7352,11 @@ void LLPipeline::copyScreenSpaceReflections(LLRenderTarget* src, LLRenderTarget* gGL.getTexUnit(diff_map)->bind(src); gGL.getTexUnit(depth_map)->bind(&depth_src, true); - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); dst->flush(); } + LOG_GLERROR("LLPipeline::copyScreenSpaceReflection()"); } void LLPipeline::generateGlow(LLRenderTarget* src) @@ -7312,7 +7364,9 @@ void LLPipeline::generateGlow(LLRenderTarget* src) if (sRenderGlow) { LL_PROFILE_GPU_ZONE("glow"); - mGlow[2].bindTarget(); + LL_RECORD_BLOCK_TIME(FTM_RENDER_GLOW); + + mGlow[2].bindTarget("mGlow[2]", 1); mGlow[2].clear(); gGlowExtractProgram.bind(); @@ -7352,8 +7406,8 @@ void LLPipeline::generateGlow(LLRenderTarget* src) gGL.color4f(1, 1, 1, 1); gPipeline.enableLightsFullbright(); - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); + gGlowExtractProgram.unbindTexture(LLShaderMgr::GLOW_NOISE_MAP); mGlow[2].flush(); } @@ -7379,7 +7433,7 @@ void LLPipeline::generateGlow(LLRenderTarget* src) for (S32 i = 0; i < kernel; i++) { - mGlow[i % 2].bindTarget(); + mGlow[i % 2].bindTarget("mGlow[i % 2]", 1); mGlow[i % 2].clear(); if (i == 0) @@ -7400,8 +7454,7 @@ void LLPipeline::generateGlow(LLRenderTarget* src) gGlowProgram.uniform2f(LLShaderMgr::GLOW_DELTA, 0, delta); } - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); mGlow[i % 2].flush(); } @@ -7411,25 +7464,26 @@ void LLPipeline::generateGlow(LLRenderTarget* src) } else // !sRenderGlow, skip the glow ping-pong and just clear the result target { - mGlow[1].bindTarget(); + mGlow[1].bindTarget("mGlow[1]", 1); mGlow[1].clear(); mGlow[1].flush(); } + LOG_GLERROR("LLPipeline::generateGlow()"); } -void LLPipeline::applyCAS(LLRenderTarget* src, LLRenderTarget* dst) +bool LLPipeline::applyCAS(LLRenderTarget* src, LLRenderTarget* dst) { static LLCachedControl<F32> cas_sharpness(gSavedSettings, "RenderCASSharpness", 0.4f); if (cas_sharpness == 0.0f || !gCASProgram.isComplete()) { - gPipeline.copyRenderTarget(src, dst); - return; + return false; } LLGLSLShader* sharpen_shader = &gCASProgram; // Bind setup: - dst->bindTarget(); + dst->bindTarget("applyCAS", 1); + dst->clear(); sharpen_shader->bind(); @@ -7451,32 +7505,33 @@ void LLPipeline::applyCAS(LLRenderTarget* src, LLRenderTarget* dst) sharpen_shader->uniform2f(out_screen_res, (AF1)dst->getWidth(), (AF1)dst->getHeight()); } - sharpen_shader->bindTexture(LLShaderMgr::DEFERRED_DIFFUSE, src, false, LLTexUnit::TFO_POINT); - - // Draw - gPipeline.mScreenTriangleVB->setBuffer(); - gPipeline.mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); - + S32 channel = sharpen_shader->bindTexture(LLShaderMgr::DEFERRED_DIFFUSE, src, false, LLTexUnit::TFO_POINT); + renderTriangle(); + sharpen_shader->unbindTexture(channel); sharpen_shader->unbind(); dst->flush(); + + return true; } -void LLPipeline::applyFXAA(LLRenderTarget* src, LLRenderTarget* dst) +bool LLPipeline::applyFXAA(LLRenderTarget* src, LLRenderTarget* dst) { { llassert(!gCubeSnapshot); bool multisample = RenderFSAAType == 1 && gFXAAProgram[0].isComplete() && mFXAAMap.isComplete(); - // Present everything. - if (multisample) + if(!multisample) return false; + { LL_PROFILE_GPU_ZONE("aa"); S32 width = dst->getWidth(); S32 height = dst->getHeight(); + //LL_WARNS() << "dst width=" << width << LL_ENDL; + // bake out texture2D with RGBL for FXAA shader - mFXAAMap.bindTarget(); + mFXAAMap.bindTarget("applyFXAA", 1); mFXAAMap.clear(GL_COLOR_BUFFER_BIT); LLGLSLShader* shader = &gGlowCombineFXAAProgram; @@ -7490,8 +7545,7 @@ void LLPipeline::applyFXAA(LLRenderTarget* src, LLRenderTarget* dst) { LLGLDepthTest depth_test(GL_TRUE, GL_TRUE, GL_ALWAYS); - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); } shader->disableTexture(LLShaderMgr::DEFERRED_DIFFUSE, src->getUsage()); @@ -7499,7 +7553,8 @@ void LLPipeline::applyFXAA(LLRenderTarget* src, LLRenderTarget* dst) mFXAAMap.flush(); - dst->bindTarget(); + dst->bindTarget("applyFXAA", 1); + dst->clear(); static LLCachedControl<U32> aa_quality(gSavedSettings, "RenderFSAASamples", 0U); U32 fsaa_quality = std::clamp(aa_quality(), 0U, 3U); @@ -7513,15 +7568,20 @@ void LLPipeline::applyFXAA(LLRenderTarget* src, LLRenderTarget* dst) mFXAAMap.bindTexture(0, channel, LLTexUnit::TFO_BILINEAR); } +/* gGLViewport[0] = gViewerWindow->getWorldViewRectRaw().mLeft; gGLViewport[1] = gViewerWindow->getWorldViewRectRaw().mBottom; gGLViewport[2] = gViewerWindow->getWorldViewRectRaw().getWidth(); gGLViewport[3] = gViewerWindow->getWorldViewRectRaw().getHeight(); glViewport(gGLViewport[0], gGLViewport[1], gGLViewport[2], gGLViewport[3]); +*/ F32 scale_x = (F32)width / mFXAAMap.getWidth(); F32 scale_y = (F32)height / mFXAAMap.getHeight(); + + //LL_WARNS() << "vp width=" << gGLViewport[2] << " scale=" << scale_x << LL_ENDL; + shader->uniform2f(LLShaderMgr::FXAA_TC_SCALE, scale_x, scale_y); shader->uniform2f(LLShaderMgr::FXAA_RCP_SCREEN_RES, 1.f / width * scale_x, 1.f / height * scale_y); shader->uniform4f(LLShaderMgr::FXAA_RCP_FRAME_OPT, -0.5f / width * scale_x, -0.5f / height * scale_y, @@ -7534,17 +7594,20 @@ void LLPipeline::applyFXAA(LLRenderTarget* src, LLRenderTarget* dst) S32 depth_channel = shader->getTextureChannel(LLShaderMgr::DEFERRED_DEPTH); gGL.getTexUnit(depth_channel)->bind(&mRT->deferredScreen, true); - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); + } + + if (channel > -1) + { + shader->unbindTexture(channel); } shader->unbind(); dst->flush(); } - else { - copyRenderTarget(src, dst); - } } + + return true; } void LLPipeline::generateSMAABuffers(LLRenderTarget* src) @@ -7576,7 +7639,7 @@ void LLPipeline::generateSMAABuffers(LLRenderTarget* src) LLRenderTarget& dest = mFXAAMap; LLGLSLShader& edge_shader = gSMAAEdgeDetectProgram[fsaa_quality]; - dest.bindTarget(); + dest.bindTarget("generateSMAABuffers", 1); dest.clear(GL_COLOR_BUFFER_BIT); edge_shader.bind(); @@ -7587,14 +7650,17 @@ void LLPipeline::generateSMAABuffers(LLRenderTarget* src) { if (!use_sample) { - src->bindTexture(0, channel, LLTexUnit::TFO_POINT); - gGL.getTexUnit(channel)->setTextureAddressMode(LLTexUnit::TAM_CLAMP); + //src->bindTexture(0, channel, LLTexUnit::TFO_POINT); + //gGL.getTexUnit(channel)->setTextureAddressMode(LLTexUnit::TAM_CLAMP); + src->bindTexture(0, channel, LLTexUnit::TFO_BILINEAR); } else { gGL.getTexUnit(channel)->bindManual(LLTexUnit::TT_TEXTURE, mSMAASampleMap); - gGL.getTexUnit(channel)->setTextureAddressMode(LLTexUnit::TAM_CLAMP); + //gGL.getTexUnit(channel)->setTextureAddressMode(LLTexUnit::TAM_CLAMP); + gGL.getTexUnit(channel)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR); } + gGL.getTexUnit(channel)->setTextureAddressMode(LLTexUnit::TAM_CLAMP); } //if (use_stencil) @@ -7603,13 +7669,13 @@ void LLPipeline::generateSMAABuffers(LLRenderTarget* src) // glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE); // glStencilMask(0xFF); //} - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + + renderTriangle(); edge_shader.unbind(); dest.flush(); - gGL.getTexUnit(channel)->unbindFast(LLTexUnit::TT_TEXTURE); + //gGL.getTexUnit(channel)->unbindFast(LLTexUnit::TT_TEXTURE); } { @@ -7619,7 +7685,7 @@ void LLPipeline::generateSMAABuffers(LLRenderTarget* src) LLRenderTarget& dest = mSMAABlendBuffer; LLGLSLShader& blend_weights_shader = gSMAABlendWeightsProgram[fsaa_quality]; - dest.bindTarget(); + dest.bindTarget("mSMAABlendBuffer", 1); dest.clear(GL_COLOR_BUFFER_BIT); blend_weights_shader.bind(); @@ -7651,8 +7717,8 @@ void LLPipeline::generateSMAABuffers(LLRenderTarget* src) // glStencilFunc(GL_EQUAL, 1, 0xFF); // glStencilMask(0x00); //} - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + + renderTriangle(); //if (use_stencil) //{ // glStencilFunc(GL_ALWAYS, 0, 0xFF); @@ -7664,9 +7730,10 @@ void LLPipeline::generateSMAABuffers(LLRenderTarget* src) gGL.getTexUnit(search_tex_channel)->unbindFast(LLTexUnit::TT_TEXTURE); } } + LOG_GLERROR("LLPipeline::generateSMAABuffers()"); } -void LLPipeline::applySMAA(LLRenderTarget* src, LLRenderTarget* dst) +bool LLPipeline::applySMAA(LLRenderTarget* src, LLRenderTarget* dst) { llassert(!gCubeSnapshot); @@ -7677,10 +7744,13 @@ void LLPipeline::applySMAA(LLRenderTarget* src, LLRenderTarget* dst) multisample = gSMAAEdgeDetectProgram[0].isComplete() && mFXAAMap.isComplete() && mSMAABlendBuffer.isComplete(); } - // Present everything. - if (multisample) + if(!multisample) return false; + { LL_PROFILE_GPU_ZONE("aa"); + + generateSMAABuffers(src); + static LLCachedControl<U32> aa_quality(gSavedSettings, "RenderFSAASamples", 0U); U32 fsaa_quality = std::clamp(aa_quality(), 0U, 3U); @@ -7701,7 +7771,7 @@ void LLPipeline::applySMAA(LLRenderTarget* src, LLRenderTarget* dst) LLRenderTarget* bound_target = dst; LLGLSLShader& blend_shader = gSMAANeighborhoodBlendProgram[fsaa_quality]; - bound_target->bindTarget(); + bound_target->bindTarget("applySMAA", 1); bound_target->clear(GL_COLOR_BUFFER_BIT); blend_shader.bind(); @@ -7720,8 +7790,7 @@ void LLPipeline::applySMAA(LLRenderTarget* src, LLRenderTarget* dst) mSMAABlendBuffer.bindTexture(0, blend_channel, LLTexUnit::TFO_BILINEAR); } - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); bound_target->flush(); blend_shader.unbind(); @@ -7729,27 +7798,23 @@ void LLPipeline::applySMAA(LLRenderTarget* src, LLRenderTarget* dst) gGL.getTexUnit(blend_channel)->unbindFast(LLTexUnit::TT_TEXTURE); } } - else - { - copyRenderTarget(src, dst); - } + + LOG_GLERROR("LLPipeline::applySMAA()"); + return true; } void LLPipeline::copyRenderTarget(LLRenderTarget* src, LLRenderTarget* dst) { LL_PROFILE_GPU_ZONE("copyRenderTarget"); - dst->bindTarget(); - + dst->bindTarget("copyRenderTarget", 1); + dst->clear(GL_COLOR_BUFFER_BIT); gDeferredPostNoDoFProgram.bind(); gDeferredPostNoDoFProgram.bindTexture(LLShaderMgr::DEFERRED_DIFFUSE, src); - gDeferredPostNoDoFProgram.bindTexture(LLShaderMgr::DEFERRED_DEPTH, &mRT->deferredScreen, true); + //gDeferredPostNoDoFProgram.bindTexture(LLShaderMgr::DEFERRED_DEPTH, &mRT->deferredScreen, true); - { - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); - } + renderTriangle(); gDeferredPostNoDoFProgram.unbind(); @@ -7760,7 +7825,7 @@ void LLPipeline::combineGlow(LLRenderTarget* src, LLRenderTarget* dst) { // Go ahead and do our glow combine here in our destination. We blit this later into the front buffer. - dst->bindTarget(); + dst->bindTarget("combineGlow", 1); { @@ -7769,14 +7834,14 @@ void LLPipeline::combineGlow(LLRenderTarget* src, LLRenderTarget* dst) gGlowCombineProgram.bindTexture(LLShaderMgr::DEFERRED_DIFFUSE, src); gGlowCombineProgram.bindTexture(LLShaderMgr::DEFERRED_EMISSIVE, &mGlow[1]); - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); } dst->flush(); + LOG_GLERROR("LLPipeline::combineGlow()"); } -void LLPipeline::renderDoF(LLRenderTarget* src, LLRenderTarget* dst) +bool LLPipeline::renderDoF(LLRenderTarget* src, LLRenderTarget* dst) { { bool dof_enabled = @@ -7784,6 +7849,8 @@ void LLPipeline::renderDoF(LLRenderTarget* src, LLRenderTarget* dst) RenderDepthOfField && !gCubeSnapshot; + if(!dof_enabled) return false; + gViewerWindow->setup3DViewport(); if (dof_enabled) @@ -7892,7 +7959,7 @@ void LLPipeline::renderDoF(LLRenderTarget* src, LLRenderTarget* dst) F32 magnification = focal_length / (subject_distance - focal_length); { // build diffuse+bloom+CoF - mRT->deferredLight.bindTarget(); + mRT->deferredLight.bindTarget("renderDOF", 1); gDeferredCoFProgram.bind(); @@ -7909,8 +7976,8 @@ void LLPipeline::renderDoF(LLRenderTarget* src, LLRenderTarget* dst) gDeferredCoFProgram.uniform1f(LLShaderMgr::DOF_MAX_COF, CameraMaxCoF); gDeferredCoFProgram.uniform1f(LLShaderMgr::DOF_RES_SCALE, CameraDoFResScale); - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); + gDeferredCoFProgram.unbind(); mRT->deferredLight.flush(); } @@ -7919,7 +7986,7 @@ void LLPipeline::renderDoF(LLRenderTarget* src, LLRenderTarget* dst) U32 dof_height = (U32)(mRT->screen.getHeight() * CameraDoFResScale); { // perform DoF sampling at half-res (preserve alpha channel) - src->bindTarget(); + src->bindTarget("DoF sampling", 1); glViewport(0, 0, dof_width, dof_height); gGL.setColorMask(true, false); @@ -7931,8 +7998,7 @@ void LLPipeline::renderDoF(LLRenderTarget* src, LLRenderTarget* dst) gDeferredPostProgram.uniform1f(LLShaderMgr::DOF_MAX_COF, CameraMaxCoF); gDeferredPostProgram.uniform1f(LLShaderMgr::DOF_RES_SCALE, CameraDoFResScale); - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); gDeferredPostProgram.unbind(); @@ -7942,7 +8008,7 @@ void LLPipeline::renderDoF(LLRenderTarget* src, LLRenderTarget* dst) { // combine result based on alpha - dst->bindTarget(); + dst->bindTarget("DoF combine", 1); glViewport(0, 0, dst->getWidth(), dst->getHeight()); gDeferredDoFCombineProgram.bind(); @@ -7955,19 +8021,130 @@ void LLPipeline::renderDoF(LLRenderTarget* src, LLRenderTarget* dst) gDeferredDoFCombineProgram.uniform1f(LLShaderMgr::DOF_WIDTH, (dof_width - 1) / (F32)src->getWidth()); gDeferredDoFCombineProgram.uniform1f(LLShaderMgr::DOF_HEIGHT, (dof_height - 1) / (F32)src->getHeight()); - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); - gDeferredDoFCombineProgram.unbind(); + renderTriangle(); + gDeferredDoFCombineProgram.unbind(); dst->flush(); } } - else - { - copyRenderTarget(src, dst); - } } + + return true; +} + +bool LLPipeline::renderBloom(LLRenderTarget* src, LLRenderTarget* dst) +{ + static LLCachedControl<U32> mp_render_bloom(gSavedSettings, "MPRenderBloom", 0); + + if(mp_render_bloom < 1) return false; + + static LLCachedControl<F32> mp_bloom_extract_brightness(gSavedSettings, "MPBloomExtractBrightness", 0.10); + static LLCachedControl<F32> mp_bloom_radius(gSavedSettings, "MPBloomBlurRadius", 1.5); + static LLCachedControl<F32> mp_bloom_radius_add(gSavedSettings, "MPBloomBlurRadiusAdd", 0); + static LLCachedControl<F32> mp_bloom_strength(gSavedSettings, "MPBloomStrength", 1.0); + static LLCachedControl<F32> mp_bloom_metal(gSavedSettings, "MPBloomExtractMetal", 0.2); + static LLCachedControl<F32> mp_bloom_nonmetal(gSavedSettings, "MPBloomExtractNonMetal", 0.2); + + LLGLDepthTest depth(GL_FALSE, GL_FALSE); + LLGLDisable blend(GL_BLEND); + + mBloomMap.bindTarget("mBloomMap", 1); + + glClearColor(0, 0, 0, 0); + mBloomMap.clear(); + + gBloomExtractProgram.bind(); + gBloomExtractProgram.bindTexture(LLShaderMgr::DIFFUSE_MAP, src); + gBloomExtractProgram.bindTexture(LLShaderMgr::BLOOM_EXTRACT_ORM, &mRT->deferredScreen, false, LLTexUnit::TFO_POINT, 1); + gBloomExtractProgram.bindTexture(LLShaderMgr::BLOOM_EXTRACT_EMISSIVE, &mGlow[1], false, LLTexUnit::TFO_POINT, 0); + gBloomExtractProgram.bindTexture(LLShaderMgr::BLOOM_EXTRACT_EMISSIVE2, &mRT->deferredScreen, false, LLTexUnit::TFO_POINT, 3); + + gBloomExtractProgram.uniform1f(LLShaderMgr::BLOOM_EXTRACT_BRIGHTNESS, 1.0 - mp_bloom_extract_brightness); + gBloomExtractProgram.uniform1f(LLShaderMgr::BLOOM_EXTRACT_METAL, mp_bloom_metal); + gBloomExtractProgram.uniform1f(LLShaderMgr::BLOOM_EXTRACT_NONMETAL, mp_bloom_nonmetal); + + renderTriangle(); + + gBloomExtractProgram.unbindTexture(LLShaderMgr::DIFFUSE_MAP); + gBloomExtractProgram.unbindTexture(LLShaderMgr::BLOOM_EXTRACT_ORM); + gBloomExtractProgram.unbindTexture(LLShaderMgr::BLOOM_EXTRACT_EMISSIVE); + gBloomExtractProgram.unbindTexture(LLShaderMgr::BLOOM_EXTRACT_EMISSIVE2); + + gBloomExtractProgram.unbind(); + mBloomMap.flush(); + + + // ping pong blur + + S16 horizontal = 1, first_iteration = true; + unsigned int amount = mp_render_bloom; + if(amount > 10) amount = 10; + + F32 radius = mp_bloom_radius; + + gBloomBlurProgram.bind(); + + + // Iteration 0 + + gBloomBlurProgram.uniform1f(LLShaderMgr::BLOOM_BLUR_RADIUS, radius); + + mBloomBlur[0].bindTarget("", 1); + //mBloomBlur[0].clear(); + gBloomBlurProgram.uniform1i( LLShaderMgr::BLOOM_BLURH, 0); + gBloomBlurProgram.bindTexture( LLShaderMgr::BLOOM_EMAP, &mBloomMap); + renderTriangle(); + mBloomBlur[0].flush(); + + mBloomBlur[1].bindTarget("", 1); + gBloomBlurProgram.uniform1i( LLShaderMgr::BLOOM_BLURH, 1); + gBloomBlurProgram.bindTexture( LLShaderMgr::BLOOM_EMAP, &mBloomBlur[0]); + renderTriangle(); + mBloomBlur[1].flush(); + + + // additional iterations + + for (unsigned int i = 1; i < amount; i++) + { + radius += mp_bloom_radius_add; + gBloomBlurProgram.uniform1f(LLShaderMgr::BLOOM_BLUR_RADIUS, radius); + + mBloomBlur[0].bindTarget("", 1); + gBloomBlurProgram.uniform1i( LLShaderMgr::BLOOM_BLURH, 0); + gBloomBlurProgram.bindTexture( LLShaderMgr::BLOOM_EMAP, &mBloomBlur[1]); + renderTriangle(); + mBloomBlur[0].flush(); + + mBloomBlur[1].bindTarget("", 1); + gBloomBlurProgram.uniform1i( LLShaderMgr::BLOOM_BLURH, 1); + gBloomBlurProgram.bindTexture( LLShaderMgr::BLOOM_EMAP, &mBloomBlur[0]); + renderTriangle(); + mBloomBlur[1].flush(); + } + + gBloomBlurProgram.unbindTexture(LLShaderMgr::BLOOM_EMAP); + gBloomBlurProgram.unbind(); + + + // combine + + dst->bindTarget("bloom combine", 1); + //dst->clear(); + + gBloomCombineProgram.bind(); + + gBloomCombineProgram.bindTexture(LLShaderMgr::DIFFUSE_MAP, src); + gBloomCombineProgram.bindTexture(LLShaderMgr::BLOOM_BMAP, &mBloomBlur[1]); + gBloomCombineProgram.uniform1f(LLShaderMgr::BLOOM_STRENGTH, mp_bloom_strength); + + renderTriangle(); + + gBloomCombineProgram.unbind(); + dst->flush(); + + return true; } void LLPipeline::renderFinalize() @@ -7986,7 +8163,11 @@ void LLPipeline::renderFinalize() LLGLDisable blend(GL_BLEND); LLGLDisable cull(GL_CULL_FACE); - enableLightsFullbright(); + gGLViewport[0] = gViewerWindow->getWorldViewRectRaw().mLeft; + gGLViewport[1] = gViewerWindow->getWorldViewRectRaw().mBottom; + gGLViewport[2] = gViewerWindow->getWorldViewRectRaw().getWidth(); + gGLViewport[3] = gViewerWindow->getWorldViewRectRaw().getHeight(); + glViewport(gGLViewport[0], gGLViewport[1], gGLViewport[2], gGLViewport[3]); gGL.setColorMask(true, true); glClearColor(0, 0, 0, 0); @@ -7994,6 +8175,10 @@ void LLPipeline::renderFinalize() static LLCachedControl<bool> has_hdr(gSavedSettings, "RenderHDREnabled", true); bool hdr = gGLManager.mGLVersion > 4.05f && has_hdr(); + U16 activeRT = 0; + + LLRenderTarget* postHDRBuffer = &mRT->screen; + if (hdr) { copyScreenSpaceReflections(&mRT->screen, &mSceneMap); @@ -8002,38 +8187,49 @@ void LLPipeline::renderFinalize() generateExposure(&mLuminanceMap, &mExposureMap); - tonemap(&mRT->screen, &mPostMap); + tonemap(&mRT->screen, &mRT->deferredLight); + + postHDRBuffer = &mRT->deferredLight; - applyCAS(&mPostMap, &mRT->screen); } - generateSMAABuffers(&mRT->screen); + gammaCorrect(postHDRBuffer, &mPostMaps[0]); - gammaCorrect(&mRT->screen, &mPostMap); + generateGlow(&mPostMaps[0]); LLVertexBuffer::unbind(); - applySMAA(&mPostMap, &mRT->screen); + if(renderBloom(&mPostMaps[activeRT], &mPostMaps[1 - activeRT])) + { + activeRT = 1 - activeRT; + } - generateGlow(&mRT->screen); + combineGlow(&mPostMaps[activeRT], &mPostMaps[1 - activeRT]); + activeRT = 1 - activeRT; - combineGlow(&mRT->screen, &mPostMap); + if(applyFXAA(&mPostMaps[activeRT], &mPostMaps[1 - activeRT])) + { + activeRT = 1 - activeRT; + } - gGLViewport[0] = gViewerWindow->getWorldViewRectRaw().mLeft; - gGLViewport[1] = gViewerWindow->getWorldViewRectRaw().mBottom; - gGLViewport[2] = gViewerWindow->getWorldViewRectRaw().getWidth(); - gGLViewport[3] = gViewerWindow->getWorldViewRectRaw().getHeight(); - glViewport(gGLViewport[0], gGLViewport[1], gGLViewport[2], gGLViewport[3]); + if(applyCAS(&mPostMaps[activeRT], &mPostMaps[1 - activeRT])) + { + activeRT = 1 - activeRT; + } + + if(applySMAA(&mPostMaps[activeRT], &mPostMaps[1 - activeRT])) + { + activeRT = 1 - activeRT; + } - renderDoF(&mPostMap, &mRT->screen); - LLRenderTarget* finalBuffer = &mRT->screen; - if (RenderFSAAType == 1) + if(renderDoF(&mPostMaps[activeRT], &mPostMaps[1 - activeRT])) { - applyFXAA(&mRT->screen, &mPostMap); - finalBuffer = &mPostMap; + activeRT = 1 - activeRT; } + LLRenderTarget* finalBuffer = &mPostMaps[activeRT]; + if (RenderBufferVisualization > -1) { switch (RenderBufferVisualization) @@ -8063,6 +8259,27 @@ void LLPipeline::renderFinalize() } break; } + case 7: + visualizeBuffers(&mBloomMap, finalBuffer, 0); + break; + case 8: + visualizeBuffers(&mBloomBlur[1], finalBuffer, 0); + break; + case 9: + visualizeBuffers(&mPostMaps[activeRT], finalBuffer, 0); + break; + case 10: + visualizeBuffers(&mGlow[0], finalBuffer, 0); + break; + case 11: + visualizeBuffers(&mGlow[1], finalBuffer, 0); + break; + case 12: + visualizeBuffers(&mGlow[2], finalBuffer, 0); + break; + case 13: + visualizeBuffers(&mSceneMap, finalBuffer, 0); + break; default: break; } @@ -8080,8 +8297,7 @@ void LLPipeline::renderFinalize() { LLGLDepthTest depth_test(GL_TRUE, GL_TRUE, GL_ALWAYS); - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); } gDeferredPostNoDoFNoiseProgram.unbind(); @@ -8106,6 +8322,7 @@ void LLPipeline::renderFinalize() // flush calls made to "addTrianglesDrawn" so far to stats machinery recordTrianglesDrawn(); + LOG_GLERROR("LLPipeline::renderFinalize()"); } void LLPipeline::bindLightFunc(LLGLSLShader& shader) @@ -8125,6 +8342,8 @@ void LLPipeline::bindLightFunc(LLGLSLShader& shader) void LLPipeline::bindShadowMaps(LLGLSLShader& shader) { + LOG_GLERROR("bindShadowMaps() 1"); + for (U32 i = 0; i < 4; i++) { LLRenderTarget* shadow_target = getSunShadowTarget(i); @@ -8138,6 +8357,8 @@ void LLPipeline::bindShadowMaps(LLGLSLShader& shader) } } + LOG_GLERROR("bindShadowMaps() 2"); + for (U32 i = 4; i < 6; i++) { S32 channel = shader.enableTexture(LLShaderMgr::DEFERRED_SHADOW0 + i); @@ -8246,7 +8467,7 @@ void LLPipeline::bindDeferredShader(LLGLSLShader& shader, LLRenderTarget* light_ bindLightFunc(shader); - stop_glerror(); + LOG_GLERROR("bindDeferredShader()"); light_target = light_target ? light_target : deferred_light_target; channel = shader.enableTexture(LLShaderMgr::DEFERRED_LIGHT, light_target->getUsage()); @@ -8262,11 +8483,11 @@ void LLPipeline::bindDeferredShader(LLGLSLShader& shader, LLRenderTarget* light_ } } - stop_glerror(); + LOG_GLERROR("bindDeferredShader() 2"); bindShadowMaps(shader); - stop_glerror(); + LOG_GLERROR("bindDeferredShader() 3"); F32 mat[16*6]; for (U32 i = 0; i < 16; i++) @@ -8281,7 +8502,7 @@ void LLPipeline::bindDeferredShader(LLGLSLShader& shader, LLRenderTarget* light_ shader.uniformMatrix4fv(LLShaderMgr::DEFERRED_SHADOW_MATRIX, 6, false, mat); - stop_glerror(); + LOG_GLERROR("bindDeferredShader() 4"); if (!LLPipeline::sReflectionProbesEnabled) { @@ -8435,6 +8656,8 @@ void LLPipeline::renderDeferredLighting() return; } + LOG_GLERROR("renderDeferredLighting begin"); + llassert(!sRenderingHUDs); F32 light_scale = 1.f; @@ -8479,7 +8702,7 @@ void LLPipeline::renderDeferredLighting() if ((RenderDeferredSSAO && !gCubeSnapshot) || RenderShadowDetail > 0) { LL_PROFILE_GPU_ZONE("sun program"); - deferred_light_target->bindTarget(); + deferred_light_target->bindTarget("sun_shader", 1); { // paint shadow/SSAO light map (direct lighting lightmap) LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("renderDeferredLighting - sun shadow"); @@ -8511,7 +8734,7 @@ void LLPipeline::renderDeferredLighting() LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("renderDeferredLighting - soften shadow"); LL_PROFILE_GPU_ZONE("soften shadow"); // blur lightmap - screen_target->bindTarget(); + screen_target->bindTarget("SSAO", 1); glClearColor(1, 1, 1, 1); screen_target->clear(GL_COLOR_BUFFER_BIT); glClearColor(0, 0, 0, 0); @@ -8544,8 +8767,7 @@ void LLPipeline::renderDeferredLighting() { LLGLDisable blend(GL_BLEND); LLGLDepthTest depth(GL_TRUE, GL_FALSE, GL_ALWAYS); - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); } screen_target->flush(); @@ -8553,21 +8775,20 @@ void LLPipeline::renderDeferredLighting() bindDeferredShader(gDeferredBlurLightProgram, screen_target); - deferred_light_target->bindTarget(); + deferred_light_target->bindTarget("blur light", 1); gDeferredBlurLightProgram.uniform2f(sDelta, 0.f, 1.f); { LLGLDisable blend(GL_BLEND); LLGLDepthTest depth(GL_TRUE, GL_FALSE, GL_ALWAYS); - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); } deferred_light_target->flush(); unbindDeferredShader(gDeferredBlurLightProgram); } - screen_target->bindTarget(); + screen_target->bindTarget("renderDeferredLighting screen_target", 1); // clear color buffer here - zeroing alpha (glow) is important or it will accumulate against sky glClearColor(0, 0, 0, 0); screen_target->clear(GL_COLOR_BUFFER_BIT); @@ -8600,8 +8821,7 @@ void LLPipeline::renderDeferredLighting() LLGLDisable blend(GL_BLEND); // full screen blit - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); } unbindDeferredShader(gDeferredSoftenProgram); @@ -8817,8 +9037,7 @@ void LLPipeline::renderDeferredLighting() gDeferredMultiLightProgram[idx].uniform1i(LLShaderMgr::CLASSIC_MODE, (psky->canAutoAdjust()) ? 1 : 0); far_z = 0.f; count = 0; - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); unbindDeferredShader(gDeferredMultiLightProgram[idx]); } } @@ -8854,6 +9073,9 @@ void LLPipeline::renderDeferredLighting() gDeferredMultiSpotLightProgram.uniform1i(LLShaderMgr::CLASSIC_MODE, (psky->canAutoAdjust()) ? 1 : 0); mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + /* + gPipeline.mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + */ } gDeferredMultiSpotLightProgram.disableTexture(LLShaderMgr::DEFERRED_PROJECTION); @@ -8916,11 +9138,14 @@ void LLPipeline::renderDeferredLighting() } } gGL.setColorMask(true, true); + + LOG_GLERROR("renderDeferredLighting end"); } void LLPipeline::doAtmospherics() { LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE; + LOG_GLERROR("doAtmospherics begin"); if (sImpostorRender) { // do not attempt atmospherics on impostors @@ -8938,7 +9163,7 @@ void LLPipeline::doAtmospherics() LLRenderTarget& dst = gPipeline.mWaterDis; mRT->screen.flush(); - dst.bindTarget(); + dst.bindTarget("doAtmospherics dst", 1); gCopyDepthProgram.bind(); S32 diff_map = gCopyDepthProgram.getTextureChannel(LLShaderMgr::DIFFUSE_MAP); @@ -8948,11 +9173,10 @@ void LLPipeline::doAtmospherics() gGL.getTexUnit(depth_map)->bind(&depth_src, true); gGL.setColorMask(false, false); - gPipeline.mScreenTriangleVB->setBuffer(); - gPipeline.mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); dst.flush(); - mRT->screen.bindTarget(); + mRT->screen.bindTarget("atmospherics", 1); } LLGLEnable blend(GL_BLEND); @@ -8974,13 +9198,14 @@ void LLPipeline::doAtmospherics() LLGLDepthTest depth(GL_FALSE); // full screen blit - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); unbindDeferredShader(haze_shader); gGL.setSceneBlendType(LLRender::BT_ALPHA); } + + LOG_GLERROR("doAtmospherics end"); } void LLPipeline::doWaterHaze() @@ -9002,7 +9227,7 @@ void LLPipeline::doWaterHaze() LLRenderTarget& dst = gPipeline.mWaterDis; mRT->screen.flush(); - dst.bindTarget(); + dst.bindTarget("water haze copy depth", 1); gCopyDepthProgram.bind(); S32 diff_map = gCopyDepthProgram.getTextureChannel(LLShaderMgr::DIFFUSE_MAP); @@ -9012,11 +9237,10 @@ void LLPipeline::doWaterHaze() gGL.getTexUnit(depth_map)->bind(&depth_src, true); gGL.setColorMask(false, false); - gPipeline.mScreenTriangleVB->setBuffer(); - gPipeline.mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); dst.flush(); - mRT->screen.bindTarget(); + mRT->screen.bindTarget("water haze", 1); } LLGLEnable blend(GL_BLEND); @@ -9042,8 +9266,7 @@ void LLPipeline::doWaterHaze() LLGLDepthTest depth(GL_FALSE); // full screen blit - mScreenTriangleVB->setBuffer(); - mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3); + renderTriangle(); } else { @@ -9065,11 +9288,13 @@ void LLPipeline::doWaterHaze() gGL.setSceneBlendType(LLRender::BT_ALPHA); } + + LOG_GLERROR("after doWaterHaze()"); } void LLPipeline::doWaterExclusionMask() { - mWaterExclusionMask.bindTarget(); + mWaterExclusionMask.bindTarget("", 1); glClearColor(1, 1, 1, 1); mWaterExclusionMask.clear(); mWaterExclusionPool->render(); @@ -9222,6 +9447,7 @@ void LLPipeline::setupSpotLight(LLGLSLShader& shader, LLDrawable* drawablep) } } + LOG_GLERROR("setupSpotLight() end"); } void LLPipeline::unbindDeferredShader(LLGLSLShader &shader) @@ -9229,7 +9455,7 @@ void LLPipeline::unbindDeferredShader(LLGLSLShader &shader) LLRenderTarget* deferred_target = &mRT->deferredScreen; LLRenderTarget* deferred_light_target = &mRT->deferredLight; - stop_glerror(); + LOG_GLERROR("unbindDeferredShader() begin"); shader.disableTexture(LLShaderMgr::NORMAL_MAP, deferred_target->getUsage()); shader.disableTexture(LLShaderMgr::DEFERRED_DIFFUSE, deferred_target->getUsage()); shader.disableTexture(LLShaderMgr::DEFERRED_SPECULAR, deferred_target->getUsage()); @@ -9278,6 +9504,8 @@ void LLPipeline::unbindDeferredShader(LLGLSLShader &shader) gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE); gGL.getTexUnit(0)->activate(); shader.unbind(); + + LOG_GLERROR("unbindDeferredShader() end"); } void LLPipeline::setEnvMat(LLGLSLShader& shader) @@ -9300,7 +9528,6 @@ void LLPipeline::bindReflectionProbes(LLGLSLShader& shader) S32 channel = shader.enableTexture(LLShaderMgr::REFLECTION_PROBES, LLTexUnit::TT_CUBE_MAP_ARRAY); bool bound = false; - if (channel > -1 && mReflectionMapManager.mTexture.notNull()) { mReflectionMapManager.mTexture->bind(channel); @@ -9333,6 +9560,11 @@ void LLPipeline::bindReflectionProbes(LLGLSLShader& shader) } // reflection probe shaders generally sample the scene map as well for SSR + + //if(RenderScreenSpaceReflections) + //{ + //LL_WARNS() << "binding SSR to reflection maps" << LL_ENDL; + channel = shader.enableTexture(LLShaderMgr::SCENE_MAP); if (channel > -1) { @@ -9358,8 +9590,10 @@ void LLPipeline::bindReflectionProbes(LLGLSLShader& shader) { gGL.getTexUnit(channel)->bind(&mSceneMap, true); } + //} + LOG_GLERROR("bindReflectionProbes() end"); } void LLPipeline::unbindReflectionProbes(LLGLSLShader& shader) @@ -9373,6 +9607,8 @@ void LLPipeline::unbindReflectionProbes(LLGLSLShader& shader) gGL.getTexUnit(channel)->enable(LLTexUnit::TT_TEXTURE); } } + + LOG_GLERROR("unbindReflectionProbes() end"); } @@ -9431,11 +9667,13 @@ static LLTrace::BlockTimerStatHandle FTM_SHADOW_ALPHA_MASKED("Alpha Masked"); static LLTrace::BlockTimerStatHandle FTM_SHADOW_ALPHA_BLEND("Alpha Blend"); static LLTrace::BlockTimerStatHandle FTM_SHADOW_ALPHA_TREE("Alpha Tree"); static LLTrace::BlockTimerStatHandle FTM_SHADOW_ALPHA_GRASS("Alpha Grass"); +static LLTrace::BlockTimerStatHandle FTM_SHADOW_ALPHA_MATERIAL("Alpha Material"); static LLTrace::BlockTimerStatHandle FTM_SHADOW_FULLBRIGHT_ALPHA_MASKED("Fullbright Alpha Masked"); void LLPipeline::renderShadow(const glm::mat4& view, const glm::mat4& proj, LLCamera& shadow_cam, LLCullResult& result, bool depth_clamp) { - LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE; //LL_RECORD_BLOCK_TIME(FTM_SHADOW_RENDER); + LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE; + LL_RECORD_BLOCK_TIME(FTM_SHADOW_RENDER); LL_PROFILE_GPU_ZONE("renderShadow"); LLPipeline::sShadowRender = true; @@ -9496,6 +9734,7 @@ void LLPipeline::renderShadow(const glm::mat4& view, const glm::mat4& proj, LLCa } }; + LLVertexBuffer::unbind(); for (int j = 0; j < 2; ++j) // 0 -- static, 1 -- rigged { @@ -9512,8 +9751,10 @@ void LLPipeline::renderShadow(const glm::mat4& view, const glm::mat4& proj, LLCa gGL.setColorMask(false, false); } - LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow simple"); //LL_RECORD_BLOCK_TIME(FTM_SHADOW_SIMPLE); + LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow simple"); LL_PROFILE_GPU_ZONE("shadow simple"); + LL_RECORD_BLOCK_TIME(FTM_SHADOW_SIMPLE); + gGL.getTexUnit(0)->disable(); for (U32 type : types) @@ -9534,13 +9775,15 @@ void LLPipeline::renderShadow(const glm::mat4& view, const glm::mat4& proj, LLCa { LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow geom"); + LL_RECORD_BLOCK_TIME(FTM_SHADOW_GEOM); renderGeomShadow(shadow_cam); } - if(MPRenderShadowOpti < 3) { LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow alpha"); LL_PROFILE_GPU_ZONE("shadow alpha"); + LL_RECORD_BLOCK_TIME(FTM_SHADOW_ALPHA); + const S32 sun_up = LLEnvironment::instance().getIsSunUp() ? 1 : 0; U32 target_width = LLRenderTarget::sCurResX; @@ -9551,6 +9794,7 @@ void LLPipeline::renderShadow(const glm::mat4& view, const glm::mat4& proj, LLCa { LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow alpha masked"); LL_PROFILE_GPU_ZONE("shadow alpha masked"); + LL_RECORD_BLOCK_TIME(FTM_SHADOW_ALPHA_MASKED); gDeferredShadowAlphaMaskProgram.bind(rigged); LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::SUN_UP_FACTOR, sun_up); LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::DEFERRED_SHADOW_TARGET_WIDTH, (float)target_width); @@ -9560,12 +9804,15 @@ void LLPipeline::renderShadow(const glm::mat4& view, const glm::mat4& proj, LLCa { LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow alpha blend"); LL_PROFILE_GPU_ZONE("shadow alpha blend"); + LL_RECORD_BLOCK_TIME(FTM_SHADOW_ALPHA_BLEND); renderAlphaObjects(rigged); } { LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow fullbright alpha masked"); LL_PROFILE_GPU_ZONE("shadow alpha masked"); + LL_RECORD_BLOCK_TIME(FTM_SHADOW_FULLBRIGHT_ALPHA_MASKED); + gDeferredShadowFullbrightAlphaMaskProgram.bind(rigged); LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::SUN_UP_FACTOR, sun_up); LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::DEFERRED_SHADOW_TARGET_WIDTH, (float)target_width); @@ -9575,6 +9822,8 @@ void LLPipeline::renderShadow(const glm::mat4& view, const glm::mat4& proj, LLCa { LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow alpha grass"); LL_PROFILE_GPU_ZONE("shadow alpha grass"); + LL_RECORD_BLOCK_TIME(FTM_SHADOW_ALPHA_GRASS); + gDeferredTreeShadowProgram.bind(rigged); LLGLSLShader::sCurBoundShaderPtr->setMinimumAlpha(ALPHA_BLEND_CUTOFF); @@ -9586,6 +9835,8 @@ void LLPipeline::renderShadow(const glm::mat4& view, const glm::mat4& proj, LLCa { LL_PROFILE_ZONE_NAMED_CATEGORY_PIPELINE("shadow alpha material"); LL_PROFILE_GPU_ZONE("shadow alpha material"); + LL_RECORD_BLOCK_TIME(FTM_SHADOW_ALPHA_MATERIAL); + renderMaskedObjects(LLRenderPass::PASS_NORMSPEC_MASK, true, false, rigged); renderMaskedObjects(LLRenderPass::PASS_MATERIAL_ALPHA_MASK, true, false, rigged); renderMaskedObjects(LLRenderPass::PASS_SPECMAP_MASK, true, false, rigged); @@ -9868,16 +10119,24 @@ public: void LLPipeline::generateSunShadow(LLCamera& camera) { - if (!sRenderDeferred || RenderShadowDetail <= 0 || (MPRenderShadowOpti > 0 && gCubeSnapshot)) + if (!sRenderDeferred || RenderShadowDetail <= 0) { return; } + if(gCubeSnapshot) + { + LL_WARNS() << "generateSunShadow() gCubeSnapshot" << LL_ENDL; + return; + } + LL_PROFILE_ZONE_SCOPED_CATEGORY_PIPELINE; //LL_RECORD_BLOCK_TIME(FTM_GEN_SUN_SHADOW); LL_PROFILE_GPU_ZONE("generateSunShadow"); LLDisableOcclusionCulling no_occlusion; + U32 splits = 4; + bool skip_avatar_update = false; if (!isAgentAvatarValid() || gAgentCamera.getCameraAnimating() || gAgentCamera.getCameraMode() != CAMERA_MODE_MOUSELOOK || !LLVOAvatar::sVisibleInFirstPerson) { @@ -9982,7 +10241,7 @@ void LLPipeline::generateSunShadow(LLCamera& camera) LLPlane shadow_near_clip; { LLVector3 p = camera.getOrigin(); // gAgent.getPositionAgent(); - p += caster_dir * RenderFarClip*2.f; + p += caster_dir * RenderFarClip*1.1f; shadow_near_clip.setVec(p, caster_dir); } @@ -10055,30 +10314,36 @@ void LLPipeline::generateSunShadow(LLCamera& camera) update_min_max(min, max, fp[i]); } + F32 maxDist = gSavedSettings.getF32("MPRenderShadowMaxDist"); near_clip = llclamp(-max.mV[2], 0.01f, 4.0f); - F32 far_clip = llclamp(-min.mV[2]*2.f, 16.0f, 512.0f); - - //far_clip = llmin(far_clip, 128.f); + F32 far_clip = llclamp(-min.mV[2]*1.1, 16.0f, maxDist); far_clip = llmin(far_clip, camera.getFar()); F32 range = far_clip-near_clip; - LLVector3 split_exp = RenderShadowSplitExponent; + F32 closestDist = 2.0; + F32 closeDist = 10.0; - F32 da = 1.f-llmax( fabsf(lightDir*up), fabsf(lightDir*camera.getLeftAxis()) ); + mSunClipPlanes.mV[0] = near_clip + closestDist; + mSunClipPlanes.mV[1] = near_clip + closeDist; + mSunClipPlanes.mV[2] = mSunClipPlanes.mV[1] + (range-closeDist)*0.4; + mSunClipPlanes.mV[3] = far_clip; + /* + LLVector3 split_exp = RenderShadowSplitExponent; + F32 da = 1.f-llmax( fabsf(lightDir*up), fabsf(lightDir*camera.getLeftAxis()) ); da = powf(da, split_exp.mV[2]); - F32 sxp = split_exp.mV[1] + (split_exp.mV[0]-split_exp.mV[1])*da; - for (U32 i = 0; i < 4; ++i) + for (U32 i = 0; i < splits; ++i) { - F32 x = (F32)(i+1)/4.f; + F32 x = (F32)(i+1)/(F32)splits; x = powf(x, sxp); mSunClipPlanes.mV[i] = near_clip+range*x; } + */ - mSunClipPlanes.mV[0] *= 1.25f; //bump back first split for transition padding + //mSunClipPlanes.mV[0] *= 1.1f; //bump back first split for transition padding } if (gCubeSnapshot) @@ -10098,7 +10363,11 @@ void LLPipeline::generateSunShadow(LLCamera& camera) } else { - for (S32 j = 0; j < (gCubeSnapshot ? 2 : 4); j++) + S32 begin = 0; + S32 end = splits-1; + if(gCubeSnapshot) end = 1; + + for (S32 j = begin; j <= end; j++) { if (!hasRenderDebugMask(RENDER_DEBUG_SHADOW_FRUSTA) && !gCubeSnapshot) { @@ -10136,8 +10405,8 @@ void LLPipeline::generateSunShadow(LLCamera& camera) delta += (frust[i+4]-frust[(i+2)%4+4])*0.05f; delta.normVec(); F32 dp = delta*pn; - frust[i] = eye + (delta*dist[j]*0.75f)/dp; - frust[i+4] = eye + (delta*dist[j+1]*1.25f)/dp; + frust[i] = eye + (delta*dist[j]*0.9f)/dp; + frust[i+4] = eye + (delta*dist[j+1]*1.1f)/dp; } shadow_cam.calcAgentFrustumPlanes(frust); @@ -10150,12 +10419,7 @@ void LLPipeline::generateSunShadow(LLCamera& camera) std::vector<LLVector3> fp; - U32 splits = 3; - if(MPRenderShadowOpti == 1) splits = 2; - else if(MPRenderShadowOpti >= 2) splits = 1; - - if (!gPipeline.getVisiblePointCloud(shadow_cam, min, max, fp, lightDir) - || j > splits) + if (!gPipeline.getVisiblePointCloud(shadow_cam, min, max, fp, lightDir)) { //no possible shadow receivers if (!gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_SHADOW_FRUSTA) && !gCubeSnapshot) @@ -10165,7 +10429,7 @@ void LLPipeline::generateSunShadow(LLCamera& camera) mShadowCamera[j+4] = shadow_cam; } - mRT->shadow[j].bindTarget(); + mRT->shadow[j].bindTarget("", 1); { LLGLDepthTest depth(GL_TRUE); mRT->shadow[j].clear(); @@ -10455,8 +10719,9 @@ void LLPipeline::generateSunShadow(LLCamera& camera) stop_glerror(); - mRT->shadow[j].bindTarget(); - mRT->shadow[j].getViewport(gGLViewport); + mRT->shadow[j].bindTarget("mRT->shadow[j] (rendering)", 1); + //mRT->shadow[j].getViewport(gGLViewport); + //mRT->shadow[j].getViewport(0, 0, SHADOWS_RESX, SHADOWS_RESY); mRT->shadow[j].clear(); { @@ -10604,8 +10869,8 @@ void LLPipeline::generateSunShadow(LLCamera& camera) // - mSpotShadow[i].bindTarget(); - mSpotShadow[i].getViewport(gGLViewport); + mSpotShadow[i].bindTarget("mSpotShadow[i]", 1); + //mSpotShadow[i].getViewport(gGLViewport); mSpotShadow[i].clear(); static LLCullResult result[2]; @@ -10653,6 +10918,8 @@ void LLPipeline::generateSunShadow(LLCamera& camera) { gAgentAvatarp->updateAttachmentVisibility(gAgentCamera.getCameraMode()); } + + LOG_GLERROR("LLPipeline::generateSunShadow()"); } void LLPipeline::renderGroups(LLRenderPass* pass, U32 type, bool texture) @@ -10668,6 +10935,8 @@ void LLPipeline::renderGroups(LLRenderPass* pass, U32 type, bool texture) pass->renderGroup(group,type,texture); } } + + LOG_GLERROR("LLPipeline::renderGroups()"); } void LLPipeline::renderRiggedGroups(LLRenderPass* pass, U32 type, bool texture) @@ -10683,6 +10952,8 @@ void LLPipeline::renderRiggedGroups(LLRenderPass* pass, U32 type, bool texture) pass->renderRiggedGroup(group, type, texture); } } + + LOG_GLERROR("LLPipeline::renderRiggedGroups()"); } void LLPipeline::profileAvatar(LLVOAvatar* avatar, bool profile_attachments) @@ -10699,7 +10970,7 @@ void LLPipeline::profileAvatar(LLVOAvatar* avatar, bool profile_attachments) LLGLSLShader* cur_shader = LLGLSLShader::sCurBoundShaderPtr; - mRT->deferredScreen.bindTarget(); + mRT->deferredScreen.bindTarget("mRT->deferredScreen in profileAvatar", 1); mRT->deferredScreen.clear(); if (!profile_attachments) @@ -10753,6 +11024,8 @@ void LLPipeline::profileAvatar(LLVOAvatar* avatar, bool profile_attachments) { cur_shader->bind(); } + + LOG_GLERROR("LLPipeline::profileAvatar()"); } void LLPipeline::generateImpostor(LLVOAvatar* avatar, bool preview_avatar, bool for_profile, LLViewerObject* specific_attachment) @@ -10973,7 +11246,7 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar, bool preview_avatar, bool { if (!avatar->mImpostor.isComplete()) { - avatar->mImpostor.allocate(resX, resY, GL_RGBA, true); + avatar->mImpostor.allocate(resX, resY, GL_RGBA8, true); if (LLPipeline::sRenderDeferred) { @@ -10989,7 +11262,7 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar, bool preview_avatar, bool avatar->mImpostor.resize(resX, resY); } - avatar->mImpostor.bindTarget(); + avatar->mImpostor.bindTarget("avatar->mImpostor", 1); } } @@ -11126,6 +11399,9 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar, bool preview_avatar, bool } LLVertexBuffer::unbind(); + + LOG_GLERROR("LLPipeline::generateImpostor()"); + LLGLState::checkStates(); } @@ -11450,7 +11726,7 @@ void LLPipeline::skipRenderingShadows() for (S32 j = 0; j < 4; j++) { - mRT->shadow[j].bindTarget(); + mRT->shadow[j].bindTarget("skip rendering shadows", 1); mRT->shadow[j].clear(); mRT->shadow[j].flush(); } diff --git a/indra/newview/pipeline.h b/indra/newview/pipeline.h index da9b8189e2..fd94f1428c 100644 --- a/indra/newview/pipeline.h +++ b/indra/newview/pipeline.h @@ -125,6 +125,8 @@ public: private: //implementation of above, wrapped for easy error handling eFBOStatus doAllocateScreenBuffer(U32 resX, U32 resY); + void renderTriangle(); + public: //attempt to allocate screen buffers at resX, resY @@ -158,15 +160,17 @@ public: void tonemap(LLRenderTarget* src, LLRenderTarget* dst); void gammaCorrect(LLRenderTarget* src, LLRenderTarget* dst); void generateGlow(LLRenderTarget* src); - void applyCAS(LLRenderTarget* src, LLRenderTarget* dst); - void applyFXAA(LLRenderTarget* src, LLRenderTarget* dst); + bool applyCAS(LLRenderTarget* src, LLRenderTarget* dst); + bool applyFXAA(LLRenderTarget* src, LLRenderTarget* dst); void generateSMAABuffers(LLRenderTarget* src); - void applySMAA(LLRenderTarget* src, LLRenderTarget* dst); - void renderDoF(LLRenderTarget* src, LLRenderTarget* dst); + bool applySMAA(LLRenderTarget* src, LLRenderTarget* dst); + bool renderDoF(LLRenderTarget* src, LLRenderTarget* dst); void copyRenderTarget(LLRenderTarget* src, LLRenderTarget* dst); void combineGlow(LLRenderTarget* src, LLRenderTarget* dst); void visualizeBuffers(LLRenderTarget* src, LLRenderTarget* dst, U32 bufferIndex); + bool renderBloom(LLRenderTarget* src, LLRenderTarget* dst); + void init(); void cleanup(); bool isInit() { return mInitialized; }; @@ -729,8 +733,12 @@ public: LLRenderTarget mExposureMap; LLRenderTarget mLastExposure; + LLRenderTarget mBloomMap; + LLRenderTarget mBloomBlur[2]; + // tonemapped and gamma corrected render ready for post - LLRenderTarget mPostMap; + //LLRenderTarget mPostMap; + LLRenderTarget mPostMaps[2]; // FXAA helper target LLRenderTarget mFXAAMap; @@ -1008,7 +1016,7 @@ public: static bool RenderDeferred; static F32 RenderDeferredSunWash; static U32 RenderFSAAType; - static U32 RenderResolutionDivisor; + static F32 RenderResolutionDivisor; static bool RenderUIBuffer; static S32 RenderShadowDetail; static S32 MPRenderShadowOpti; diff --git a/indra/newview/skins/default/textures/megapahit/fps_button.png b/indra/newview/skins/default/textures/megapahit/fps_button.png Binary files differnew file mode 100644 index 0000000000..fa436a620d --- /dev/null +++ b/indra/newview/skins/default/textures/megapahit/fps_button.png diff --git a/indra/newview/skins/default/textures/megapahit/mp_blue_bullet.png b/indra/newview/skins/default/textures/megapahit/mp_blue_bullet.png Binary files differnew file mode 100644 index 0000000000..1a27570786 --- /dev/null +++ b/indra/newview/skins/default/textures/megapahit/mp_blue_bullet.png diff --git a/indra/newview/skins/default/textures/megapahit/mp_green_bullet.png b/indra/newview/skins/default/textures/megapahit/mp_green_bullet.png Binary files differnew file mode 100644 index 0000000000..f4c28e4bc9 --- /dev/null +++ b/indra/newview/skins/default/textures/megapahit/mp_green_bullet.png diff --git a/indra/newview/skins/default/textures/megapahit/mp_help_bullet.png b/indra/newview/skins/default/textures/megapahit/mp_help_bullet.png Binary files differnew file mode 100644 index 0000000000..64c8933a78 --- /dev/null +++ b/indra/newview/skins/default/textures/megapahit/mp_help_bullet.png diff --git a/indra/newview/skins/default/textures/megapahit/mp_info_bullet.png b/indra/newview/skins/default/textures/megapahit/mp_info_bullet.png Binary files differnew file mode 100644 index 0000000000..c90767b9ac --- /dev/null +++ b/indra/newview/skins/default/textures/megapahit/mp_info_bullet.png diff --git a/indra/newview/skins/default/textures/megapahit/mp_red_bullet.png b/indra/newview/skins/default/textures/megapahit/mp_red_bullet.png Binary files differnew file mode 100644 index 0000000000..aeaa52b53b --- /dev/null +++ b/indra/newview/skins/default/textures/megapahit/mp_red_bullet.png diff --git a/indra/newview/skins/default/textures/megapahit/mp_yellow_bullet.png b/indra/newview/skins/default/textures/megapahit/mp_yellow_bullet.png Binary files differnew file mode 100644 index 0000000000..026fbaf56d --- /dev/null +++ b/indra/newview/skins/default/textures/megapahit/mp_yellow_bullet.png diff --git a/indra/newview/skins/default/textures/textures.xml b/indra/newview/skins/default/textures/textures.xml index 1fe1ff333a..8af67c1f88 100644 --- a/indra/newview/skins/default/textures/textures.xml +++ b/indra/newview/skins/default/textures/textures.xml @@ -931,4 +931,13 @@ with the same filename but different name <texture name="ProgressLarge_11" file_name="icons/ProgressLarge_11.png" preload="true" /> <texture name="ProgressLarge_12" file_name="icons/ProgressLarge_12.png" preload="true" /> + <texture name="mp_fpsButton" file_name="megapahit/fps_button.png" preload="false" /> + + <texture name="mp_red_bullet" file_name="megapahit/mp_red_bullet.png" preload="false" /> + <texture name="mp_yellow_bullet" file_name="megapahit/mp_yellow_bullet.png" preload="false" /> + <texture name="mp_green_bullet" file_name="megapahit/mp_green_bullet.png" preload="false" /> + <texture name="mp_blue_bullet" file_name="megapahit/mp_blue_bullet.png" preload="false" /> + <texture name="mp_help_bullet" file_name="megapahit/mp_help_bullet.png" preload="false" /> + <texture name="mp_info_bullet" file_name="megapahit/mp_info_bullet.png" preload="false" /> + </textures> diff --git a/indra/newview/skins/default/xui/en/floater_about.xml b/indra/newview/skins/default/xui/en/floater_about.xml index 0d22d37085..4e7ce2c32f 100644 --- a/indra/newview/skins/default/xui/en/floater_about.xml +++ b/indra/newview/skins/default/xui/en/floater_about.xml @@ -103,8 +103,8 @@ gwigz (nya) EmilyAmiee Bavid Dailey Aria (Tashia Redrose) Cate (32a) Hiroo Ono Melodey Keysin (scoutkeysin) -Yikes Lopez Padoria Teuden -~ ( ^-^ ) ~ (cutie_qu) Markus Teuden +Yikes Lopez Padoria +~ ( ^-^ ) ~ (cutie_qu) </text_editor> <text follows="top|left" @@ -135,7 +135,6 @@ Vir Linden - Making it possible for the project to have a place in SL nutsobvious - Early testing and video proof Soft Linden - Security testing Kyle Linden - Giving TPV parcel 2 to Erik Kundiman -Signal Linden - Opening opportunities for Megapahit to contribute more </text_editor> </panel> </accordion_tab> diff --git a/indra/newview/skins/default/xui/en/floater_mp_performance.xml b/indra/newview/skins/default/xui/en/floater_mp_performance.xml index 1b5cf82dcb..13a32479fa 100644 --- a/indra/newview/skins/default/xui/en/floater_mp_performance.xml +++ b/indra/newview/skins/default/xui/en/floater_mp_performance.xml @@ -1,65 +1,66 @@ <?xml version="1.0" encoding="utf-8" standalone="yes"?> <floater - positioning="cascading" - legacy_header_height="40" - top="12" - right="-334" - height="80" - min_height="120" - width="330" - min_width="330" - can_minimize="true" - can_close="true" - can_resize="false" - layout="topright" - name="mpv_performance" - single_instance="true" - save_rect="true" - save_visibility="true" - title="FPS Limiter"> +positioning="cascading" +legacy_header_height="40" +top="12" +right="-334" +height="80" +min_height="120" +width="330" +min_width="330" +can_minimize="true" +can_close="true" +can_resize="false" +layout="topright" +name="mpv_performance" +single_instance="true" +save_rect="true" +save_visibility="true" +title="FPS Limiter"> - <panel - name="panel_fps" - border="false" - width="320" - height="60" - left="10" - top="40" - follows="left|top|right|bottom" - layout="topleft" - > +<panel + name="panel_fps" + border="false" + width="320" + height="60" + left="10" + top="40" + follows="left|top|right|bottom" + layout="topleft" + > - <slider - follows="left|top" - width="240" - height="15" - left="12" - layout="topleft" - name="fpsSlider" - enabled="true" - control_name="fpsSlider" - decimal_digits="0" - increment="12" - initial_value="0" - label="Max FPS:" - label_width="50" - text_width="2" - can_edit_text="false" - show_text="false" - > - </slider> + <slider + follows="left|top" + width="240" + height="15" + left="12" + layout="topleft" + name="fpsSliderCtrl" + enabled="true" + decimal_digits="0" + min_val="0" + max_val="132" + increment="12" + initial_value="132" + label="Max FPS:" + label_width="50" + text_width="2" + can_edit_text="false" + show_text="false" + > + </slider> - <text - follows="left|top" - width="50" - height="15" - left_delta="252" - layout="topleft" - type="string" - name="fpsText" - > - no limit - </text> + <text + follows="left|top" + width="50" + height="15" + left_delta="252" + layout="topleft" + type="string" + name="fpsTextCtrl" + > + no limit + </text> </panel> diff --git a/indra/newview/skins/default/xui/en/floater_preferences.xml b/indra/newview/skins/default/xui/en/floater_preferences.xml index 4b0e0bb221..97ff1fd5a2 100644 --- a/indra/newview/skins/default/xui/en/floater_preferences.xml +++ b/indra/newview/skins/default/xui/en/floater_preferences.xml @@ -100,6 +100,15 @@ layout="topleft" help_topic="preferences_display_tab" name="display" /> + + <panel + class="panel_preference_graphics3" + filename="panel_preferences_graphics3.xml" + label="Visual Effects" + layout="topleft" + help_topic="preferences_display_tab" + name="display3" /> + <panel class="panel_preference" filename="panel_preferences_sound.xml" diff --git a/indra/newview/skins/default/xui/en/floater_preferences_graphics_advanced.xml b/indra/newview/skins/default/xui/en/floater_preferences_graphics_advanced.xml index 88d6ae1bc2..8acf870c9d 100644 --- a/indra/newview/skins/default/xui/en/floater_preferences_graphics_advanced.xml +++ b/indra/newview/skins/default/xui/en/floater_preferences_graphics_advanced.xml @@ -52,7 +52,7 @@ left_delta="330" width="20"> m - </text> + </text> <slider control_name="RenderMaxPartCount" decimal_digits="0" @@ -626,9 +626,9 @@ layout="topleft" left="385" name="vert_border" - top="16" + top="16" width="0"/> - + <text type="string" length="1" @@ -732,7 +732,7 @@ <check_box.commit_callback function="Pref.RenderOptionUpdate" /> </check_box> - + <text type="string" length="1" @@ -751,7 +751,7 @@ height="18" layout="topleft" left_delta="130" - top_delta="0" + top_delta="0" name="ShadowDetail" width="150"> <combo_box.item @@ -766,88 +766,12 @@ label="Sun/Moon + Projectors" name="2" value="2"/> - </combo_box> - - <text - type="string" - length="1" - follows="left|top" - height="16" - layout="topleft" - left="420" - name="RenderShadowQualityText" - text_readonly_color="LabelDisabledColor" - top_delta="22" - width="128"> - Shadows Optimisations - </text> - - <combo_box - control_name="MPRenderShadowOpti" - height="18" - layout="topleft" - left_delta="130" - top_delta="0" - name="MPShadowQuality" - width="150"> - <combo_box.item - label="No optimisation" - name="0" - value="0"/> - <combo_box.item - label="Medium" - name="1" - value="1"/> - <combo_box.item - label="Faster" - name="2" - value="2"/> - <combo_box.item - label="Fastest" + <combo_box.item + label="Projectors only" name="3" value="3"/> </combo_box> - <text - type="string" - length="1" - follows="left|top" - height="16" - layout="topleft" - left="420" - name="RenderShadowResolutionScaleText" - text_readonly_color="LabelDisabledColor" - top_delta="22" - width="128"> - Shadows Resolution - </text> - - <combo_box - control_name="RenderShadowResolutionScale" - height="18" - layout="topleft" - left_delta="130" - top_delta="0" - name="RenderShadowResolutionScale" - width="150"> - <combo_box.item - label="Default" - name="Default" - value="1.0"/> - <combo_box.item - label="High" - name="High" - value="1.5"/> - <combo_box.item - label="Ultra" - name="Ultra" - value="2.0"/> - <combo_box.item - label="Crazy" - name="Crazy" - value="3.0"/> - </combo_box> - <check_box control_name="RenderScreenSpaceReflections" height="16" @@ -861,7 +785,7 @@ <check_box.commit_callback function="Pref.RenderOptionUpdate" /> </check_box> - + <text type="string" length="1" diff --git a/indra/newview/skins/default/xui/en/panel_preferences_advanced.xml b/indra/newview/skins/default/xui/en/panel_preferences_advanced.xml index 8248da9fda..e529ec0db1 100644 --- a/indra/newview/skins/default/xui/en/panel_preferences_advanced.xml +++ b/indra/newview/skins/default/xui/en/panel_preferences_advanced.xml @@ -213,6 +213,7 @@ layout="topleft" left="30" name="stream_notification_channel_enabled" + top_pad="10" width="256"> </check_box> <spinner @@ -250,7 +251,7 @@ layout="topleft" left="30" name="allow_multiple_viewer_check" - top_pad="15" + top_pad="20" width="237"/> <check_box control_name="ForceShowGrid" diff --git a/indra/newview/skins/default/xui/en/panel_preferences_colors.xml b/indra/newview/skins/default/xui/en/panel_preferences_colors.xml index 6fd6c81217..df9f467fca 100644 --- a/indra/newview/skins/default/xui/en/panel_preferences_colors.xml +++ b/indra/newview/skins/default/xui/en/panel_preferences_colors.xml @@ -505,7 +505,6 @@ Skin </text> <radio_group - control_name="skin_selection" height="20" layout="topleft" left="35" @@ -538,6 +537,15 @@ name="radio3" value="contrast" width="75" /> + <radio_item + label="contrast gold" + left_pad="0" + layout="topleft" + top_delta="0" + height="16" + name="radio2" + value="contrast_gold" + width="75" /> <radio_group.commit_callback function="Pref.SelectSkin" /> </radio_group> diff --git a/indra/newview/skins/default/xui/en/panel_preferences_graphics3.xml b/indra/newview/skins/default/xui/en/panel_preferences_graphics3.xml new file mode 100644 index 0000000000..8b76ece106 --- /dev/null +++ b/indra/newview/skins/default/xui/en/panel_preferences_graphics3.xml @@ -0,0 +1,1814 @@ +<?xml version="1.0" encoding="utf-8" standalone="yes"?> + +<panel +name="Visuals effects panel" +follows="left|top|right|bottom" +label="Visuals Effects" +layout="topleft" +width="517" +height="438" +left="102" +top="1" +border="true" +> + +<tab_container +name="preferences_visuals_tab_container" +enabled="true" +top_pad="0" +follows="left|top" +width="517" +height="430" +left_delta="0" +tab_position="top" +tab_stop="false"> + +<panel +label="Megapahit" +name="preferences_visuals_megapahit" +layout="topleft" +follows="top|left"> + +<text +follows="left|top" +layout="topleft" +top_pad="20" +width="400" +height="18" +left="20" +font="SansSerifSmall" +text_color="White" +> +Megapahit recommended settings: +</text> + +<text +follows="left|top" +layout="topleft" +width="400" +height="18" +left="120" +top_pad="55" +font="SansSerifSmall" +> +Clicking the button below is a good starting point +</text> + +<button +name="MPBalancedButton" +follows="top|left" +layout="topleft" +width="200" +height="23" +left="155" +top_pad="40" +label="Recommended Settings" +> +</button> + +<text +follows="left|top" +layout="topleft" +width="460" +height="18" +left="50" +top_pad="60" +font="SansSerifSmall" +> +We recommend capping the fps (touch the fps counter on the top right corner) +</text> + +</panel> + +<panel +label="Antialiasing" +name="preferences_visuals_aa" +layout="topleft" +follows="top|left"> + +<text +name="mp_aa_lbl" +follows="left|top" +layout="topleft" +top_pad="20" +width="100" +height="18" +left="20" +font="SansSerifSmall" +text_color="White" +> +Antialiasing: +</text> + +<text +name="mp_aa_type_lbl" +type="string" +layout="topleft" +follows="left|top" +width="140" +height="16" +left="32" +top_pad="10" +text_readonly_color="LabelDisabledColor" +> +Type: +</text> + +<combo_box +name="mp_aatype_ctrl" +control_name="RenderFSAAType" +label="Antialiasing" +layout="topleft" +width="150" +height="18" +left_delta="150" +top_delta="0" +initial_value="0" +> +<combo_box.item + label="Disabled" + name="FSAADisabled" + value="0" /> +<combo_box.item + label="FXAA" + name="FXAA" + value="1" /> +<combo_box.item + label="SMAA" + name="SMAA" + value="2" /> +</combo_box> + +<icon +name="mp_aa_bullet" +tool_tip="Low performance impact" +image_name="mp_blue_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="55" +top_delta="-2" +/> + +<icon +name="mp_aa_info_bullet" +tool_tip="Antialiasing method (FXAA is fast but blurry, SMAA is sharper)." +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="mp_aa_quality_lbl" +tool_tip="Antialiasing quality: We recommend High or Ultra" +type="string" +length="1" +layout="topleft" +follows="left|top" +width="140" +height="16" +left="32" +top_pad="10" +text_readonly_color="LabelDisabledColor" +> +Quality: +</text> + +<combo_box +name="mp_aa_quality_ctrl" +control_name="RenderFSAASamples" +label="Antialiasing" +layout="topleft" +width="150" +height="18" +left_delta="150" +top_delta="0" +> +<combo_box.item +label="Low" +name="Low" +value="0" /> +<combo_box.item +label="Medium" +name="Medium" +value="1" /> +<combo_box.item +label="High" +name="High" +value="2" /> +<combo_box.item +label="Ultra" +name="Ultra" +value="3" /> +</combo_box> + +<icon +name="mp_aaq_bullet" +tool_tip="Low performance impact" +image_name="mp_blue_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="55" +top_delta="-2" +/> + +<icon +name="mp_aaq_info_bullet" +tool_tip="Quality of the selected antialiasing" +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="mp_cas_lbl" +type="string" +length="1" +layout="topleft" +follows="left|top" +width="140" +height="16" +left="32" +top_pad="20" +text_readonly_color="LabelDisabledColor" +> +Sharpness: +</text> + +<slider +name="mp_cas_ctrl" +control_name="RenderCASSharpness" +follows="left|top" +layout="topleft" +width="200" +height="16" +left_delta="150" +top_delta="0" +initial_value="0.0" +min_val="0.0" +max_val="1.0" +decimal_digits="1" +label_width="2" +> +</slider> + +<icon +name="mp_cas_bullet" +tool_tip="No performance impact, except there is an issue currently with the combination of SMAA and Sharpness, where the performance is going down. We are investigating..." +image_name="mp_blue_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_cas_info_bullet" +tool_tip="Add sharpness to the image." +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +follows="left|top" +layout="topleft" +width="400" +height="18" +left="55" +top_pad="40" +font="SansSerifSmall" +> +Beware: SMAA + Sharpness currently causes a slow down on Mac. +</text> + +</panel> + +<panel +label="Shadows" +name="preferences_visuals_shadows" +layout="topleft" +follows="top|left"> + +<text +name="mp_shadows_lbl" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="20" +top_pad="20" +font="SansSerifSmall" +text_color="White" +> +Shadows +</text> + +<text +name="shadow_src_lbl" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall" +> +Shadows source: +</text> + +<combo_box +name="ShadowDetailCtrl" +control_name="RenderShadowDetail" +layout="topleft" +width="150" +height="18" +left_delta="150" +top_delta="0" +> +<combo_box.item +label="None" +name="0" +value="0"/> +<combo_box.item +label="Sun/Moon" +name="1" +value="1"/> +<combo_box.item +label="Sun/Moon + Projectors" +name="2" +value="2"/> +<combo_box.item +label="Projectors only" +name="3" +value="3"/> +</combo_box> + +<icon +name="mp_shadows_bullet" +tool_tip="High to extreme performance impact" +image_name="mp_red_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="55" +top_delta="-2" +/> + +<icon +name="mp_shadows_info_bullet" +tool_tip="Enables a shadow source (Projectors only is experimental)" +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="shadow_dist_lbl" +tool_tip="Maximum Shadow Draw distance (Enormous performance penalty)" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall"> +Shadows Distance +</text> + +<slider +name="MPShadowDistCtrl" +control_name="MPRenderShadowMaxDist" +follows="left|top" +layout="topleft" +width="200" +height="16" +left_delta="150" +top_delta="-1" +increment="8" +initial_value="64" +min_val="16" +max_val="256" +decimal_digits="0" +label_width="2"> +</slider> + +<icon +name="mp_shadowd_bullet" +tool_tip="Move to the left to improve performance" +image_name="mp_yellow_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_shadowd_info_bullet" +tool_tip="Limit the maximum shadow render distance" +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="shadow_res_lbl" +tool_tip="Shadow Resolution (Important video memory impact. Lower this if you encounter performance drop, or instability.)" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall" +> +Shadows Resolution +</text> + +<slider +name="MPShadowResCtrl" +control_name="RenderShadowResolutionScale" +decimal_digits="1" +follows="left|top" +layout="topleft" +width="200" +height="16" +left_delta="150" +top_delta="-1" +increment="0.5" +initial_value="1.5" +min_val="1.0" +max_val="6.0" +label_width="2" +> +</slider> + +<icon +name="mp_shadowdd_bullet" +tool_tip="Move to the right to improve quality: High memory usage and potentially unstable on lower end gpus" +image_name="mp_yellow_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_shadowdd_info_bullet" +tool_tip="Improves the shadow map resolution (Use carefully)" +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="shadow_res_lbl" +tool_tip="Shadow smoothness (This will only work if you activate Ambient Occlusion)" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall" +> +Shadows Smoothness +</text> + +<slider +name="shadowBlurCtrl" +control_name="RenderShadowBlurSize" +follows="left|top" +layout="topleft" +width="200" +height="16" +left_delta="150" +top_delta="-1" +increment="0.1" +initial_value="1.0" +min_val="0.0" +max_val="3.0" +decimal_digits="1" +label_width="2" +> +</slider> + +<icon +name="mp_shadowsblur_bullet" +tool_tip="No performance impact" +image_name="mp_blue_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_shadowsblur_info_bullet" +tool_tip="Adjust the shadow smoothness. This only works if SSAO is turned on" +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="shadow_ssao_lbl" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="20" +top_pad="40" +font="SansSerifSmall" +text_color="White" +> +Ambient Occlusion +</text> + +<check_box +name="mp_ssao_ctrl" +control_name="RenderDeferredSSAO" +label="Screen Space Ambient Occlusion" +layout="topleft" +width="200" +height="16" +left="20" +top_delta="32" +initial_value="true" +> +<check_box.commit_callback +function="Pref.RenderOptionUpdate" /> +</check_box> + +<icon +name="mp_ssao_bullet" +tool_tip="Low to Medium performance impact" +image_name="mp_yellow_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_ssao_info_bullet" +tool_tip="Adds some shadow based on surface proximity." +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +</panel> + +<panel +label="Bloom" +name="preferences_visuals_bloom" +layout="topleft" +follows="top|left"> + +<text +name="mp_bloom_lbl" +follows="left|top" +layout="topleft" +width="200" +height="18" +left="20" +top_pad="20" +font="SansSerifSmall" +text_color="White" +> +Bloom (experimental) +</text> + +<text +name="mp_bloom_level_lbl" +tool_tip="Bloom Level: The higher, the more diffuse (medium gpu cost)\n Note: This setting can fix a performance issue when antialiasing is turned on)" +type="string" +length="1" +follows="left|top" +width="140" +height="16" +layout="topleft" +left="32" +top_pad="10" +text_readonly_color="LabelDisabledColor" +> +Bloom level: +</text> + +<combo_box +name="MPBloomCtrl" +control_name="MPRenderBloom" +layout="topleft" +width="150" +height="18" +left_delta="150" +top_delta="0" +> +<combo_box.item +label="None" +name="0" +value="0"/> +<combo_box.item +label="Level 1" +name="1" +value="1"/> +<combo_box.item +label="Level 2" +name="2" +value="2"/> +<combo_box.item +label="Level 3" +name="3" +value="3"/> +</combo_box> + +<icon +name="mp_blooml_bullet" +tool_tip="Low to Medium performance impact" +image_name="mp_yellow_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="55" +top_delta="-2" +/> + +<icon +name="mp_blooml_info_bullet" +tool_tip="Bloom adds a glowing effect around the brightest areas. The level affects the number of iterations, and the quality." +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="bloom_radius_lbl" +tool_tip="Bloom Radius" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall" +> +Bloom Radius +</text> + +<slider +name="MPBloomRadiusCtrl" +control_name="MPBloomBlurRadius" +decimal_digits="2" +follows="left|top" +layout="topleft" +width="200" +height="16" +left_delta="150" +top_delta="-1" +increment="0.01" +initial_value="1.0" +label_width="2" +min_val="0.0" +max_val="3.0" +> +</slider> + +<icon +name="mp_bloomr_bullet" +tool_tip="No performance impact" +image_name="mp_blue_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_bloomr_info_bullet" +tool_tip="Adjust the base radius of the effect" +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="bloom_radiusadd_lbl" +tool_tip="Bloom Radius addition" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall" +> +Bloom Radius addition +</text> + +<slider +name="MPBloomRadiusAddCtrl" +control_name="MPBloomBlurRadiusAdd" +decimal_digits="2" +follows="left|top" +layout="topleft" +width="200" +height="16" +left_delta="150" +top_delta="-1" +increment="0.01" +initial_value="1.0" +label_width="2" +min_val="-3.0" +max_val="3.0" +> +</slider> + +<icon +name="mp_bloomra_bullet" +tool_tip="No performance impact" +image_name="mp_blue_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_bloomra_info_bullet" +tool_tip="Adjust the added radius for each iteration" +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="bloom_extract_lbl" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall" +> +Bloom Range +</text> + +<slider +name="MPBloomRangeCtrl" +control_name="MPBloomExtractBrightness" +decimal_digits="2" +follows="left|top" +layout="topleft" +width="200" +height="16" +left_delta="150" +top_delta="-1" +increment="0.025" +initial_value="0.1" +label_width="2" +min_val="0.0" +max_val="0.5" +> +</slider> + +<icon +name="mp_bloomrange_bullet" +tool_tip="No performance impact" +image_name="mp_blue_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_bloomrange_info_bullet" +tool_tip="When moved to the right, it will take more of the bright areas." +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="bloom_strength_lbl" +tool_tip="Bloom: Strength of the effect (no performance impact)" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall"> +Bloom Strength +</text> + +<slider +name="MPBloomStrCtrl" +control_name="MPBloomStrength" +decimal_digits="1" +follows="left|top" +layout="topleft" +width="200" +height="16" +left_delta="150" +top_delta="-1" +increment="0.1" +initial_value="1.0" +min_val="0.5" +max_val="2.0" +label_width="2" +> +</slider> + +<icon +name="mp_bloomstr_bullet" +tool_tip="No performance impact" +image_name="mp_blue_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_bloomstr_info_bullet" +tool_tip="Controls the effect strength" +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="bloom_metal_lbl" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall" +> +Bloom Metal +</text> + +<slider +name="MPBloomMetalCtrl" +control_name="MPBloomExtractMetal" +follows="left|top" +layout="topleft" +width="200" +height="16" +left_delta="150" +top_delta="-1" +increment="0.05" +initial_value="0.2" +decimal_digits="2" +min_val="0.0" +max_val="1.0" +label_width="2" +> +</slider> + +<icon +name="mp_bloommetal_bullet" +tool_tip="No performance impact" +image_name="mp_blue_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_bloommetal_info_bullet" +tool_tip="When moved to the right, the effect will apply on more metallic surfaces." +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="bloom_nonmetal_lbl" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall"> +Bloom Non Metal +</text> + +<slider +name="MPBloomNonMetalCtrl" +control_name="MPBloomExtractNonMetal" +layout="topleft" +follows="left|top" +width="200" +height="16" +left_delta="150" +top_delta="-1" +increment="0.05" +initial_value="0.2" +label_width="2" +decimal_digits="2" +min_val="0.0" +max_val="1.0" +> +</slider> + +<icon +name="mp_bloomnonmet_bullet" +tool_tip="No performance impact" +image_name="mp_blue_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_bloomnonmet_info_bullet" +tool_tip="When moved to the right, the effect will apply on more non-metallic surfaces." +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +</panel> + +<panel +name="preferences_visuals_probes" +label="Probes" +layout="topleft" +follows="top|left" +> + +<text +name="mp_probes_lbl" +follows="left|top" +layout="topleft" +width="100" +height="18" +left="20" +top_pad="20" +font="SansSerifSmall" +text_color="White" +> +Reflection Probes +</text> + +<icon +name="mp_probedetail_info_bullet" +tool_tip="Reflection probes are a fundamental part of how pbr lighting is calculated" +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="probes_detail_lbl" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall" +> +Reflection Detail: +</text> + +<combo_box +name="mp_probes_detail_ctrl" +control_name="RenderReflectionProbeDetail" +layout="topleft" +width="150" +height="18" +left_delta="150" +top_delta="0" +> +<combo_box.item +label="Static Only" +name="0" +value="0"/> +<combo_box.item +label="Static+Dynamic" +name="1" +value="1"/> +<combo_box.item +label="Realtime" +name="2" +value="2"/> +</combo_box> + +<icon +name="mp_probedetail_bullet" +tool_tip="High to extreme performance impact" +image_name="mp_red_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="55" +top_delta="-2" +/> + +<icon +name="mp_probedetail_info_bullet" +tool_tip="Controls how often the reflection probes update with the surrounding. We recommend Static Only for daily usage (specially on Mac)" +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="probes_coverage_lbl" +tool_tip="Reflection probes level (Important memory usage and performance penalty)" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall" +> +Reflection Coverage: +</text> + +<combo_box +name="probes_level_ctrl" +control_name="RenderReflectionProbeLevel" +layout="topleft" +width="150" +height="18" +left_delta="150" +top_delta="0" +> +<combo_box.item +label="None" +name="0" +value="0"/> +<combo_box.item +label="Manual only" +name="1" +value="1"/> +<combo_box.item +label="Manual + terrain" +name="2" +value="2"/> +<combo_box.item +label="Full scene" +name="3" +value="3"/> +</combo_box> + +<icon +name="mp_probedetail_bullet" +tool_tip="Medium to High performance impact" +image_name="mp_yellow_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="55" +top_delta="-2" +/> + +<icon +name="mp_probedetail_info_bullet" +tool_tip="Controls what part of the surrounding the reflections probes are capturing. We recommend Manual only." +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="probes_count_lbl" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall" +> +Max Reflection Probes: +</text> + +<combo_box +name="mp_probes_count_ctrl" +control_name="RenderReflectionProbeCount" +label="Max. Reflection Probes:" +layout="topleft" +width="150" +height="18" +left_delta="150" +top_delta="0" +> +<combo_box.item +label="None" +name="1" +value="1"/> +<combo_box.item +label="Low" +name="32" +value="32"/> +<combo_box.item +label="Medium" +name="64" +value="64"/> +<combo_box.item +label="High" +name="128" +value="128"/> +<combo_box.item +label="Ultra" +name="256" +value="256"/> +</combo_box> + +<icon +name="mp_probecount_bullet" +tool_tip="Medium to High performance and memory usage impact" +image_name="mp_yellow_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="55" +top_delta="-2" +/> + +<icon +name="mp_probecount_info_bullet" +tool_tip="Limits the maximum number of active reflections probes" +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="probes_res_lbl" +tool_tip="Sets the resolution used to calculate the probes (Important to extreme video memory impact and performance)" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall" +> +Reflection Resolution: +</text> + +<combo_box +name="ProbeResCtrl" +control_name="RenderReflectionProbeResolution" +layout="topleft" +width="150" +height="18" +left_delta="150" +top_delta="0" +> +<combo_box.item +label="Low" +name="low" +value="64"/> +<combo_box.item +label="Default" +name="default" +value="128"/> +<combo_box.item +label="High" +name="high" +value="256"/> +<combo_box.item +label="Maximum" +name="maximum" +value="512"/> +</combo_box> + +<icon +name="mp_proberes_bullet" +tool_tip="Medium to Extreme performance and memory usage impact" +image_name="mp_red_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="55" +top_delta="-2" +/> + +<icon +name="mp_proberes_info_bullet" +tool_tip="Improves the quality of the probes" +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="mp_probe_dd_lbl" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall" +> +Draw Distance +</text> + +<slider +control_name="RenderReflectionProbeDrawDistance" +follows="left|top" +layout="topleft" +width="200" +height="16" +left_delta="150" +top_delta="-1" +initial_value="32" +min_val="8" +max_val="64" +increment="8" +decimal_digits="0" +label_width="2"> +</slider> + +<icon +name="mp_probedd_bullet" +tool_tip="Medium to High performance impact" +image_name="mp_yellow_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_probedd_info_bullet" +tool_tip="Controls the draw distance at which the probes are calculating the surrounding" +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="mp_probe_ud_lbl" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall" +> +Default Probe Update +</text> + +<slider +control_name="RenderDefaultProbeUpdatePeriod" +follows="left|top" +layout="topleft" +width="200" +height="16" +left_delta="150" +top_delta="-1" +initial_value="15" +increment="1" +min_val="2" +max_val="60" +decimal_digits="0" +label_width="2" +> +</slider> + +<icon +name="mp_dprobeperiod_bullet" +tool_tip="When moved to the right, the performance will improve." +image_name="mp_green_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_dprobeperiod_info_bullet" +tool_tip="Controls how the default probe update is delayed." +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="mp_probe_ud_lbl" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall" +> +Other Probes delay +</text> + +<slider +name="MPProbeUpdCtrl" +control_name="MPRenderProbeUpdatePeriod" +follows="left|top" +layout="topleft" +width="200" +height="16" +left_delta="150" +top_delta="-1" +initial_value="15" +increment="1" +min_val="0" +max_val="60" +decimal_digits="0" +label_width="2" +> +</slider> + +<icon +name="mp_probeperiod_bullet" +tool_tip="When moved to the right, the performance will improve." +image_name="mp_green_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_probeperiod_info_bullet" +tool_tip="Controls how each probe update is delayed." +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="mp_probe_slow_lbl" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="10" +font="SansSerifSmall" +> +Refresh delay +</text> + +<slider +name="MPProbeSlowCtrl" +control_name="MPRenderProbeSlowDown" +follows="left|top" +layout="topleft" +width="200" +height="16" +left_delta="150" +top_delta="-1" +initial_value="0.01" +increment="0.01" +min_val="0" +max_val="0.2" +decimal_digits="2" +label_width="2"> +</slider> + +<icon +name="mp_probeslowdown_bullet" +tool_tip="When moved to the right, the performance will improve." +image_name="mp_green_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_probeslowdown_info_bullet" +tool_tip="Controls how often the probes update process is called. When moved to the right, the update be slower." +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +</panel> + +<panel +label="Quality" +name="preferences_visuals_others" +layout="topleft" +follows="top|left"> + +<check_box +name="VintageCtrl" +control_name="RenderDisableVintageMode" +label="HDR and Emissive" +layout="topleft" +width="250" +height="16" +left="20" +top_delta="32" +initial_value="false" +> +<check_box.commit_callback +function="Pref.RenderOptionUpdate" /> +</check_box> + +<icon +name="mp_hdr_bullet" +tool_tip="Low to Medium performance impact. We recommend it ON, unless you are using a weaker/older computer." +image_name="mp_yellow_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_hdr_info_bullet" +tool_tip="Enables Higher color fidelity, and several other post-processing effects." +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<check_box +name="mp_transparent_water" +control_name="RenderTransparentWater" +label="Transparent Water" +layout="topleft" +width="250" +height="16" +left="20" +top_delta="32" +initial_value="true" +> +<check_box.commit_callback +function="Pref.RenderOptionUpdate" /> +</check_box> + +<icon +name="mp_twater_bullet" +tool_tip="Low to Medium performance impact. We recommend it ON, unless you are using a weaker/older computer." +image_name="mp_yellow_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_twater_info_bullet" +tool_tip="Enables higher quality water with transparency." +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<check_box +name="colorPrecisionCtrl" +control_name="MPLowColorPrecision" +label="Lower color precision (needs restart)" +layout="topleft" +width="250" +height="16" +left="20" +top_delta="32" +initial_value="false" +> +<check_box.commit_callback +function="Pref.RenderOptionUpdate" /> +</check_box> + +<icon +name="mp_lowcolor_bullet" +tool_tip="Can help performance specially in high resolution" +image_name="mp_green_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_lowcolor_info_bullet" +tool_tip="Lowers the internal color precision which can help with performance." +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<text +name="mp_resdiv_lbl" +follows="left|top" +layout="topleft" +width="140" +height="18" +left="32" +top_pad="30" +font="SansSerifSmall" +> +Resolution divisor +</text> + +<slider +control_name="RenderResolutionDivisor" +follows="left|top" +layout="topleft" +width="200" +height="16" +left_delta="150" +top_delta="-1" +initial_value="1.0" +increment="0.25" +min_val="1.0" +max_val="4.0" +decimal_digits="2" +label_width="2"> +</slider> + +</panel> + +<panel +label="For nerds" +name="preferences_visuals_others" +layout="topleft" +follows="top|left"> + +<check_box +name="MultiTexCtrl" +control_name="RenderGLMultiThreadedTextures" +label="Multithreaded Textures" +layout="topleft" +width="250" +height="16" +left="20" +top_delta="32" +initial_value="false" +> +</check_box> + +<icon +name="mp_multitex_bullet" +tool_tip="Improves textures loading performance on certain hardware. But can be unstable." +image_name="mp_yellow_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_multitex_info_bullet" +tool_tip="Enables loading textures using multiple threads." +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<check_box +name="AppleMultGLCtrl" +control_name="RenderAppleUseMultGL" +label="Apple Multithreaded OpenGL" +layout="topleft" +width="250" +height="16" +left="20" +top_delta="32" +initial_value="false" +> +</check_box> + +<icon +name="mp_applemulti_bullet" +tool_tip="Variable performance impact. Can be unstable!" +image_name="mp_yellow_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_applemulti_info_bullet" +tool_tip="Enables Apple OpenGL Multithreaded optimisations. Can be unstable!!" +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +<check_box +name="NoGLDebugCtrl" +control_name="MPNoGLDebug" +label="No GL Debug" +layout="topleft" +width="250" +height="16" +left="20" +top_delta="32" +initial_value="true" +> +</check_box> + +<icon +name="mp_nodebug_bullet" +tool_tip="Leave this always to ON for optimal performance" +image_name="mp_yellow_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="-2" +/> + +<icon +name="mp_nodebug_info_bullet" +tool_tip="Ensures there is no opengl debug. This should be set to ON!" +image_name="mp_info_bullet" +follows="left|top" +width="16" +height="16" +layout="topleft" +left_pad="5" +top_delta="0" +/> + +</panel> + +</tab_container> + +</panel>
\ No newline at end of file diff --git a/indra/newview/skins/default/xui/en/panel_snapshot_local.xml b/indra/newview/skins/default/xui/en/panel_snapshot_local.xml index 52f9068264..fb88b752ae 100644 --- a/indra/newview/skins/default/xui/en/panel_snapshot_local.xml +++ b/indra/newview/skins/default/xui/en/panel_snapshot_local.xml @@ -74,6 +74,10 @@ label="1600x1200" name="1600x1200" value="[i1600,i1200]" /> + <combo_box.item + label="2048x2048" + name="2048x2048" + value="[i2048,i2048]" /> <combo_box.item label="Custom" name="Custom" diff --git a/indra/newview/skins/default/xui/en/panel_status_bar.xml b/indra/newview/skins/default/xui/en/panel_status_bar.xml index 5e05eb2837..dbdec5b5ef 100644 --- a/indra/newview/skins/default/xui/en/panel_status_bar.xml +++ b/indra/newview/skins/default/xui/en/panel_status_bar.xml @@ -188,15 +188,21 @@ <button type="string" font="SansSerif" + image_unselected="mp_fpsButton" + image_selected="mp_fpsButton" + image_hover_unselected="mp_fpsButton" + image_pressed="mp_fpsButton" + image_pressed_selected="mp_fpsButton" + image_color="White" label_color="FpsTextColor" follows="right|top" halign="center" valign="center" height="18" top="1" - left_pad="4" + left_pad="2" name="FpsText" - tool_tip="fps" + tool_tip="fps: Color indicates frametime fluctuations (Green is optimal)" width="32"> 60 </button> |
