livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge into viewer/viewer-20 yesterday's lindenlab/svn-imports-viewer-20

master
Nat Goodspeed 2009-09-26 18:08:24 -04:00
parent 8ddc0c0ac4 09bf3c1fec
commit bc4444cd78
715 changed files with 21097 additions and 10766 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
doc/contributions.txt
View File

@ -38,6 +38,7 @@ Aimee Trescothick
VWR-11100
VWR-11111
VWR-11844
VWR-14087
Alejandro Rosenthal
VWR-1184
Aleric Inglewood
@ -551,6 +552,8 @@ Strife Onizuka
VWR-183
VWR-2265
VWR-4111
Tayra Dagostino
VWR-13947
TBBle Kurosawa
VWR-938
VWR-941
@ -567,6 +570,7 @@ Tharax Ferraris
VWR-605
Thickbrick Sleaford
VWR-7109
VWR-13947
Thraxis Epsilon
SVC-371
VWR-383

3
indra/integration_tests/llui_libtest/CMakeLists.txt
View File

@ -57,6 +57,8 @@ if (DARWIN)
find_library(COCOA_LIBRARY Cocoa)
set(OS_LIBRARIES ${COCOA_LIBRARY})
elseif (WINDOWS)
#ll_stack_trace needs this now...
list(APPEND WINDOWS_LIBRARIES dbghelp)
set(OS_LIBRARIES ${WINDOWS_LIBRARIES})
elseif (LINUX)
set(OS_LIBRARIES)
@ -95,6 +97,7 @@ if (WINDOWS)
COMMAND ${CMAKE_COMMAND} -E copy_if_different
${OPENJPEG_DEBUG} ${CMAKE_CURRENT_BINARY_DIR}
)
endif (WINDOWS)
# Ensure people working on the viewer don't break this library

1
indra/llcommon/indra_constants.h
View File

@ -286,6 +286,7 @@ const U8 UPD_UNIFORM = 0x10; // used with UPD_SCALE
// Agent Update Flags (U8)
const U8 AU_FLAGS_NONE = 0x00;
const U8 AU_FLAGS_HIDETITLE = 0x01;
const U8 AU_FLAGS_CLIENT_AUTOPILOT = 0x02;
// start location constants
const U32 START_LOCATION_ID_LAST = 0;

1
indra/llcommon/lllslconstants.h
View File

@ -48,6 +48,7 @@ const U32 AGENT_TYPING = 0x0200;
const U32 AGENT_CROUCHING = 0x0400;
const U32 AGENT_BUSY = 0x0800;
const U32 AGENT_ALWAYS_RUN = 0x1000;
const U32 AGENT_AUTOPILOT = 0x2000;
const S32 LSL_REMOTE_DATA_CHANNEL = 1;
const S32 LSL_REMOTE_DATA_REQUEST = 2;

6
indra/llcommon/llstring.cpp
View File

@ -155,7 +155,7 @@ S32 wchar_to_utf8chars(llwchar in_char, char* outchars)
*outchars++ = 0xF0 | (cur_char >> 18);
*outchars++ = 0x80 | ((cur_char >> 12) & 0x3F);
*outchars++ = 0x80 | ((cur_char >> 6) & 0x3F);
*outchars++ = 0x80 | cur_char & 0x3F;
*outchars++ = 0x80 | (cur_char & 0x3F);
}
else if (cur_char < 0x4000000)
{
@ -163,7 +163,7 @@ S32 wchar_to_utf8chars(llwchar in_char, char* outchars)
*outchars++ = 0x80 | ((cur_char >> 18) & 0x3F);
*outchars++ = 0x80 | ((cur_char >> 12) & 0x3F);
*outchars++ = 0x80 | ((cur_char >> 6) & 0x3F);
*outchars++ = 0x80 | cur_char & 0x3F;
*outchars++ = 0x80 | (cur_char & 0x3F);
}
else if (cur_char < 0x80000000)
{
@ -172,7 +172,7 @@ S32 wchar_to_utf8chars(llwchar in_char, char* outchars)
*outchars++ = 0x80 | ((cur_char >> 18) & 0x3F);
*outchars++ = 0x80 | ((cur_char >> 12) & 0x3F);
*outchars++ = 0x80 | ((cur_char >> 6) & 0x3F);
*outchars++ = 0x80 | cur_char & 0x3F;
*outchars++ = 0x80 | (cur_char & 0x3F);
}
else
{

28
indra/llmath/llcamera.cpp
View File

@ -178,7 +178,7 @@ S32 LLCamera::AABBInFrustum(const LLVector3 &center, const LLVector3& radius)
U8 mask = 0;
S32 result = 2;
if (radius.magVecSquared() > mFrustumCornerDist * mFrustumCornerDist)
/*if (mFrustumCornerDist > 0.f && radius.magVecSquared() > mFrustumCornerDist * mFrustumCornerDist)
{ //box is larger than frustum, check frustum quads against box planes
static const LLVector3 dir[] =
@ -241,11 +241,15 @@ S32 LLCamera::AABBInFrustum(const LLVector3 &center, const LLVector3& radius)
result = 1;
}
}
else
else*/
{
for (U32 i = 0; i < mPlaneCount; i++)
{
mask = mAgentPlanes[i].mask;
if (mask == 0xff)
{
continue;
}
LLPlane p = mAgentPlanes[i].p;
LLVector3 n = LLVector3(p);
float d = p.mV[3];
@ -294,6 +298,10 @@ S32 LLCamera::AABBInFrustumNoFarClip(const LLVector3 &center, const LLVector3& r
}
mask = mAgentPlanes[i].mask;
if (mask == 0xff)
{
continue;
}
LLPlane p = mAgentPlanes[i].p;
LLVector3 n = LLVector3(p);
float d = p.mV[3];
@ -437,6 +445,11 @@ int LLCamera::sphereInFrustum(const LLVector3 &sphere_center, const F32 radius)
int res = 2;
for (int i = 0; i < 6; i++)
{
if (mAgentPlanes[i].mask == 0xff)
{
continue;
}
float d = mAgentPlanes[i].p.dist(sphere_center);
if (d > radius)
@ -622,6 +635,17 @@ U8 LLCamera::calcPlaneMask(const LLPlane& plane)
return mask;
}
void LLCamera::ignoreAgentFrustumPlane(S32 idx)
{
if (idx < 0 || idx > (S32) mPlaneCount)
{
return;
}
mAgentPlanes[idx].mask = 0xff;
mAgentPlanes[idx].p.clearVec();
}
void LLCamera::calcAgentFrustumPlanes(LLVector3* frust)
{

16
indra/llmath/llcamera.h
View File

@ -93,6 +93,17 @@ public:
PLANE_TOP_MASK = (1<<PLANE_TOP),
PLANE_ALL_MASK = 0xf
};
enum
{
AGENT_PLANE_LEFT = 0,
AGENT_PLANE_RIGHT,
AGENT_PLANE_NEAR,
AGENT_PLANE_BOTTOM,
AGENT_PLANE_TOP,
AGENT_PLANE_FAR,
};
enum {
HORIZ_PLANE_LEFT = 0,
HORIZ_PLANE_RIGHT = 1,
@ -132,7 +143,8 @@ private:
public:
LLVector3 mAgentFrustum[8]; //8 corners of 6-plane frustum
F32 mFrustumCornerDist; //distance to corner of frustum against far clip plane
LLPlane getAgentPlane(U32 idx) { return mAgentPlanes[idx].p; }
public:
LLCamera();
LLCamera(F32 vertical_fov_rads, F32 aspect_ratio, S32 view_height_in_pixels, F32 near_plane, F32 far_plane);
@ -179,6 +191,8 @@ public:
// Return number of bytes copied.
size_t readFrustumFromBuffer(const char *buffer);
void calcAgentFrustumPlanes(LLVector3* frust);
void ignoreAgentFrustumPlane(S32 idx);
// Returns 1 if partly in, 2 if fully in.
// NOTE: 'center' is in absolute frame.
S32 sphereInFrustumOld(const LLVector3 &center, const F32 radius) const;

1
indra/llmath/llrect.h
View File

@ -42,6 +42,7 @@
template <class Type> class LLRectBase
{
public:
typedef Type tCoordType;
Type mLeft;
Type mTop;
Type mRight;

11
indra/llmath/llvolume.cpp
View File

@ -84,6 +84,7 @@ const F32 SKEW_MIN = -0.95f;
const F32 SKEW_MAX = 0.95f;
const F32 SCULPT_MIN_AREA = 0.002f;
const S32 SCULPT_MIN_AREA_DETAIL = 1;
BOOL check_same_clock_dir( const LLVector3& pt1, const LLVector3& pt2, const LLVector3& pt3, const LLVector3& norm)
{
@ -2230,10 +2231,14 @@ void LLVolume::sculpt(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components,
if (!data_is_empty)
{
sculptGenerateMapVertices(sculpt_width, sculpt_height, sculpt_components, sculpt_data, sculpt_type);
if (sculptGetSurfaceArea() < SCULPT_MIN_AREA)
// don't test lowest LOD to support legacy content DEV-33670
if (mDetail > SCULPT_MIN_AREA_DETAIL)
{
data_is_empty = TRUE;
if (sculptGetSurfaceArea() < SCULPT_MIN_AREA)
{
data_is_empty = TRUE;
}
}
}

4
indra/llmath/v3math.h
View File

@ -409,8 +409,8 @@ inline bool operator<(const LLVector3 &a, const LLVector3 &b)
return (a.mV[0] < b.mV[0]
|| (a.mV[0] == b.mV[0]
&& (a.mV[1] < b.mV[1]
|| (a.mV[1] == b.mV[1])
&& a.mV[2] < b.mV[2])));
|| ((a.mV[1] == b.mV[1])
&& a.mV[2] < b.mV[2]))));
}
inline const LLVector3& operator+=(LLVector3 &a, const LLVector3 &b)

4
indra/llmessage/lliobuffer.cpp
View File

@ -87,7 +87,7 @@ LLIOPipe::EStatus LLIOBuffer::seek(LLIOBuffer::EHead head, S64 delta)
{
case READ:
if(((delta >= 0) && ((mReadHead + delta) <= mWriteHead))
|| (delta < 0) && ((mReadHead + delta) >= mBuffer))
|| ((delta < 0) && ((mReadHead + delta) >= mBuffer)))
{
mReadHead += delta;
status = STATUS_OK;
@ -95,7 +95,7 @@ LLIOPipe::EStatus LLIOBuffer::seek(LLIOBuffer::EHead head, S64 delta)
break;
case WRITE:
if(((delta >= 0) && ((mWriteHead + delta) < (mBuffer + mBufferSize)))
|| (delta < 0) && ((mWriteHead + delta) > mReadHead))
|| ((delta < 0) && ((mWriteHead + delta) > mReadHead)))
{
mWriteHead += delta;
status = STATUS_OK;

1
indra/llprimitive/llprimitive.cpp
View File

@ -1908,4 +1908,3 @@ bool LLLightImageParams::fromLLSD(LLSD& sd)
return false;
}

27
indra/llrender/llgl.cpp
View File

@ -64,6 +64,8 @@ BOOL gDebugSession = FALSE;
BOOL gDebugGL = FALSE;
BOOL gClothRipple = FALSE;
BOOL gNoRender = FALSE;
BOOL gGLActive = FALSE;
std::ofstream gFailLog;
@ -107,6 +109,7 @@ LLMatrix4 gGLObliqueProjectionInverse;
#define LL_GL_NAME_POOLING 0
LLGLNamePool::pool_list_t LLGLNamePool::sInstances;
std::list<LLGLUpdate*> LLGLUpdate::sGLQ;
#if (LL_WINDOWS || LL_LINUX || LL_SOLARIS) && !LL_MESA_HEADLESS
// ATI prototypes
@ -1013,6 +1016,16 @@ void flush_glerror()
void assert_glerror()
{
if (!gGLActive)
{
//llwarns << "GL used while not active!" << llendl;
if (gDebugSession)
{
//ll_fail("GL used while not active");
}
}
if (gNoRender || !gDebugGL)
{
return;
@ -1258,8 +1271,10 @@ void LLGLState::checkTextureChannels(const std::string& msg)
};
GLint stackDepth = 0;
LLMatrix4 identity;
LLMatrix4 matrix;
glh::matrix4f mat;
glh::matrix4f identity;
identity.identity();
for (GLint i = 1; i < maxTextureUnits; i++)
{
@ -1280,10 +1295,10 @@ void LLGLState::checkTextureChannels(const std::string& msg)
}
}
glGetFloatv(GL_TEXTURE_MATRIX, (GLfloat*) matrix.mMatrix);
glGetFloatv(GL_TEXTURE_MATRIX, (GLfloat*) mat.m);
stop_glerror();
if (matrix != identity)
if (mat != identity)
{
error = TRUE;
LL_WARNS("RenderState") << "Texture matrix in channel " << i << " corrupt." << LL_ENDL;
@ -1309,10 +1324,6 @@ void LLGLState::checkTextureChannels(const std::string& msg)
stop_glerror();
}
glh::matrix4f mat;
glh::matrix4f identity;
identity.identity();
glGetFloatv(GL_TEXTURE_MATRIX, mat.m);
stop_glerror();

32
indra/llrender/llgl.h
View File

@ -37,6 +37,7 @@
#include <string>
#include <map>
#include <list>
#include "llerror.h"
#include "v4color.h"
@ -367,6 +368,35 @@ protected:
virtual void releaseName(GLuint name) = 0;
};
/*
Interface for objects that need periodic GL updates applied to them.
Used to synchronize GL updates with GL thread.
*/
class LLGLUpdate
{
public:
static std::list<LLGLUpdate*> sGLQ;
BOOL mInQ;
LLGLUpdate()
: mInQ(FALSE)
{
}
virtual ~LLGLUpdate()
{
if (mInQ)
{
std::list<LLGLUpdate*>::iterator iter = std::find(sGLQ.begin(), sGLQ.end(), this);
if (iter != sGLQ.end())
{
sGLQ.erase(iter);
}
}
}
virtual void updateGL() = 0;
};
extern LLMatrix4 gGLObliqueProjectionInverse;
#include "llglstates.h"
@ -385,4 +415,6 @@ void parse_gl_version( S32* major, S32* minor, S32* release, std::string* vendor
extern BOOL gClothRipple;
extern BOOL gNoRender;
extern BOOL gGLActive;
#endif // LL_LLGL_H

214
indra/llrender/llimagegl.cpp
View File

@ -44,7 +44,6 @@
#include "llgl.h"
#include "llrender.h"
//----------------------------------------------------------------------------
const F32 MIN_TEXTURE_LIFETIME = 10.f;
@ -57,12 +56,25 @@ S32 LLImageGL::sGlobalTextureMemoryInBytes = 0;
S32 LLImageGL::sBoundTextureMemoryInBytes = 0;
S32 LLImageGL::sCurBoundTextureMemory = 0;
S32 LLImageGL::sCount = 0;
std::list<U32> LLImageGL::sDeadTextureList;
BOOL LLImageGL::sGlobalUseAnisotropic = FALSE;
F32 LLImageGL::sLastFrameTime = 0.f;
LLImageGL* LLImageGL::sDefaultGLTexture = NULL ;
std::set<LLImageGL*> LLImageGL::sImageList;
#if !LL_RELEASE_FOR_DOWNLOAD
//-----------------------
//debug use
#define MAX_TEXTURE_LOG_SIZE 22 //2048 * 2048
std::vector<S32> LLImageGL::sTextureLoadedCounter(MAX_TEXTURE_LOG_SIZE + 1) ;
std::vector<S32> LLImageGL::sTextureBoundCounter(MAX_TEXTURE_LOG_SIZE + 1) ;
std::vector<S32> LLImageGL::sTextureCurBoundCounter(MAX_TEXTURE_LOG_SIZE + 1) ;
S32 LLImageGL::sCurTexSizeBar = -1 ;
S32 LLImageGL::sCurTexPickSize = -1 ;
LLPointer<LLImageGL> LLImageGL::sDefaultTexturep = NULL;
//------------------------
#endif
//**************************************************************************************
//below are functions for debug use
//do not delete them even though they are not currently being used.
@ -198,6 +210,14 @@ void LLImageGL::updateStats(F32 current_time)
sLastFrameTime = current_time;
sBoundTextureMemoryInBytes = sCurBoundTextureMemory;
sCurBoundTextureMemory = 0;
#if !LL_RELEASE_FOR_DOWNLOAD
for(U32 i = 0 ; i < sTextureCurBoundCounter.size() ; i++)
{
sTextureBoundCounter[i] = sTextureCurBoundCounter[i] ;
sTextureCurBoundCounter[i] = 0 ;
}
#endif
}
//static
@ -363,6 +383,10 @@ void LLImageGL::init(BOOL usemipmaps)
mGLTextureCreated = FALSE ;
mIsMask = FALSE;
mNeedsAlphaAndPickMask = TRUE ;
mDiscardLevelInAtlas = -1 ;
mTexelsInAtlas = 0 ;
mTexelsInGLTexture = 0 ;
}
void LLImageGL::cleanup()
@ -523,7 +547,7 @@ void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
is_compressed = true;
}
gGL.getTexUnit(0)->bind(this);
llverify(gGL.getTexUnit(0)->bind(this));
if (mUseMipMaps)
{
@ -728,6 +752,92 @@ void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
llpushcallstacks ;
}
BOOL LLImageGL::preAddToAtlas(S32 discard_level, const LLImageRaw* raw_image)
{
if (gGLManager.mIsDisabled)
{
llwarns << "Trying to create a texture while GL is disabled!" << llendl;
return FALSE;
}
llassert(gGLManager.mInited);
stop_glerror();
if (discard_level < 0)
{
llassert(mCurrentDiscardLevel >= 0);
discard_level = mCurrentDiscardLevel;
}
discard_level = llclamp(discard_level, 0, (S32)mMaxDiscardLevel);
// Actual image width/height = raw image width/height * 2^discard_level
S32 w = raw_image->getWidth() << discard_level;
S32 h = raw_image->getHeight() << discard_level;
// setSize may call destroyGLTexture if the size does not match
setSize(w, h, raw_image->getComponents());
if( !mHasExplicitFormat )
{
switch (mComponents)
{
case 1:
// Use luminance alpha (for fonts)
mFormatInternal = GL_LUMINANCE8;
mFormatPrimary = GL_LUMINANCE;
mFormatType = GL_UNSIGNED_BYTE;
break;
case 2:
// Use luminance alpha (for fonts)
mFormatInternal = GL_LUMINANCE8_ALPHA8;
mFormatPrimary = GL_LUMINANCE_ALPHA;
mFormatType = GL_UNSIGNED_BYTE;
break;
case 3:
mFormatInternal = GL_RGB8;
mFormatPrimary = GL_RGB;
mFormatType = GL_UNSIGNED_BYTE;
break;
case 4:
mFormatInternal = GL_RGBA8;
mFormatPrimary = GL_RGBA;
mFormatType = GL_UNSIGNED_BYTE;
break;
default:
llerrs << "Bad number of components for texture: " << (U32)getComponents() << llendl;
}
}
mCurrentDiscardLevel = discard_level;
mDiscardLevelInAtlas = discard_level;
mTexelsInAtlas = raw_image->getWidth() * raw_image->getHeight() ;
mLastBindTime = sLastFrameTime;
mGLTextureCreated = false ;
glPixelStorei(GL_UNPACK_ROW_LENGTH, raw_image->getWidth());
stop_glerror();
if(mFormatSwapBytes)
{
glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
stop_glerror();
}
return TRUE ;
}
void LLImageGL::postAddToAtlas()
{
if(mFormatSwapBytes)
{
glPixelStorei(GL_UNPACK_SWAP_BYTES, 0);
stop_glerror();
}
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
gGL.getTexUnit(0)->setTextureFilteringOption(mFilterOption);
stop_glerror();
}
BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update)
{
llpushcallstacks ;
@ -832,7 +942,7 @@ BOOL LLImageGL::setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S3
// Copy sub image from frame buffer
BOOL LLImageGL::setSubImageFromFrameBuffer(S32 fb_x, S32 fb_y, S32 x_pos, S32 y_pos, S32 width, S32 height)
{
if (gGL.getTexUnit(0)->bind(this, true))
if (gGL.getTexUnit(0)->bind(this))
{
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, fb_x, fb_y, x_pos, y_pos, width, height);
mGLTextureCreated = true;
@ -854,13 +964,17 @@ void LLImageGL::generateTextures(S32 numTextures, U32 *textures)
// static
void LLImageGL::deleteTextures(S32 numTextures, U32 *textures)
{
glDeleteTextures(numTextures, (GLuint*)textures);
for (S32 i = 0; i < numTextures; i++)
{
sDeadTextureList.push_back(textures[i]);
}
}
// static
void LLImageGL::setManualImage(U32 target, S32 miplevel, S32 intformat, S32 width, S32 height, U32 pixformat, U32 pixtype, const void *pixels)
{
glTexImage2D(target, miplevel, intformat, width, height, 0, pixformat, pixtype, pixels);
stop_glerror();
}
//create an empty GL texture: just create a texture name
@ -895,12 +1009,12 @@ BOOL LLImageGL::createGLTexture()
BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename/*=0*/)
{
llpushcallstacks ;
if (gGLManager.mIsDisabled)
{
llwarns << "Trying to create a texture while GL is disabled!" << llendl;
return FALSE;
}
mGLTextureCreated = false ;
llassert(gGLManager.mInited);
stop_glerror();
@ -1023,12 +1137,21 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_
if (old_name != 0)
{
sGlobalTextureMemoryInBytes -= mTextureMemory;
#if !LL_RELEASE_FOR_DOWNLOAD
decTextureCounter(mTextureMemory / mComponents) ;
#endif
LLImageGL::deleteTextures(1, &old_name);
stop_glerror();
}
mTextureMemory = getMipBytes(discard_level);
sGlobalTextureMemoryInBytes += mTextureMemory;
mTexelsInGLTexture = getWidth() * getHeight() ;
#if !LL_RELEASE_FOR_DOWNLOAD
incTextureCounter(mTextureMemory / mComponents) ;
#endif
// mark this as bound at this point, so we don't throw it out immediately
mLastBindTime = sLastFrameTime;
@ -1208,32 +1331,48 @@ BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
return TRUE ;
}
void LLImageGL::destroyGLTexture()
void LLImageGL::deleteDeadTextures()
{
if (mTexName != 0)
while (!sDeadTextureList.empty())
{
stop_glerror();
GLuint tex = sDeadTextureList.front();
sDeadTextureList.pop_front();
for (int i = 0; i < gGLManager.mNumTextureUnits; i++)
{
if (sCurrentBoundTextures[i] == mTexName)
if (sCurrentBoundTextures[i] == tex)
{
gGL.getTexUnit(i)->unbind(LLTexUnit::TT_TEXTURE);
stop_glerror();
}
}
sGlobalTextureMemoryInBytes -= mTextureMemory;
mTextureMemory = 0;
glDeleteTextures(1, &tex);
stop_glerror();
}
}
void LLImageGL::destroyGLTexture()
{
if (mTexName != 0)
{
if(mTextureMemory)
{
#if !LL_RELEASE_FOR_DOWNLOAD
decTextureCounter(mTextureMemory / mComponents) ;
#endif
sGlobalTextureMemoryInBytes -= mTextureMemory;
mTextureMemory = 0;
}
LLImageGL::deleteTextures(1, &mTexName);
mTexName = 0;
mCurrentDiscardLevel = -1 ; //invalidate mCurrentDiscardLevel.
mGLTextureCreated = FALSE ;
stop_glerror();
}
}
//----------------------------------------------------------------------------
void LLImageGL::setAddressMode(LLTexUnit::eTextureAddressMode mode)
@ -1259,12 +1398,12 @@ void LLImageGL::setFilteringOption(LLTexUnit::eTextureFilterOptions option)
mFilterOption = option;
}
if (gGL.getTexUnit(gGL.getCurrentTexUnitIndex())->getCurrTexture() == mTexName)
if (mTexName != 0 && gGL.getTexUnit(gGL.getCurrentTexUnitIndex())->getCurrTexture() == mTexName)
{
gGL.getTexUnit(gGL.getCurrentTexUnitIndex())->setTextureFilteringOption(option);
mTexOptionsDirty = false;
stop_glerror();
}
stop_glerror();
}
BOOL LLImageGL::getIsResident(BOOL test_now)
@ -1500,7 +1639,50 @@ BOOL LLImageGL::getMask(const LLVector2 &tc)
}
//----------------------------------------------------------------------------
#if !LL_RELEASE_FOR_DOWNLOAD
//for debug use
//val is a "power of two" number
S32 LLImageGL::getTextureCounterIndex(U32 val)
{
//index range is [0, MAX_TEXTURE_LOG_SIZE].
if(val < 2)
{
return 0 ;
}
else if(val >= (1 << MAX_TEXTURE_LOG_SIZE))
{
return MAX_TEXTURE_LOG_SIZE ;
}
else
{
S32 ret = 0 ;
while(val >>= 1)
{
++ret;
}
return ret ;
}
}
void LLImageGL::incTextureCounter(U32 val)
{
sTextureLoadedCounter[getTextureCounterIndex(val)]++ ;
}
void LLImageGL::decTextureCounter(U32 val)
{
sTextureLoadedCounter[getTextureCounterIndex(val)]-- ;
}
void LLImageGL::setCurTexSizebar(S32 index)
{
sCurTexSizeBar = index ;
sCurTexPickSize = (1 << index) ;
}
void LLImageGL::resetCurTexSizebar()
{
sCurTexSizeBar = -1 ;
sCurTexPickSize = -1 ;
}
//----------------------------------------------------------------------------
#endif
// Manual Mip Generation
/*

44
indra/llrender/llimagegl.h
View File

@ -42,7 +42,7 @@
#include "v2math.h"
#include "llrender.h"
class LLTextureAtlas ;
#define BYTES_TO_MEGA_BYTES(x) ((x) >> 20)
#define MEGA_BYTES_TO_BYTES(x) ((x) << 20)
@ -52,6 +52,10 @@ class LLImageGL : public LLRefCount
{
friend class LLTexUnit;
public:
static std::list<U32> sDeadTextureList;
static void deleteDeadTextures();
// Size calculation
static S32 dataFormatBits(S32 dataformat);
static S32 dataFormatBytes(S32 dataformat, S32 width, S32 height);
@ -69,7 +73,6 @@ public:
// Sometimes called externally for textures not using LLImageGL (should go away...)
static S32 updateBoundTexMem(const S32 delta);
static bool checkSize(S32 width, S32 height);
//for server side use only.
@ -115,6 +118,7 @@ public:
void destroyGLTexture();
void setExplicitFormat(LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format = 0, BOOL swap_bytes = FALSE);
void setComponents(S8 ncomponents) { mComponents = ncomponents; }
S32 getDiscardLevel() const { return mCurrentDiscardLevel; }
S32 getMaxDiscardLevel() const { return mMaxDiscardLevel; }
@ -128,6 +132,7 @@ public:
S32 getMipBytes(S32 discard_level = -1) const;
BOOL getBoundRecently() const;
LLGLenum getPrimaryFormat() const { return mFormatPrimary; }
LLGLenum getFormatType() const { return mFormatType; }
BOOL getHasGLTexture() const { return mTexName != 0; }
LLGLuint getTexName() const { return mTexName; }
@ -164,10 +169,20 @@ public:
void setFilteringOption(LLTexUnit::eTextureFilterOptions option);
LLTexUnit::eTextureFilterOptions getFilteringOption(void) const { return mFilterOption; }
LLGLenum getTexTarget()const { return mTarget ;}
S8 getDiscardLevelInAtlas()const {return mDiscardLevelInAtlas;}
U32 getTexelsInAtlas()const { return mTexelsInAtlas ;}
U32 getTexelsInGLTexture()const {return mTexelsInGLTexture;}
void init(BOOL usemipmaps);
virtual void cleanup(); // Clean up the LLImageGL so it can be reinitialized. Be careful when using this in derived class destructors
void setNeedsAlphaAndPickMask(BOOL need_mask) {mNeedsAlphaAndPickMask = need_mask;}
BOOL preAddToAtlas(S32 discard_level, const LLImageRaw* raw_image);
void postAddToAtlas() ;
public:
// Various GL/Rendering options
S32 mTextureMemory;
@ -189,6 +204,10 @@ private:
U16 mHeight;
S8 mCurrentDiscardLevel;
S8 mDiscardLevelInAtlas;
U32 mTexelsInAtlas ;
U32 mTexelsInGLTexture;
protected:
LLGLenum mTarget; // Normally GL_TEXTURE2D, sometimes something else (ex. cube maps)
LLTexUnit::eTextureType mBindTarget; // Normally TT_TEXTURE, sometimes something else (ex. cube maps)
@ -224,7 +243,26 @@ public:
static U32 sBindCount; // Tracks number of texture binds for current frame
static U32 sUniqueCount; // Tracks number of unique texture binds for current frame
static BOOL sGlobalUseAnisotropic;
static LLImageGL* sDefaultGLTexture ;
static LLImageGL* sDefaultGLTexture ;
static BOOL sAutomatedTest;
#if !LL_RELEASE_FOR_DOWNLOAD
//for debug use: show texture size distribution
//----------------------------------------
static LLPointer<LLImageGL> sDefaultTexturep; //default texture to replace normal textures
static std::vector<S32> sTextureLoadedCounter ;
static std::vector<S32> sTextureBoundCounter ;
static std::vector<S32> sTextureCurBoundCounter ;
static S32 sCurTexSizeBar ;
static S32 sCurTexPickSize ;
static S32 getTextureCounterIndex(U32 val) ;
static void incTextureCounter(U32 val) ;
static void decTextureCounter(U32 val) ;
static void setCurTexSizebar(S32 index) ;
static void resetCurTexSizebar();
//----------------------------------------
#endif
#if DEBUG_MISS
BOOL mMissed; // Missed on last bind?

10
indra/llrender/llrender.cpp
View File

@ -45,10 +45,11 @@ LLRender gGL;
// Handy copies of last good GL matrices
F64 gGLModelView[16];
F64 gGLLastModelView[16];
F64 gGLLastProjection[16];
F64 gGLProjection[16];
S32 gGLViewport[4];
static const U32 LL_NUM_TEXTURE_LAYERS = 8;
static const U32 LL_NUM_TEXTURE_LAYERS = 16;
static GLenum sGLTextureType[] =
{
@ -311,6 +312,11 @@ bool LLTexUnit::bind(LLRenderTarget* renderTarget, bool bindDepth)
if (bindDepth)
{
if (renderTarget->hasStencil())
{
llerrs << "Cannot bind a render buffer for sampling. Allocate render target without a stencil buffer if sampling of depth buffer is required." << llendl;
}
bindManual(renderTarget->getUsage(), renderTarget->getDepth());
}
else
@ -328,7 +334,7 @@ bool LLTexUnit::bindManual(eTextureType type, U32 texture, bool hasMips)
{
return false;
}
if(mCurrTexture != texture)
{
gGL.flush();

1
indra/llrender/llrender.h
View File

@ -355,6 +355,7 @@ private:
extern F64 gGLModelView[16];
extern F64 gGLLastModelView[16];
extern F64 gGLLastProjection[16];
extern F64 gGLProjection[16];
extern S32 gGLViewport[4];

63
indra/llrender/llrendertarget.cpp
View File

@ -140,7 +140,7 @@ void LLRenderTarget::addColorAttachment(U32 color_fmt)
U32 offset = mTex.size();
if (offset >= 4 ||
offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers))
(offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers)))
{
llerrs << "Too many color attachments!" << llendl;
}
@ -204,7 +204,7 @@ void LLRenderTarget::allocateDepth()
gGL.getTexUnit(0)->bindManual(mUsage, mDepth);
U32 internal_type = LLTexUnit::getInternalType(mUsage);
gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
LLImageGL::setManualImage(internal_type, 0, GL_DEPTH24_STENCIL8_EXT, mResX, mResY, GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT, NULL);
LLImageGL::setManualImage(internal_type, 0, GL_DEPTH_COMPONENT32_ARB, mResX, mResY, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
}
}
@ -382,7 +382,7 @@ void LLRenderTarget::flush(BOOL fetch_depth)
allocateDepth();
}
gGL.getTexUnit(0)->bind(this, true);
gGL.getTexUnit(0)->bind(this);
glCopyTexImage2D(LLTexUnit::getInternalType(mUsage), 0, GL_DEPTH24_STENCIL8_EXT, 0, 0, mResX, mResY, 0);
}
@ -392,7 +392,11 @@ void LLRenderTarget::flush(BOOL fetch_depth)
{
#if !LL_DARWIN
stop_glerror();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
stop_glerror();
if (mSampleBuffer)
{
@ -434,7 +438,6 @@ void LLRenderTarget::flush(BOOL fetch_depth)
#endif
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
glFlush();
}
}
@ -442,6 +445,7 @@ void LLRenderTarget::copyContents(LLRenderTarget& source, S32 srcX0, S32 srcY0,
S32 dstX0, S32 dstY0, S32 dstX1, S32 dstY1, U32 mask, U32 filter)
{
#if !LL_DARWIN
gGL.flush();
if (!source.mFBO || !mFBO)
{
llerrs << "Cannot copy framebuffer contents for non FBO render targets." << llendl;
@ -452,13 +456,56 @@ void LLRenderTarget::copyContents(LLRenderTarget& source, S32 srcX0, S32 srcY0,
mSampleBuffer->copyContents(source, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
else
{
if (mask == GL_DEPTH_BUFFER_BIT && source.mStencil != mStencil)
{
stop_glerror();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, source.mFBO);
gGL.getTexUnit(0)->bind(this, true);
stop_glerror();
glCopyTexSubImage2D(LLTexUnit::getInternalType(mUsage), 0, srcX0, srcY0, dstX0, dstY0, dstX1, dstY1);
stop_glerror();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
stop_glerror();
}
else
{
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, source.mFBO);
stop_glerror();
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, mFBO);
stop_glerror();
check_framebuffer_status();
stop_glerror();
glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
stop_glerror();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
stop_glerror();
}
}
#endif
}
//static
void LLRenderTarget::copyContentsToFramebuffer(LLRenderTarget& source, S32 srcX0, S32 srcY0, S32 srcX1, S32 srcY1,
S32 dstX0, S32 dstY0, S32 dstX1, S32 dstY1, U32 mask, U32 filter)
{
#if !LL_DARWIN
if (!source.mFBO)
{
llerrs << "Cannot copy framebuffer contents for non FBO render targets." << llendl;
}
{
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, source.mFBO);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, mFBO);
stop_glerror();
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
stop_glerror();
check_framebuffer_status();
stop_glerror();
glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
stop_glerror();
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
stop_glerror();
}
#endif
}
@ -613,7 +660,7 @@ void LLMultisampleBuffer::addColorAttachment(U32 color_fmt)
U32 offset = mTex.size();
if (offset >= 4 ||
offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers))
(offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers)))
{
llerrs << "Too many color attachments!" << llendl;
}

4
indra/llrender/llrendertarget.h
View File

@ -121,6 +121,7 @@ public:
U32 getTexture(U32 attachment = 0) const;
U32 getDepth(void) const { return mDepth; }
BOOL hasStencil() const { return mStencil; }
void bindTexture(U32 index, S32 channel);
@ -135,6 +136,9 @@ public:
void copyContents(LLRenderTarget& source, S32 srcX0, S32 srcY0, S32 srcX1, S32 srcY1,
S32 dstX0, S32 dstY0, S32 dstX1, S32 dstY1, U32 mask, U32 filter);
static void copyContentsToFramebuffer(LLRenderTarget& source, S32 srcX0, S32 srcY0, S32 srcX1, S32 srcY1,
S32 dstX0, S32 dstY0, S32 dstX1, S32 dstY1, U32 mask, U32 filter);
//Returns TRUE if target is ready to be rendered into.
//That is, if the target has been allocated with at least
//one renderable attachment (i.e. color buffer, depth buffer).

22
indra/llui/llfloater.cpp
View File

@ -602,6 +602,8 @@ void LLFloater::openFloater(const LLSD& key)
mOpenSignal(this, key);
onOpen(key);
dirtyRect();
}
void LLFloater::closeFloater(bool app_quitting)
@ -667,7 +669,9 @@ void LLFloater::closeFloater(bool app_quitting)
}
}
}
dirtyRect();
// Close callback
mCloseSignal(this, LLSD(app_quitting));
@ -1933,8 +1937,8 @@ void LLFloaterView::restoreAll()
LLRect LLFloaterView::findNeighboringPosition( LLFloater* reference_floater, LLFloater* neighbor )
{
LLRect base_rect = reference_floater->getRect();
S32 width = neighbor->getRect().getWidth();
S32 height = neighbor->getRect().getHeight();
LLRect::tCoordType width = neighbor->getRect().getWidth();
LLRect::tCoordType height = neighbor->getRect().getHeight();
LLRect new_rect = neighbor->getRect();
LLRect expanded_base_rect = base_rect;
@ -1953,10 +1957,10 @@ LLRect LLFloaterView::findNeighboringPosition( LLFloater* reference_floater, LLF
}
}
S32 left_margin = llmax(0, base_rect.mLeft);
S32 right_margin = llmax(0, getRect().getWidth() - base_rect.mRight);
S32 top_margin = llmax(0, getRect().getHeight() - base_rect.mTop);
S32 bottom_margin = llmax(0, base_rect.mBottom);
LLRect::tCoordType left_margin = llmax(0, base_rect.mLeft);
LLRect::tCoordType right_margin = llmax(0, getRect().getWidth() - base_rect.mRight);
LLRect::tCoordType top_margin = llmax(0, getRect().getHeight() - base_rect.mTop);
LLRect::tCoordType bottom_margin = llmax(0, base_rect.mBottom);
// find position for floater in following order
// right->left->bottom->top
@ -2262,8 +2266,8 @@ void LLFloaterView::adjustToFitScreen(LLFloater* floater, BOOL allow_partial_out
// floater is hosted elsewhere, so ignore
return;
}
S32 screen_width = getSnapRect().getWidth();
S32 screen_height = getSnapRect().getHeight();
LLRect::tCoordType screen_width = getSnapRect().getWidth();
LLRect::tCoordType screen_height = getSnapRect().getHeight();
// convert to local coordinate frame
LLRect snap_rect_local = getLocalSnapRect();

35
indra/llui/llmenugl.cpp
View File

@ -121,6 +121,8 @@ const F32 ACTIVATE_HIGHLIGHT_TIME = 0.3f;
static MenuRegistry::Register<LLMenuItemSeparatorGL> register_separator("menu_item_separator");
static MenuRegistry::Register<LLMenuItemCallGL> register_menu_item_call("menu_item_call");
static MenuRegistry::Register<LLMenuItemCheckGL> register_menu_item_check("menu_item_check");
// Created programmatically but we need to specify custom colors in xml
static MenuRegistry::Register<LLMenuItemTearOffGL> register_menu_item_tear_off("menu_item_tear_off");
static MenuRegistry::Register<LLMenuGL> register_menu("menu");
static LLDefaultChildRegistry::Register<LLMenuGL> register_menu_default("menu");
@ -390,8 +392,10 @@ void LLMenuItemGL::buildDrawLabel( void )
void LLMenuItemGL::onCommit( void )
{
// close all open menus by default
// if parent menu is actually visible (and we are not triggering menu item via accelerator)
// Check torn-off status to allow left-arrow keyboard navigation back
// to parent menu.
// Also, don't hide if item triggered by keyboard shortcut (and hence
// parent not visible).
if (!getMenu()->getTornOff()
&& getMenu()->getVisible())
{
@ -408,6 +412,12 @@ void LLMenuItemGL::onCommit( void )
{
getMenu()->clearHoverItem();
}
if (mHighlight != highlight)
{
dirtyRect();
}
mHighlight = highlight;
}
@ -1233,6 +1243,8 @@ void LLMenuItemBranchGL::openMenu()
branch->translate( delta_x, delta_y );
branch->setVisible( TRUE );
branch->getParent()->sendChildToFront(branch);
dirtyRect();
}
}
@ -2334,8 +2346,8 @@ void LLMenuGL::createJumpKeys()
{
char jump_key = uppercase_word[i];
if (LLStringOps::isDigit(jump_key) || LLStringOps::isUpper(jump_key) &&
mJumpKeys.find(jump_key) == mJumpKeys.end())
if (LLStringOps::isDigit(jump_key) || (LLStringOps::isUpper(jump_key) &&
mJumpKeys.find(jump_key) == mJumpKeys.end()))
{
mJumpKeys.insert(std::pair<KEY, LLMenuItemGL*>(jump_key, (*item_it)));
(*item_it)->setJumpKey(jump_key);
@ -3476,16 +3488,19 @@ LLTearOffMenu::LLTearOffMenu(LLMenuGL* menup) :
LLRect rect;
menup->localRectToOtherView(LLRect(-1, menup->getRect().getHeight(), menup->getRect().getWidth() + 3, 0), &rect, gFloaterView);
// make sure this floater is big enough for menu
mTargetHeight = (F32)(rect.getHeight() + floater_header_size + 5);
mTargetHeight = (F32)(rect.getHeight() + floater_header_size);
reshape(rect.getWidth(), rect.getHeight());
setRect(rect);
// attach menu to floater
menup->setFollowsAll();
menup->setFollows( FOLLOWS_LEFT | FOLLOWS_BOTTOM );
mOldParent = menup->getParent();
addChild(menup);
menup->setVisible(TRUE);
menup->translate(-menup->getRect().mLeft + 1, -menup->getRect().mBottom + 1);
LLRect menu_rect = menup->getRect();
menu_rect.setOriginAndSize( 1, 1,
menu_rect.getWidth(), menu_rect.getHeight());
menup->setRect(menu_rect);
menup->setDropShadowed(FALSE);
mMenu = menup;
@ -3513,12 +3528,6 @@ void LLTearOffMenu::draw()
// animate towards target height
reshape(getRect().getWidth(), llceil(lerp((F32)getRect().getHeight(), mTargetHeight, LLCriticalDamp::getInterpolant(0.05f))));
}
else
{
// when in stasis, remain big enough to hold menu contents
mTargetHeight = (F32)(mMenu->getRect().getHeight() + floater_header_size + 4);
reshape(mMenu->getRect().getWidth() + 3, mMenu->getRect().getHeight() + floater_header_size + 5);
}
LLFloater::draw();
}

68
indra/llui/llradiogroup.cpp
View File

@ -45,8 +45,6 @@
#include "lluictrlfactory.h"
static LLDefaultChildRegistry::Register<LLRadioGroup> r1("radio_group");
static RadioGroupRegistry::Register<LLRadioCtrl> register_radio_ctrl("radio_item");
@ -83,6 +81,10 @@ LLRadioGroup::~LLRadioGroup()
// virtual
BOOL LLRadioGroup::postBuild()
{
if (!mRadioButtons.empty())
{
mRadioButtons[0]->setTabStop(true);
}
if (mControlVariable)
{
setSelectedIndex(mControlVariable->getValue().asInteger());
@ -102,7 +104,7 @@ void LLRadioGroup::setIndexEnabled(S32 index, BOOL enabled)
child->setEnabled(enabled);
if (index == mSelectedIndex && enabled == FALSE)
{
setSelectedIndex(-1);
mSelectedIndex = -1;
}
break;
}
@ -142,8 +144,28 @@ BOOL LLRadioGroup::setSelectedIndex(S32 index, BOOL from_event)
return FALSE;
}
if (mSelectedIndex >= 0)
{
LLRadioCtrl* old_radio_item = mRadioButtons[mSelectedIndex];
old_radio_item->setTabStop(false);
old_radio_item->setValue( FALSE );
}
else
{
mRadioButtons[0]->setTabStop(false);
}
mSelectedIndex = index;
LLRadioCtrl* radio_item = mRadioButtons[mSelectedIndex];
radio_item->setTabStop(true);
radio_item->setValue( TRUE );
if (hasFocus())
{
mRadioButtons[mSelectedIndex]->focusFirstItem(FALSE, FALSE);
}
if (!from_event)
{
setControlValue(getSelectedIndex());
@ -211,33 +233,6 @@ BOOL LLRadioGroup::handleKeyHere(KEY key, MASK mask)
return handled;
}
void LLRadioGroup::draw()
{
S32 current_button = 0;
BOOL take_focus = FALSE;
if (gFocusMgr.childHasKeyboardFocus(this))
{
take_focus = TRUE;
}
for (button_list_t::iterator iter = mRadioButtons.begin();
iter != mRadioButtons.end(); ++iter)
{
LLRadioCtrl* radio = *iter;
BOOL selected = (current_button == mSelectedIndex);
radio->setValue( selected );
if (take_focus && selected && !gFocusMgr.childHasKeyboardFocus(radio))
{
// don't flash keyboard focus when navigating via keyboard
BOOL DONT_FLASH = FALSE;
radio->focusFirstItem(FALSE, DONT_FLASH);
}
current_button++;
}
LLView::draw();
}
// When adding a child button, we need to ensure that the radio
// group gets a message when the button is clicked.
@ -259,6 +254,19 @@ bool LLRadioGroup::addChild(LLView* view, S32 tab_group)
return res;
}
BOOL LLRadioGroup::handleMouseDown(S32 x, S32 y, MASK mask)
{
// grab focus preemptively, before child button takes mousecapture
//
if (hasTabStop())
{
focusFirstItem(FALSE, FALSE);
}
return LLUICtrl::handleMouseDown(x, y, mask);
}
// Handle one button being clicked. All child buttons must have this
// function as their callback function.

9
indra/llui/llradiogroup.h
View File

@ -54,7 +54,10 @@ public:
Params()
: length("length"),
type("type")
{}
{
// radio items are not tabbable until they are selected
tab_stop = false;
}
};
/*virtual*/ ~LLRadioCtrl();
@ -103,6 +106,7 @@ public:
virtual BOOL postBuild();
virtual bool addChild(LLView* view, S32 tab_group = 0);
virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask);
virtual BOOL handleKeyHere(KEY key, MASK mask);
@ -117,9 +121,6 @@ public:
virtual void setValue(const LLSD& value );
virtual LLSD getValue() const;
// Draw the group, but also fix the highlighting based on the control.
void draw();
// Update the control as needed. Userdata must be a pointer to the button.
void onClickButton(LLUICtrl* clicked_radio);

9
indra/llui/lltabcontainer.cpp
View File

@ -329,10 +329,13 @@ void LLTabContainer::draw()
}
// Hide all the buttons
for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
if (getTabsHidden())
{
LLTabTuple* tuple = *iter;
tuple->mButton->setVisible( FALSE );
for(tuple_list_t::iterator iter = mTabList.begin(); iter != mTabList.end(); ++iter)
{
LLTabTuple* tuple = *iter;
tuple->mButton->setVisible( FALSE );
}
}
LLPanel::draw();

3
indra/llui/lltextbase.cpp
View File

@ -420,8 +420,9 @@ BOOL LLTextBase::handleToolTipForUrl(LLView *view, S32 x, S32 y, std::string& ms
LLToolTipMgr::instance().show(LLToolTipParams()
.message(tooltip_msg)
.sticky_rect(sticky_rect_screen));
return TRUE;
}
return TRUE;
return FALSE;
}
LLContextMenu *LLTextBase::createUrlContextMenu(const std::string &in_url)

23
indra/llui/lltextbox.cpp
View File

@ -161,7 +161,12 @@ BOOL LLTextBox::handleHover(S32 x, S32 y, MASK mask)
BOOL LLTextBox::handleToolTip(S32 x, S32 y, std::string& msg, LLRect& sticky_rect_screen)
{
return handleToolTipForUrl(this, x, y, msg, sticky_rect_screen);
if (handleToolTipForUrl(this, x, y, msg, sticky_rect_screen))
{
return TRUE;
}
return LLUICtrl::handleToolTip(x, y, msg, sticky_rect_screen);
}
void LLTextBox::setText(const LLStringExplicit& text)
@ -297,7 +302,7 @@ LLWString LLTextBox::getWrappedText(const LLStringExplicit& in_text, F32 max_wid
// find the next Url in the text string
LLUrlMatch match;
while ( LLUrlRegistry::instance().findUrl(wstring_to_utf8str(wtext), match))
while ( LLUrlRegistry::instance().findUrl(wtext, match))
{
S32 start = match.getStart();
S32 end = match.getEnd() + 1;
@ -573,17 +578,21 @@ void LLTextBox::updateDisplayTextAndSegments()
LLWString text = mText.getWString();
// find the next Url in the text string
while ( LLUrlRegistry::instance().findUrl(wstring_to_utf8str(text), match,
while ( LLUrlRegistry::instance().findUrl(text, match,
boost::bind(&LLTextBox::onUrlLabelUpdated, this, _1, _2)) )
{
// work out the char offset for the start/end of the url
S32 url_start = match.getStart();
S32 url_end = match.getEnd();
// and the char offset for the label in the display text
S32 seg_start = mDisplayText.size();
S32 start = seg_start + match.getStart();
end = start + match.getLabel().size();
S32 start = seg_start + url_start;
S32 end = start + match.getLabel().size();
// create a segment for the text before the Url
mSegments.insert(new LLNormalTextSegment(new LLStyle(), seg_start, start, *this));
mDisplayText += text.substr(0, match.getStart());
mDisplayText += text.substr(0, url_start);
// create a segment for the Url text
LLStyleSP html(new LLStyle);
@ -599,7 +608,7 @@ void LLTextBox::updateDisplayTextAndSegments()
mDisplayText += utf8str_to_wstring(match.getLabel());
// move on to the rest of the text after the Url
text = text.substr(match.getEnd()+1, text.size() - match.getEnd());
text = text.substr(url_end+1, text.size() - url_end);
}
// output a segment for the remaining text

17
indra/llui/lltexteditor.cpp
View File

@ -1120,21 +1120,12 @@ void LLTextEditor::updateCursorXPos()
}
// constraint cursor to editable segments of document
// NOTE: index must be within document range
S32 LLTextEditor::getEditableIndex(S32 index, bool increasing_direction)
{
//// always allow editable position at end of doc
//if (index == getLength())
//{
// return index;
//}
segment_set_t::iterator segment_iter;
S32 offset;
getSegmentAndOffset(index, &segment_iter, &offset);
if (segment_iter == mSegments.end())
{
return 0;
}
LLTextSegmentPtr segmentp = *segment_iter;
@ -3194,7 +3185,11 @@ void LLTextEditor::draw()
drawLineNumbers();
{
LLLocalClipRect clip(mTextRect);
// pad clipping rectangle so that cursor can draw at full width
// when at left edge of mTextRect
LLRect clip_rect(mTextRect);
clip_rect.stretch(1);
LLLocalClipRect clip(clip_rect);
drawSelectionBackground();
drawPreeditMarker();
drawText();

17
indra/llui/llui.cpp
View File

@ -81,7 +81,8 @@ std::list<std::string> gUntranslated;
/*static*/ LLWindow* LLUI::sWindow = NULL;
/*static*/ LLHtmlHelp* LLUI::sHtmlHelp = NULL;
/*static*/ LLView* LLUI::sRootView = NULL;
/*static*/ BOOL LLUI::sDirty = FALSE;
/*static*/ LLRect LLUI::sDirtyRect;
/*static*/ std::vector<std::string> LLUI::sXUIPaths;
/*static*/ LLFrameTimer LLUI::sMouseIdleTimer;
@ -1603,6 +1604,20 @@ void LLUI::cleanupClass()
sImageProvider->cleanUp();
}
//static
void LLUI::dirtyRect(LLRect rect)
{
if (!sDirty)
{
sDirtyRect = rect;
sDirty = TRUE;
}
else
{
sDirtyRect.unionWith(rect);
}
}
//static
void LLUI::translate(F32 x, F32 y, F32 z)

4
indra/llui/llui.h
View File

@ -174,6 +174,10 @@ public:
static void loadIdentity();
static void translate(F32 x, F32 y, F32 z = 0.0f);
static LLRect sDirtyRect;
static BOOL sDirty;
static void dirtyRect(LLRect rect);
// Return the ISO639 language name ("en", "ko", etc.) for the viewer UI.
// http://www.loc.gov/standards/iso639-2/php/code_list.php
static std::string getLanguage();

50
indra/llui/lluictrl.cpp
View File

@ -506,56 +506,6 @@ void LLUICtrl::setFocus(BOOL b)
}
}
void LLUICtrl::onFocusReceived()
{
// trigger callbacks
LLFocusableElement::onFocusReceived();
// find first view in hierarchy above new focus that is a LLUICtrl
LLView* viewp = getParent();
LLUICtrl* last_focus = dynamic_cast<LLUICtrl*>(gFocusMgr.getLastKeyboardFocus());
while (viewp && !viewp->isCtrl())
{
viewp = viewp->getParent();
}
// and if it has newly gained focus, call onFocusReceived()
LLUICtrl* ctrlp = static_cast<LLUICtrl*>(viewp);
if (ctrlp && (!last_focus || !last_focus->hasAncestor(ctrlp)))
{
ctrlp->onFocusReceived();
}
}
void LLUICtrl::onFocusLost()
{
// trigger callbacks
LLFocusableElement::onFocusLost();
// find first view in hierarchy above old focus that is a LLUICtrl
LLView* viewp = getParent();
while (viewp && !viewp->isCtrl())
{
viewp = viewp->getParent();
}
// and if it has just lost focus, call onFocusReceived()
LLUICtrl* ctrlp = static_cast<LLUICtrl*>(viewp);
// hasFocus() includes any descendants
if (ctrlp && !ctrlp->hasFocus())
{
ctrlp->onFocusLost();
}
}
void LLUICtrl::onTopLost()
{
// trigger callbacks
LLFocusableElement::onTopLost();
}
// virtual
void LLUICtrl::setTabStop( BOOL b )
{

3
indra/llui/lluictrl.h
View File

@ -153,9 +153,6 @@ protected:
public:
// LLView interface
/*virtual*/ BOOL setLabelArg( const std::string& key, const LLStringExplicit& text );
/*virtual*/ void onFocusReceived();
/*virtual*/ void onFocusLost();
/*virtual*/ void onTopLost();
/*virtual*/ BOOL isCtrl() const;
/*virtual*/ void setTentative(BOOL b);
/*virtual*/ BOOL getTentative() const;

28
indra/llui/llurlregistry.cpp
View File

@ -162,3 +162,31 @@ bool LLUrlRegistry::findUrl(const std::string &text, LLUrlMatch &match, const LL
return false;
}
bool LLUrlRegistry::findUrl(const LLWString &text, LLUrlMatch &match, const LLUrlLabelCallback &cb)
{
// boost::regex_search() only works on char or wchar_t
// types, but wchar_t is only 2-bytes on Win32 (not 4).
// So we use UTF-8 to make this work the same everywhere.
std::string utf8_text = wstring_to_utf8str(text);
if (findUrl(utf8_text, match, cb))
{
// we cannot blindly return the start/end offsets from
// the UTF-8 string because it is a variable-length
// character encoding, so we need to update the start
// and end values to be correct for the wide string.
LLWString wurl = utf8str_to_wstring(match.getUrl());
S32 start = text.find(wurl);
if (start == std::string::npos)
{
return false;
}
S32 end = start + wurl.size() - 1;
match.setValues(start, end, match.getUrl(), match.getLabel(),
match.getTooltip(), match.getIcon(),
match.getMenuName(), match.getLocation());
return true;
}
return false;
}

6
indra/llui/llurlregistry.h
View File

@ -37,10 +37,10 @@
#include "llurlentry.h"
#include "llurlmatch.h"
#include "llsingleton.h"
#include "llstring.h"
#include <string>
#include <vector>
#include <map>
/// This default callback for findUrl() simply ignores any label updates
void LLUrlRegistryNullCallback(const std::string &url, const std::string &label);
@ -77,6 +77,10 @@ public:
bool findUrl(const std::string &text, LLUrlMatch &match,
const LLUrlLabelCallback &cb = &LLUrlRegistryNullCallback);
/// a slightly less efficient version of findUrl for wide strings
bool findUrl(const LLWString &text, LLUrlMatch &match,
const LLUrlLabelCallback &cb = &LLUrlRegistryNullCallback);
private:
LLUrlRegistry();
friend class LLSingleton<LLUrlRegistry>;

54
indra/llui/llview.cpp
View File

@ -143,6 +143,7 @@ LLView::LLView(const LLView::Params& p)
LLView::~LLView()
{
dirtyRect();
//llinfos << "Deleting view " << mName << ":" << (void*) this << llendl;
// llassert(LLView::sIsDrawing == FALSE);
@ -602,6 +603,7 @@ void LLView::setVisible(BOOL visible)
if (!getParent() || getParent()->isInVisibleChain())
{
// tell all children of this view that the visibility may have changed
dirtyRect();
handleVisibilityChange( visible );
}
updateBoundingRect();
@ -673,9 +675,13 @@ LLView* LLView::childrenHandleToolTip(S32 x, S32 y, std::string& msg, LLRect& st
LLView* viewp = *child_it;
S32 local_x = x - viewp->getRect().mLeft;
S32 local_y = y - viewp->getRect().mBottom;
if(viewp->pointInView(local_x, local_y) &&
viewp->getVisible() &&
viewp->handleToolTip(local_x, local_y, msg, sticky_rect_screen) )
if(!viewp->pointInView(local_x, local_y) ||
!viewp->getVisible())
{
continue;
}
if(viewp->handleToolTip(local_x, local_y, msg, sticky_rect_screen) )
{
if (sDebugMouseHandling)
{
@ -685,17 +691,22 @@ LLView* LLView::childrenHandleToolTip(S32 x, S32 y, std::string& msg, LLRect& st
handled_view = viewp;
break;
}
if( viewp->blockMouseEvent(x, y) )
{
handled_view = viewp;
}
}
return handled_view;
}
BOOL LLView::handleToolTip(S32 x, S32 y, std::string& msg, LLRect& sticky_rect_screen)
{
LLView* child_handler = childrenHandleToolTip(x, y, msg, sticky_rect_screen);
BOOL handled = child_handler != NULL;
BOOL handled = FALSE;
// child widgets get priority on tooltips
if (!handled && !mToolTipMsg.empty())
// parents provide tooltips first, which are optionally
// overridden by children
if (!mToolTipMsg.empty())
{
// allow "scrubbing" over ui by showing next tooltip immediately
// if previous one was still visible
@ -710,7 +721,9 @@ BOOL LLView::handleToolTip(S32 x, S32 y, std::string& msg, LLRect& sticky_rect_s
handled = TRUE;
}
if( blockMouseEvent(x, y) )
// child tooltips will override our own
LLView* child_handler = childrenHandleToolTip(x, y, msg, sticky_rect_screen);
if (child_handler)
{
handled = TRUE;
}
@ -1297,7 +1310,7 @@ void LLView::drawChildren()
{
// Only draw views that are within the root view
localRectToScreen(viewp->getRect(),&screenRect);
if ( rootRect.overlaps(screenRect) )
if ( rootRect.overlaps(screenRect) && LLUI::sDirtyRect.overlaps(screenRect))
{
glMatrixMode(GL_MODELVIEW);
LLUI::pushMatrix();
@ -1316,6 +1329,21 @@ void LLView::drawChildren()
gGL.getTexUnit(0)->disable();
}
void LLView::dirtyRect()
{
LLView* child = getParent();
LLView* parent = child ? child->getParent() : NULL;
LLView* cur = this;
while (child && parent && parent->getParent())
{ //find third to top-most view
cur = child;
child = parent;
parent = parent->getParent();
}
LLUI::dirtyRect(cur->calcScreenRect());
}
//Draw a box for debugging.
void LLView::drawDebugRect()
{
@ -1529,6 +1557,8 @@ void LLView::updateBoundingRect()
{
if (isDead()) return;
LLRect cur_rect = mBoundingRect;
if (mUseBoundingRect)
{
mBoundingRect = calcBoundingRect();
@ -1543,6 +1573,12 @@ void LLView::updateBoundingRect()
{
getParent()->updateBoundingRect();
}
if (mBoundingRect != cur_rect)
{
dirtyRect();
}
}
LLRect LLView::calcScreenRect() const

1
indra/llui/llview.h
View File

@ -519,6 +519,7 @@ public:
virtual BOOL handleUnicodeCharHere(llwchar uni_char);
virtual void handleReshape(const LLRect& rect, bool by_user);
virtual void dirtyRect();
virtual void notifyParent(const LLSD& info);
virtual void notifyChildren(const LLSD& info);

1
indra/lscript/lscript_compile/indra.l
View File

@ -150,6 +150,7 @@ extern "C" { int yyerror(const char *fmt, ...); }
"AGENT_CROUCHING" { count(); yylval.ival = AGENT_CROUCHING; return(INTEGER_CONSTANT); }
"AGENT_BUSY" { count(); yylval.ival = AGENT_BUSY; return(INTEGER_CONSTANT); }
"AGENT_ALWAYS_RUN" { count(); yylval.ival = AGENT_ALWAYS_RUN; return(INTEGER_CONSTANT); }
"AGENT_AUTOPILOT" { count(); yylval.ival = AGENT_AUTOPILOT; return(INTEGER_CONSTANT); }
"CAMERA_PITCH" { count(); yylval.ival = FOLLOWCAM_PITCH; return(INTEGER_CONSTANT); }
"CAMERA_FOCUS_OFFSET" { count(); yylval.ival = FOLLOWCAM_FOCUS_OFFSET; return (INTEGER_CONSTANT); }

4
indra/newview/CMakeLists.txt
View File

@ -372,6 +372,8 @@ set(viewer_SOURCE_FILES
lltexglobalcolor.cpp
lltexlayer.cpp
lltexlayerparams.cpp
lltextureatlas.cpp
lltextureatlasmanager.cpp
lltexturecache.cpp
lltexturectrl.cpp
lltexturefetch.cpp
@ -830,6 +832,8 @@ set(viewer_HEADER_FILES
lltexglobalcolor.h
lltexlayer.h
lltexlayerparams.h
lltextureatlas.h
lltextureatlasmanager.h
lltexturecache.h
lltexturectrl.h
lltexturefetch.h

1
indra/newview/app_settings/keywords.ini
View File

@ -108,6 +108,7 @@ AGENT_TYPING Returned by llGetAgentInfo if the Agent is typing
AGENT_CROUCHING Returned by llGetAgentInfo if the Agent is crouching
AGENT_BUSY Returned by llGetAgentInfo if the Agent is busy
AGENT_ALWAYS_RUN Returned by llGetAgentInfo if the Agent has 'Always Run' enabled
AGENT_AUTOPILOT Returned by llGetAgentInfo if the Agent is under autopilot control
PSYS_PART_FLAGS
PSYS_PART_START_COLOR

676
indra/newview/app_settings/settings.xml
View File

@ -2597,6 +2597,17 @@
<key>Value</key>
<integer>1</integer>
</map>
<key>EnableTextureAtlas</key>
<map>
<key>Comment</key>
<string>Whether to use texture atlas or not</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Boolean</string>
<key>Value</key>
<integer>0</integer>
</map>
<key>EnableVoiceChat</key>
<map>
<key>Comment</key>
@ -5513,23 +5524,7 @@
<key>Value</key>
<integer>1</integer>
</map>
<key>RenderShadowGaussian</key>
<map>
<key>Comment</key>
<string>Gaussian coefficients for the two shadow/SSAO blurring passes (z component unused).</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Vector3</string>
<key>Value</key>
<array>
<real>2.0</real>
<real>2.0</real>
<real>0.0</real>
</array>
</map>
<key>RenderShadowNearDist</key>
<map>
<key>Comment</key>
@ -5554,12 +5549,75 @@
<key>Type</key>
<string>Vector3</string>
<key>Value</key>
<array>
<real>1.0</real>
<real>12.0</real>
<real>32.0</real>
</array>
</map>
<key>RenderShadowSplitExponent</key>
<map>
<key>Comment</key>
<string>Near clip plane split distances for shadow map frusta (x=perspective, y=ortho, z=transition rate).</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Vector3</string>
<key>Value</key>
<array>
<real>3.0</real>
<real>3.0</real>
<real>2.0</real>
</array>
</map>
<key>RenderShadowOrthoClipPlanes</key>
<map>
<key>Comment</key>
<string>Near clip plane split distances for orthographic shadow map frusta.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Vector3</string>
<key>Value</key>
<array>
<real>4.0</real>
<real>8.0</real>
<real>24.0</real>
</array>
</map>
<key>RenderShadowProjOffset</key>
<map>
<key>Comment</key>
<string>Amount to scale distance to virtual origin of shadow perspective projection.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>2.0</real>
</map>
<key>RenderShadowSlopeThreshold</key>
<map>
<key>Comment</key>
<string>Cutoff slope value for points to affect perspective shadow generation</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.0</real>
</map>
<key>RenderShadowProjExponent</key>
<map>
<key>Comment</key>
<string>Exponent applied to transition between ortho and perspective shadow projections based on viewing angle and light vector.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.5</real>
</map>
<key>RenderSSAOScale</key>
<map>
<key>Comment</key>
@ -5628,7 +5686,7 @@
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>128</real>
<real>64</real>
</map>
<key>RenderCubeMap</key>
<map>
@ -5707,7 +5765,7 @@
<key>Value</key>
<integer>0</integer>
</map>
<key>RenderAnimateTrees</key>
<map>
<key>Comment</key>
@ -5719,6 +5777,174 @@
<key>Value</key>
<integer>0</integer>
</map>
<key>RenderGIRange</key>
<map>
<key>Comment</key>
<string>Distance to cut off GI effect.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>96</real>
</map>
<key>RenderGILuminance</key>
<map>
<key>Comment</key>
<string>Luminance factor of global illumination contribution.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.075</real>
</map>
<key>RenderGIBrightness</key>
<map>
<key>Comment</key>
<string>Brightness factor of global illumination contribution.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.3</real>
</map>
<key>RenderGINoise</key>
<map>
<key>Comment</key>
<string>Noise of position sampling for GI photon mapping.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.7</real>
</map>
<key>RenderGIAttenuation</key>
<map>
<key>Comment</key>
<string>Distance attenuation factor for indirect lighting.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.1</real>
</map>
<key>RenderGIBlurBrightness</key>
<map>
<key>Comment</key>
<string>Brightness factor of global illumination blur effect.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>1.025</real>
</map>
<key>RenderGIBlurEdgeWeight</key>
<map>
<key>Comment</key>
<string>Edge weight for GI soften filter (sharpness).</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.8</real>
</map>
<key>RenderGIBlurIncrement</key>
<map>
<key>Comment</key>
<string>Increment of scale for each pass of global illumination blur effect.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.8</real>
</map>
<key>RenderLuminanceScale</key>
<map>
<key>Comment</key>
<string>Luminance value scalar for darkening effect.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>1.0</real>
</map>
<key>RenderSunLuminanceScale</key>
<map>
<key>Comment</key>
<string>Sun Luminance value scalar for darkening effect.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>1.0</real>
</map>
<key>RenderSunLuminanceOffset</key>
<map>
<key>Comment</key>
<string>Sun Luminance value offset for darkening effect.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0</real>
</map>
<key>RenderLuminanceDetail</key>
<map>
<key>Comment</key>
<string>Mipmap level to use for luminance</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>16.0</real>
</map>
<key>RenderEdgeDepthCutoff</key>
<map>
<key>Comment</key>
<string>Cutoff for depth difference that amounts to an edge.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.01</real>
</map>
<key>RenderEdgeNormCutoff</key>
<map>
<key>Comment</key>
<string>Cutoff for normal difference that amounts to an edge.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.25</real>
</map>
<key>RenderDeferredAlphaSoften</key>
<map>
<key>Comment</key>
@ -5741,6 +5967,178 @@
<key>Value</key>
<real>4</real>
</map>
<key>RenderDeferredSpotShadowBias</key>
<map>
<key>Comment</key>
<string>Bias value for spot shadows (prevent shadow acne).</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>-64.0</real>
</map>
<key>RenderDeferredSpotShadowOffset</key>
<map>
<key>Comment</key>
<string>Offset value for spot shadows (prevent shadow acne).</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.8</real>
</map>
<key>RenderShadowBias</key>
<map>
<key>Comment</key>
<string>Bias value for shadows (prevent shadow acne).</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>-0.008</real>
</map>
<key>RenderShadowOffset</key>
<map>
<key>Comment</key>
<string>Offset value for shadows (prevent shadow acne).</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.01</real>
</map>
<key>RenderShadowResolutionScale</key>
<map>
<key>Comment</key>
<string>Scale of shadow map resolution vs. screen resolution</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>1.0</real>
</map>
<key>RenderDeferredTreeShadowBias</key>
<map>
<key>Comment</key>
<string>Bias value for tree shadows (prevent shadow acne).</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>1.0</real>
</map>
<key>RenderDeferredTreeShadowOffset</key>
<map>
<key>Comment</key>
<string>Offset value for tree shadows (prevent shadow acne).</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>1.0</real>
</map>
<key>RenderHighlightFadeTime</key>
<map>
<key>Comment</key>
<string>Transition time for mouseover highlights.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.1</real>
</map>
<key>RenderHighlightBrightness</key>
<map>
<key>Comment</key>
<string>Brightness of mouseover highlights.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>4.0</real>
</map>
<key>RenderHighlightThickness</key>
<map>
<key>Comment</key>
<string>Thickness of mouseover highlights.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.6</real>
</map>
<key>RenderHighlightColor</key>
<map>
<key>Comment</key>
<string>Brightness of mouseover highlights.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Color4</string>
<key>Value</key>
<array>
<real>0.4</real>
<real>0.98</real>
<real>0.93</real>
<real>1.0</real>
</array>
</map>
<key>RenderSpecularResX</key>
<map>
<key>Comment</key>
<string>Spec map resolution.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>U32</string>
<key>Value</key>
<real>128</real>
</map>
<key>RenderSpecularResY</key>
<map>
<key>Comment</key>
<string>Spec map resolution.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>U32</string>
<key>Value</key>
<real>128</real>
</map>
<key>RenderSpecularExponent</key>
<map>
<key>Comment</key>
<string>Specular exponent for generating spec map</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>1</real>
</map>
<key>RenderDeferred</key>
<map>
<key>Comment</key>
@ -5752,6 +6150,31 @@
<key>Value</key>
<integer>0</integer>
</map>
<key>RenderDeferredShadow</key>
<map>
<key>Comment</key>
<string>Enable shadows in deferred renderer.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Boolean</string>
<key>Value</key>
<integer>1</integer>
</map>
<key>RenderDeferredGI</key>
<map>
<key>Comment</key>
<string>Enable GI in deferred renderer.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Boolean</string>
<key>Value</key>
<integer>0</integer>
</map>
<key>RenderDeferredSunShadow</key>
<map>
<key>Comment</key>
@ -5763,6 +6186,67 @@
<key>Value</key>
<integer>1</integer>
</map>
<key>RenderDeferredSun</key>
<map>
<key>Comment</key>
<string>Execute sunlight shader in deferred renderer.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Boolean</string>
<key>Value</key>
<integer>1</integer>
</map>
<key>RenderDeferredAtmospheric</key>
<map>
<key>Comment</key>
<string>Execute atmospheric shader in deferred renderer.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Boolean</string>
<key>Value</key>
<integer>1</integer>
</map>
<key>RenderDeferredBlurLight</key>
<map>
<key>Comment</key>
<string>Execute shadow softening shader in deferred renderer.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Boolean</string>
<key>Value</key>
<integer>1</integer>
</map>
<key>RenderDeferredLocalLights</key>
<map>
<key>Comment</key>
<string>Execute local lighting shader in deferred renderer.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Boolean</string>
<key>Value</key>
<integer>1</integer>
</map>
<key>RenderDeferredFullscreenLights</key>
<map>
<key>Comment</key>
<string>Execute local lighting shader in deferred renderer.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Boolean</string>
<key>Value</key>
<integer>1</integer>
</map>
<key>RenderDeferredSunWash</key>
<map>
<key>Comment</key>
@ -5785,6 +6269,45 @@
<key>Value</key>
<real>-0.0001</real>
</map>
<key>RenderShadowErrorCutoff</key>
<map>
<key>Comment</key>
<string>Cutoff error value to use ortho instead of perspective projection.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>5.0</real>
</map>
<key>RenderShadowFOVCutoff</key>
<map>
<key>Comment</key>
<string>Cutoff FOV to use ortho instead of perspective projection.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>1.1</real>
</map>
<key>RenderShadowGaussian</key>
<map>
<key>Comment</key>
<string>Gaussian coefficients for the two shadow/SSAO blurring passes (z component unused).</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Vector3</string>
<key>Value</key>
<array>
<real>3.0</real>
<real>2.0</real>
<real>0.0</real>
</array>
</map>
<key>RenderShadowBlurSize</key>
<map>
<key>Comment</key>
@ -5794,7 +6317,7 @@
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.7</real>
<real>1.4</real>
</map>
<key>RenderShadowBlurSamples</key>
<map>
@ -5805,8 +6328,106 @@
<key>Type</key>
<string>U32</string>
<key>Value</key>
<real>5</real>
<real>4</real>
</map>
<key>RenderShadowBlurDistFactor</key>
<map>
<key>Comment</key>
<string>Distance scaler for shadow blur.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.1</real>
</map>
<key>RenderGIAmbiance</key>
<map>
<key>Comment</key>
<string>Ambiance factor of global illumination contribution.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.5</real>
</map>
<key>RenderGIMinRenderSize</key>
<map>
<key>Comment</key>
<string>Minimum size of objects to put into GI source map.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.5</real>
</map>
<key>RenderGIBlurColorCurve</key>
<map>
<key>Comment</key>
<string>Color curve for GI softening kernel</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Vector3</string>
<key>Value</key>
<array>
<real>1.0</real>
<real>0.6</real>
<real>0.02</real>
</array>
</map>
<key>RenderGIBlurPasses</key>
<map>
<key>Comment</key>
<string>Scale of GI softening kernel.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>U32</string>
<key>Value</key>
<real>4</real>
</map>
<key>RenderGIBlurSize</key>
<map>
<key>Comment</key>
<string>Scale of GI softening kernel.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>4.0</real>
</map>
<key>RenderGIBlurSamples</key>
<map>
<key>Comment</key>
<string>Number of samples to take for each pass of GI blur (value range 1-16). Actual number of samples is value * 2 - 1.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>U32</string>
<key>Value</key>
<real>16</real>
</map>
<key>RenderGIBlurDistFactor</key>
<map>
<key>Comment</key>
<string>Distance scaler for GI blur.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>F32</string>
<key>Value</key>
<real>0.0</real>
</map>
<key>RenderDynamicLOD</key>
<map>
<key>Comment</key>
@ -6143,7 +6764,7 @@
<key>Type</key>
<string>S32</string>
<key>Value</key>
<integer>4096</integer>
<integer>8192</integer>
</map>
<key>RenderMaxVBOSize</key>
<map>
@ -6354,6 +6975,17 @@
<key>Value</key>
<integer>0</integer>
</map>
<key>RenderUIBuffer</key>
<map>
<key>Comment</key>
<string>Cache ui render in a screen aligned buffer.</string>
<key>Persist</key>
<integer>1</integer>
<key>Type</key>
<string>Boolean</string>
<key>Value</key>
<integer>0</integer>
</map>
<key>RenderUnloadedAvatar</key>
<map>
<key>Comment</key>

57
indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
View File

@ -8,14 +8,10 @@
#extension GL_ARB_texture_rectangle : enable
uniform sampler2D diffuseMap;
uniform sampler2DShadow shadowMap0;
uniform sampler2DShadow shadowMap1;
uniform sampler2DShadow shadowMap2;
uniform sampler2DShadow shadowMap3;
uniform sampler2D noiseMap;
uniform sampler2DRect positionMap;
uniform sampler2DRect depthMap;
uniform mat4 shadow_matrix[4];
uniform mat4 shadow_matrix[6];
uniform vec4 shadow_clip;
uniform vec2 screen_res;
@ -26,52 +22,42 @@ varying vec3 vary_ambient;
varying vec3 vary_directional;
varying vec3 vary_fragcoord;
varying vec3 vary_position;
varying vec3 vary_light;
uniform float alpha_soften;
uniform mat4 inv_proj;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
void main()
{
vec2 frag = vary_fragcoord.xy/vary_fragcoord.z*0.5+0.5;
frag *= screen_res;
vec3 samp_pos = texture2DRect(positionMap, frag).xyz;
vec3 samp_pos = getPosition(frag).xyz;
float shadow = 1.0;
vec4 pos = vec4(vary_position, 1.0);
if (pos.z > -shadow_clip.w)
{
if (pos.z < -shadow_clip.z)
{
vec4 lpos = shadow_matrix[3]*pos;
shadow = shadow2DProj(shadowMap3, lpos).x;
shadow += max((pos.z+shadow_clip.z)/(shadow_clip.z-shadow_clip.w)*2.0-1.0, 0.0);
}
else if (pos.z < -shadow_clip.y)
{
vec4 lpos = shadow_matrix[2]*pos;
shadow = shadow2DProj(shadowMap2, lpos).x;
}
else if (pos.z < -shadow_clip.x)
{
vec4 lpos = shadow_matrix[1]*pos;
shadow = shadow2DProj(shadowMap1, lpos).x;
}
else
{
vec4 lpos = shadow_matrix[0]*pos;
shadow = shadow2DProj(shadowMap0, lpos).x;
}
}
vec4 col = vec4(vary_ambient + vary_directional.rgb*shadow, gl_Color.a);
vec4 col = vec4(vary_ambient + vary_directional.rgb, gl_Color.a);
vec4 color = texture2D(diffuseMap, gl_TexCoord[0].xy) * col;
color.rgb = atmosLighting(color.rgb);
color.rgb = scaleSoftClip(color.rgb);
if (samp_pos.z != 0.0)
if (samp_pos.z != 0.0 && gl_Color.a < 1.0)
{
float dist_factor = alpha_soften;
float a = gl_Color.a;
@ -83,6 +69,7 @@ void main()
//gl_FragColor = gl_Color;
gl_FragColor = color;
//gl_FragColor = vec4(1,0,1,1);
//gl_FragColor = vec4(1,0,1,1)*shadow;
}

8
indra/newview/app_settings/shaders/class1/deferred/alphaV.glsl
View File

@ -20,8 +20,11 @@ varying vec3 vary_ambient;
varying vec3 vary_directional;
varying vec3 vary_fragcoord;
varying vec3 vary_position;
varying vec3 vary_light;
uniform float near_clip;
uniform float shadow_offset;
uniform float shadow_bias;
void main()
{
@ -32,8 +35,9 @@ void main()
vec4 pos = (gl_ModelViewMatrix * gl_Vertex);
vec3 norm = normalize(gl_NormalMatrix * gl_Normal);
vary_position = pos.xyz;
vary_position = pos.xyz + norm.xyz * (-pos.z/64.0*shadow_offset+shadow_bias);
calcAtmospherics(pos.xyz);
//vec4 color = calcLighting(pos.xyz, norm, gl_Color, vec4(0.));
@ -54,6 +58,8 @@ void main()
col.rgb += gl_LightSource[1].diffuse.rgb*calcDirectionalLight(norm, gl_LightSource[1].position.xyz);
col.rgb = scaleDownLight(col.rgb);
vary_light = gl_LightSource[0].position.xyz;
vary_ambient = col.rgb*gl_Color.rgb;
vary_directional.rgb = gl_Color.rgb*atmosAffectDirectionalLight(max(calcDirectionalLight(norm, gl_LightSource[0].position.xyz), (1.0-gl_Color.a)*(1.0-gl_Color.a)));

2
indra/newview/app_settings/shaders/class1/deferred/avatarAlphaF.glsl
View File

@ -12,7 +12,7 @@ uniform sampler2DShadow shadowMap2;
uniform sampler2DShadow shadowMap3;
uniform sampler2D noiseMap;
uniform mat4 shadow_matrix[4];
uniform mat4 shadow_matrix[6];
uniform vec4 shadow_clip;
vec3 atmosLighting(vec3 light);

13
indra/newview/app_settings/shaders/class1/deferred/avatarF.glsl
View File

@ -8,13 +8,18 @@
uniform sampler2D diffuseMap;
varying vec3 vary_normal;
varying vec4 vary_position;
void main()
{
gl_FragData[0] = gl_Color * texture2D(diffuseMap, gl_TexCoord[0].xy);
vec4 diff = gl_Color*texture2D(diffuseMap, gl_TexCoord[0].xy);
if (diff.a < 0.2)
{
discard;
}
gl_FragData[0] = vec4(diff.rgb, 0.0);
gl_FragData[1] = vec4(0,0,0,0);
gl_FragData[2] = vec4(normalize(vary_normal), 0.0);
gl_FragData[3] = vary_position;
gl_FragData[2] = vec4(normalize(vary_normal)*0.5+0.5, 0.0);
}

3
indra/newview/app_settings/shaders/class1/deferred/avatarShadowF.glsl
View File

@ -10,6 +10,7 @@ uniform sampler2D diffuseMap;
void main()
{
gl_FragColor = vec4(1,1,1,gl_Color.a * texture2D(diffuseMap, gl_TexCoord[0].xy));
gl_FragColor = vec4(1,1,1,gl_Color.a * texture2D(diffuseMap, gl_TexCoord[0].xy).a);
//gl_FragColor = vec4(1,1,1,1);
}

3
indra/newview/app_settings/shaders/class1/deferred/avatarShadowV.glsl
View File

@ -28,8 +28,7 @@ void main()
norm = normalize(norm);
pos = gl_ProjectionMatrix * pos;
//smash geometry against near clip plane
pos.z = max(pos.z, -1.0);
pos.z = max(pos.z, -pos.w+0.01);
gl_Position = pos;
gl_FrontColor = gl_Color;

2
indra/newview/app_settings/shaders/class1/deferred/avatarV.glsl
View File

@ -10,7 +10,6 @@ mat4 getSkinnedTransform();
attribute vec4 weight;
varying vec3 vary_normal;
varying vec4 vary_position;
void main()
{
@ -30,7 +29,6 @@ void main()
norm.z = dot(trans[2].xyz, gl_Normal);
norm = normalize(norm);
vary_position = pos;
vary_normal = norm;
gl_Position = gl_ProjectionMatrix * pos;

42
indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl
View File

@ -7,10 +7,12 @@
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect positionMap;
uniform sampler2DRect depthMap;
uniform sampler2DRect normalMap;
uniform sampler2DRect lightMap;
uniform sampler2DRect giLightMap;
uniform float dist_factor;
uniform float blur_size;
uniform vec2 delta;
uniform vec3 kern[32];
@ -19,30 +21,52 @@ uniform float kern_scale;
varying vec2 vary_fragcoord;
uniform mat4 inv_proj;
uniform vec2 screen_res;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
void main()
{
vec3 norm = texture2DRect(normalMap, vary_fragcoord.xy).xyz;
vec3 pos = texture2DRect(positionMap, vary_fragcoord.xy).xyz;
vec2 ccol = texture2DRect(lightMap, vary_fragcoord.xy).rg;
vec3 norm = texture2DRect(normalMap, vary_fragcoord.xy).xyz*2.0-1.0;
vec3 pos = getPosition(vary_fragcoord.xy).xyz;
vec4 ccol = texture2DRect(lightMap, vary_fragcoord.xy).rgba;
vec2 dlt = kern_scale * delta / (1.0+norm.xy*norm.xy);
dlt /= max(-pos.z*dist_factor, 1.0);
vec2 defined_weight = kern[0].xy; // special case the first (centre) sample's weight in the blur; we have to sample it anyway so we get it for 'free'
vec2 col = defined_weight * ccol;
vec4 col = defined_weight.xyxx * ccol;
for (int i = 1; i < kern_length; i++)
{
vec2 tc = vary_fragcoord.xy + kern[i].z*dlt;
vec3 samppos = texture2DRect(positionMap, tc).xyz;
vec3 samppos = getPosition(tc).xyz;
float d = dot(norm.xyz, samppos.xyz-pos.xyz);// dist from plane
if (d*d <= 0.003)
{
col += texture2DRect(lightMap, tc).rg*kern[i].xy;
col += texture2DRect(lightMap, tc)*kern[i].xyxx;
defined_weight += kern[i].xy;
}
}
col /= defined_weight;
gl_FragColor = vec4(col.r, col.g, 0.0, 1.0);
col /= defined_weight.xyxx;
gl_FragColor = col;
//gl_FragColor = ccol;
}

8
indra/newview/app_settings/shaders/class1/deferred/bumpF.glsl
View File

@ -11,7 +11,6 @@ uniform sampler2D bumpMap;
varying vec3 vary_mat0;
varying vec3 vary_mat1;
varying vec3 vary_mat2;
varying vec4 vary_position;
void main()
{
@ -22,8 +21,7 @@ void main()
dot(norm,vary_mat1),
dot(norm,vary_mat2));
gl_FragData[0].rgb = gl_Color.rgb*col;
gl_FragData[1] = vec4(col*(gl_Color.a*1.5), gl_Color.a);
gl_FragData[2] = vec4(normalize(tnorm), 0.0);
gl_FragData[3] = vary_position;
gl_FragData[0] = vec4(gl_Color.rgb*col, 0.0);
gl_FragData[1] = vec4(col*gl_Color.a, gl_Color.a);
gl_FragData[2] = vec4(normalize(tnorm)*0.5+0.5, 0.0);
}

3
indra/newview/app_settings/shaders/class1/deferred/bumpV.glsl
View File

@ -8,7 +8,6 @@
varying vec3 vary_mat0;
varying vec3 vary_mat1;
varying vec3 vary_mat2;
varying vec4 vary_position;
void main()
{
@ -16,8 +15,6 @@ void main()
gl_Position = ftransform();
gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
vary_position = gl_ModelViewMatrix * gl_Vertex;
vec3 n = normalize(gl_NormalMatrix * gl_Normal);
vec3 b = normalize(gl_NormalMatrix * gl_MultiTexCoord2.xyz);
vec3 t = cross(b, n);

6
indra/newview/app_settings/shaders/class1/deferred/diffuseF.glsl
View File

@ -8,13 +8,11 @@
uniform sampler2D diffuseMap;
varying vec3 vary_normal;
varying vec4 vary_position;
void main()
{
vec3 col = texture2D(diffuseMap, gl_TexCoord[0].xy).rgb;
gl_FragData[0] = vec4(gl_Color.rgb*col, 1.0);
gl_FragData[0] = vec4(gl_Color.rgb*col, 0.0);
gl_FragData[1] = vec4(col*(gl_Color.a*1.5), gl_Color.a);
gl_FragData[2] = vec4(normalize(vary_normal), 0.0);
gl_FragData[3] = vary_position;
gl_FragData[2] = vec4(normalize(vary_normal)*0.5+0.5, 0.0);
}

5
indra/newview/app_settings/shaders/class1/deferred/diffuseV.glsl
View File

@ -6,16 +6,13 @@
*/
varying vec3 vary_normal;
varying vec4 vary_position;
void main()
{
//transform vertex
gl_Position = ftransform();
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
vary_position = gl_ModelViewMatrix * gl_Vertex;
vary_normal = normalize(gl_NormalMatrix * gl_Normal);
gl_FrontColor = gl_Color;

28
indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
View File

@ -8,14 +8,9 @@
#extension GL_ARB_texture_rectangle : enable
uniform sampler2D diffuseMap;
uniform sampler2DShadow shadowMap0;
uniform sampler2DShadow shadowMap1;
uniform sampler2DShadow shadowMap2;
uniform sampler2DShadow shadowMap3;
uniform sampler2DRect depthMap;
uniform sampler2D noiseMap;
uniform sampler2DRect positionMap;
uniform mat4 shadow_matrix[4];
uniform vec4 shadow_clip;
uniform vec2 screen_res;
@ -30,12 +25,27 @@ varying vec3 vary_fragcoord;
uniform float alpha_soften;
uniform mat4 inv_proj;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
void main()
{
vec2 frag = vary_fragcoord.xy/vary_fragcoord.z*0.5+0.5;
frag *= screen_res;
vec3 samp_pos = texture2DRect(positionMap, frag).xyz;
vec3 samp_pos = getPosition(frag).xyz;
float shadow = 1.0;
vec4 pos = vary_position;
@ -46,10 +56,10 @@ void main()
color.rgb = fullbrightScaleSoftClip(color.rgb);
if (samp_pos.z != 0.0)
if (samp_pos.z != 0.0 && color.a < 1.0)
{
float dist_factor = alpha_soften;
float a = gl_Color.a;
float a = color.a;
a *= a;
dist_factor *= 1.0/(1.0-a);
color.a *= min((pos.z-samp_pos.z)*dist_factor, 1.0);

2
indra/newview/app_settings/shaders/class1/deferred/fullbrightV.glsl
View File

@ -12,12 +12,12 @@ vec3 atmosAffectDirectionalLight(float lightIntensity);
vec3 scaleDownLight(vec3 light);
vec3 scaleUpLight(vec3 light);
varying vec4 vary_position;
varying vec3 vary_ambient;
varying vec3 vary_directional;
varying vec3 vary_normal;
varying vec3 vary_fragcoord;
uniform float near_clip;
varying vec4 vary_position;
void main()
{

165
indra/newview/app_settings/shaders/class1/deferred/giF.glsl Normal file
View File

@ -0,0 +1,165 @@
/**
* @file giF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect depthMap;
uniform sampler2DRect normalMap;
uniform sampler2D noiseMap;
uniform sampler2D diffuseGIMap;
uniform sampler2D normalGIMap;
uniform sampler2D depthGIMap;
uniform sampler2D lightFunc;
// Inputs
varying vec2 vary_fragcoord;
uniform vec2 screen_res;
uniform mat4 inv_proj;
uniform mat4 gi_mat; //gPipeline.mGIMatrix - eye space to sun space
uniform mat4 gi_mat_proj; //gPipeline.mGIMatrixProj - eye space to projected sun space
uniform mat4 gi_norm_mat; //gPipeline.mGINormalMatrix - eye space normal to sun space normal matrix
uniform mat4 gi_inv_proj; //gPipeline.mGIInvProj - projected sun space to sun space
uniform float gi_radius;
uniform float gi_intensity;
uniform int gi_samples;
uniform vec2 gi_kern[25];
uniform vec2 gi_scale;
uniform vec3 gi_quad;
uniform vec3 gi_spec;
uniform float gi_direction_weight;
uniform float gi_light_offset;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
vec4 getGIPosition(vec2 gi_tc)
{
float depth = texture2D(depthGIMap, gi_tc).a;
vec2 sc = gi_tc*2.0;
sc -= vec2(1.0, 1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = gi_inv_proj*ndc;
pos.xyz /= pos.w;
pos.w = 1.0;
return pos;
}
vec3 giAmbient(vec3 pos, vec3 norm)
{
vec4 gi_c = gi_mat_proj * vec4(pos, 1.0);
gi_c.xyz /= gi_c.w;
vec4 gi_pos = gi_mat*vec4(pos,1.0);
vec3 gi_norm = (gi_norm_mat*vec4(norm,1.0)).xyz;
gi_norm = normalize(gi_norm);
vec2 tcx = gi_norm.xy;
vec2 tcy = gi_norm.yx;
vec4 eye_pos = gi_mat*vec4(0,0,0,1.0);
vec3 eye_dir = normalize(gi_pos.xyz-eye_pos.xyz/eye_pos.w);
//vec3 eye_dir = vec3(0,0,-1);
//eye_dir = (gi_norm_mat*vec4(eye_dir, 1.0)).xyz;
//eye_dir = normalize(eye_dir);
//float round_x = gi_scale.x;
//float round_y = gi_scale.y;
vec3 debug = texture2D(normalGIMap, gi_c.xy).rgb*0.5+0.5;
debug.xz = vec2(0.0,0.0);
//debug = fract(debug);
float round_x = 1.0/64.0;
float round_y = 1.0/64.0;
//gi_c.x = floor(gi_c.x/round_x+0.5)*round_x;
//gi_c.y = floor(gi_c.y/round_y+0.5)*round_y;
float fda = 0.0;
vec3 fdiff = vec3(0,0,0);
vec3 rcol = vec3(0,0,0);
float fsa = 0.0;
for (int i = -1; i < 2; i+=2 )
{
for (int j = -1; j < 2; j+=2)
{
vec2 tc = vec2(i, j)*0.75;
vec3 nz = texture2D(noiseMap, vary_fragcoord.xy/128.0+tc*0.5).xyz;
//tc += gi_norm.xy*nz.z;
tc += nz.xy*2.0;
tc /= gi_samples;
tc += gi_c.xy;
vec3 lnorm = -normalize(texture2D(normalGIMap, tc.xy).xyz*2.0-1.0);
vec3 lpos = getGIPosition(tc.xy).xyz;
vec3 at = lpos-gi_pos.xyz;
float dist = dot(at,at);
float da = clamp(1.0/(gi_spec.x*dist), 0.0, 1.0);
if (da > 0.0)
{
//add angular attenuation
vec3 ldir = at;
float ang_atten = clamp(dot(ldir, gi_norm), 0.0, 1.0);
float ld = -dot(ldir, lnorm);
if (ang_atten > 0.0 && ld < 0.0)
{
vec3 diff = texture2D(diffuseGIMap, tc.xy).xyz;
da = da*ang_atten;
fda += da;
fdiff += diff*da;
}
}
}
}
fdiff /= max(gi_spec.y*fda, gi_quad.z);
fdiff = clamp(fdiff, vec3(0), vec3(1));
vec3 ret = fda*fdiff;
//ret = ret*ret*gi_quad.x+ret*gi_quad.y+gi_quad.z;
//fda *= nz.z;
//rcol.rgb *= gi_intensity;
//return rcol.rgb+vary_AmblitColor.rgb*0.25;
//return vec4(debug, 0.0);
//return vec4(fda*fdiff, 0.0);
return clamp(ret,vec3(0.0), vec3(1.0));
//return debug.xyz;
}
void main()
{
vec2 pos_screen = vary_fragcoord.xy;
vec4 pos = getPosition(pos_screen);
vec3 norm = texture2DRect(normalMap, pos_screen).xyz*2.0-1.0;
gl_FragData[0].xyz = giAmbient(pos, norm);
}

22
indra/newview/app_settings/shaders/class1/deferred/giV.glsl Normal file
View File

@ -0,0 +1,22 @@
/**
* @file giV.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
varying vec2 vary_fragcoord;
uniform vec2 screen_res;
void main()
{
//transform vertex
gl_Position = ftransform();
vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
vary_fragcoord = (pos.xy * 0.5 + 0.5)*screen_res;
vec4 tex = gl_MultiTexCoord0;
tex.w = 1.0;
gl_FrontColor = gl_Color;
}

5
indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl
View File

@ -9,12 +9,9 @@ uniform sampler2D diffuseMap;
uniform sampler2D normalMap;
uniform sampler2D specularMap;
varying vec4 vary_position;
void main()
{
gl_FragData[0] = texture2D(diffuseMap, gl_TexCoord[0].xy);
gl_FragData[1] = texture2D(specularMap, gl_TexCoord[0].xy);
gl_FragData[2] = vec4(texture2D(normalMap, gl_TexCoord[0].xy).xyz, vary_position.z);
gl_FragData[3] = vary_position;
gl_FragData[2] = vec4(texture2D(normalMap, gl_TexCoord[0].xy).xyz, 0.0);
}

4
indra/newview/app_settings/shaders/class1/deferred/impostorV.glsl
View File

@ -5,15 +5,11 @@
* $License$
*/
varying vec4 vary_position;
void main()
{
//transform vertex
gl_Position = ftransform();
gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
vary_position = gl_ModelViewMatrix * gl_Vertex;
gl_FrontColor = gl_Color;
}

15
indra/newview/app_settings/shaders/class1/deferred/luminanceF.glsl Normal file
View File

@ -0,0 +1,15 @@
/**
* @file luminanceF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
uniform sampler2DRect diffuseMap;
varying vec2 vary_fragcoord;
void main()
{
gl_FragColor = texture2DRect(diffuseMap, vary_fragcoord.xy);
}

20
indra/newview/app_settings/shaders/class1/deferred/luminanceV.glsl Normal file
View File

@ -0,0 +1,20 @@
/**
* @file giV.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
varying vec2 vary_fragcoord;
uniform vec2 screen_res;
void main()
{
//transform vertex
gl_Position = ftransform();
vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
vary_fragcoord = (pos.xy * 0.5 + 0.5)*screen_res;
gl_FrontColor = gl_Color;
}

64
indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl
View File

@ -7,13 +7,14 @@
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect depthMap;
uniform sampler2DRect diffuseRect;
uniform sampler2DRect specularRect;
uniform sampler2DRect positionMap;
uniform sampler2DRect normalMap;
uniform samplerCube environmentMap;
uniform sampler2DRect lightMap;
uniform sampler2D noiseMap;
uniform sampler2D lightFunc;
uniform vec3 env_mat[3];
uniform float sun_wash;
@ -23,24 +24,48 @@ uniform int light_count;
uniform vec4 light[16];
uniform vec4 light_col[16];
varying vec3 vary_fragcoord;
varying vec4 vary_fragcoord;
uniform vec2 screen_res;
uniform float far_z;
uniform mat4 inv_proj;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
void main()
{
vec2 frag = (vary_fragcoord.xy*0.5+0.5)*screen_res;
vec3 pos = texture2DRect(positionMap, frag.xy).xyz;
vec3 norm = normalize(texture2DRect(normalMap, frag.xy).xyz);
vec3 pos = getPosition(frag.xy).xyz;
if (pos.z < far_z)
{
discard;
}
vec3 norm = normalize(texture2DRect(normalMap, frag.xy).xyz*2.0-1.0);
vec4 spec = texture2DRect(specularRect, frag.xy);
vec3 diff = texture2DRect(diffuseRect, frag.xy).rgb;
float noise = texture2D(noiseMap, frag.xy/128.0).b;
vec3 out_col = vec3(0,0,0);
vec3 npos = normalize(-pos);
for (int i = 0; i < light_count; ++i)
{
vec3 lv = light[i].xyz-pos;
float dist2 = dot(lv,lv);
if (dist2 > light[i].w)
dist2 /= light[i].w;
if (dist2 > 1.0)
{
continue;
}
@ -55,29 +80,38 @@ void main()
da = dot(norm, lv);
float fa = light_col[i].a+1.0;
float dist_atten = clamp(1.0-(dist2-light[i].w*(1.0-fa))/(light[i].w*fa), 0.0, 1.0);
float dist_atten = clamp(1.0-(dist2-1.0*(1.0-fa))/fa, 0.0, 1.0);
dist_atten *= noise;
float lit = da * dist_atten;
vec3 col = light_col[i].rgb*lit*diff;
//vec3 col = vec3(dist2, light_col[i].a, lit);
if (spec.a > 0.0)
{
vec3 ref = reflect(normalize(pos), norm);
float sa = dot(ref,lv);
sa = max(sa, 0.0);
sa = pow(sa, 128.0 * spec.a*spec.a/dist_atten)*min(dist_atten*4.0, 1.0);
sa *= noise;
col += da*sa*light_col[i].rgb*spec.rgb;
//vec3 ref = dot(pos+lv, norm);
float sa = dot(normalize(lv+npos),norm);
if (sa > 0.0)
{
sa = texture2D(lightFunc,vec2(sa, spec.a)).a * min(dist_atten*4.0, 1.0);
sa *= noise;
col += da*sa*light_col[i].rgb*spec.rgb;
}
}
out_col += col;
}
//attenuate point light contribution by SSAO component
out_col *= texture2DRect(lightMap, frag.xy).g;
if (dot(out_col, out_col) <= 0.0)
{
discard;
}
gl_FragColor.rgb = out_col;
gl_FragColor.a = 0.0;
//gl_FragColor = vec4(0.1, 0.025, 0.025/4.0, 0.0);
}

178
indra/newview/app_settings/shaders/class1/deferred/multiSpotLightF.glsl Normal file
View File

@ -0,0 +1,178 @@
/**
* @file multiSpotLightF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
#version 120
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect diffuseRect;
uniform sampler2DRect specularRect;
uniform sampler2DRect depthMap;
uniform sampler2DRect normalMap;
uniform samplerCube environmentMap;
uniform sampler2D noiseMap;
uniform sampler2D lightFunc;
uniform sampler2D projectionMap;
uniform mat4 proj_mat; //screen space to light space
uniform float proj_near; //near clip for projection
uniform vec3 proj_p; //plane projection is emitting from (in screen space)
uniform vec3 proj_n;
uniform float proj_focus; //distance from plane to begin blurring
uniform float proj_lod; //(number of mips in proj map)
uniform float proj_range; //range between near clip and far clip plane of projection
uniform float proj_ambiance;
uniform float near_clip;
uniform float far_clip;
uniform vec3 proj_origin; //origin of projection to be used for angular attenuation
uniform float sun_wash;
varying vec4 vary_light;
varying vec4 vary_fragcoord;
uniform vec2 screen_res;
uniform mat4 inv_proj;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
void main()
{
vec4 frag = vary_fragcoord;
frag.xyz /= frag.w;
frag.xyz = frag.xyz*0.5+0.5;
frag.xy *= screen_res;
vec3 pos = getPosition(frag.xy).xyz;
vec3 lv = vary_light.xyz-pos.xyz;
float dist2 = dot(lv,lv);
dist2 /= vary_light.w;
if (dist2 > 1.0)
{
discard;
}
vec3 norm = texture2DRect(normalMap, frag.xy).xyz*2.0-1.0;
norm = normalize(norm);
float l_dist = -dot(lv, proj_n);
vec4 proj_tc = (proj_mat * vec4(pos.xyz, 1.0));
if (proj_tc.z < 0.0)
{
discard;
}
proj_tc.xyz /= proj_tc.w;
float fa = gl_Color.a+1.0;
float dist_atten = clamp(1.0-(dist2-1.0*(1.0-fa))/fa, 0.0, 1.0);
lv = proj_origin-pos.xyz;
lv = normalize(lv);
float da = dot(norm, lv);
vec3 col = vec3(0,0,0);
vec3 diff_tex = texture2DRect(diffuseRect, frag.xy).rgb;
float noise = texture2D(noiseMap, frag.xy/128.0).b;
if (proj_tc.z > 0.0 &&
proj_tc.x < 1.0 &&
proj_tc.y < 1.0 &&
proj_tc.x > 0.0 &&
proj_tc.y > 0.0)
{
float lit = 0.0;
if (da > 0.0)
{
float diff = clamp((l_dist-proj_focus)/proj_range, 0.0, 1.0);
float lod = diff * proj_lod;
vec4 plcol = texture2DLod(projectionMap, proj_tc.xy, lod);
vec3 lcol = gl_Color.rgb * plcol.rgb * plcol.a;
lit = da * dist_atten * noise;
col = lcol*lit*diff_tex;
}
float diff = clamp((proj_range-proj_focus)/proj_range, 0.0, 1.0);
float lod = diff * proj_lod;
vec4 amb_plcol = texture2DLod(projectionMap, proj_tc.xy, lod);
//float amb_da = mix(proj_ambiance, proj_ambiance*max(-da, 0.0), max(da, 0.0));
float amb_da = proj_ambiance;
amb_da += (da*da*0.5+0.5)*proj_ambiance;
amb_da *= dist_atten * noise;
amb_da = min(amb_da, 1.0-lit);
col += amb_da*gl_Color.rgb*diff_tex.rgb*amb_plcol.rgb*amb_plcol.a;
}
vec4 spec = texture2DRect(specularRect, frag.xy);
if (spec.a > 0.0)
{
vec3 ref = reflect(normalize(pos), norm);
//project from point pos in direction ref to plane proj_p, proj_n
vec3 pdelta = proj_p-pos;
float ds = dot(ref, proj_n);
if (ds < 0.0)
{
vec3 pfinal = pos + ref * dot(pdelta, proj_n)/ds;
vec3 stc = (proj_mat * vec4(pfinal.xyz, 1.0)).xyz;
if (stc.z > 0.0)
{
stc.xy /= stc.z+proj_near;
if (stc.x < 1.0 &&
stc.y < 1.0 &&
stc.x > 0.0 &&
stc.y > 0.0)
{
vec4 scol = texture2DLod(projectionMap, stc.xy, proj_lod-spec.a*proj_lod);
col += dist_atten*scol.rgb*gl_Color.rgb*scol.a*spec.rgb;
}
}
}
}
/*if (spec.a > 0.0)
{
//vec3 ref = reflect(normalize(pos), norm);
float sa = dot(normalize(lv-normalize(pos)),norm);;
//sa = max(sa, 0.0);
//sa = pow(sa, 128.0 * spec.a*spec.a/dist_atten)*min(dist_atten*4.0, 1.0);
sa = texture2D(lightFunc, vec2(sa, spec.a)).a * min(dist_atten*4.0, 1.0);
sa *= noise;
col += da*sa*lcol*spec.rgb;
}*/
gl_FragColor.rgb = col;
gl_FragColor.a = 0.0;
}

66
indra/newview/app_settings/shaders/class1/deferred/pointLightF.glsl
View File

@ -9,33 +9,53 @@
uniform sampler2DRect diffuseRect;
uniform sampler2DRect specularRect;
uniform sampler2DRect positionMap;
uniform sampler2DRect normalMap;
uniform samplerCube environmentMap;
uniform sampler2DRect lightMap;
uniform sampler2D noiseMap;
uniform sampler2D lightFunc;
uniform sampler2DRect depthMap;
uniform vec3 env_mat[3];
uniform float sun_wash;
varying vec4 vary_light;
varying vec3 vary_fragcoord;
varying vec4 vary_fragcoord;
uniform vec2 screen_res;
uniform mat4 inv_proj;
uniform vec4 viewport;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = (pos_screen.xy-viewport.xy)*2.0;
sc /= viewport.zw;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
void main()
{
vec2 frag = vary_fragcoord.xy/vary_fragcoord.z*0.5+0.5;
frag *= screen_res;
vec3 pos = texture2DRect(positionMap, frag).xyz;
vec4 frag = vary_fragcoord;
frag.xyz /= frag.w;
frag.xyz = frag.xyz*0.5+0.5;
frag.xy *= screen_res;
vec3 pos = getPosition(frag.xy).xyz;
vec3 lv = vary_light.xyz-pos;
float dist2 = dot(lv,lv);
if (dist2 > vary_light.w)
dist2 /= vary_light.w;
if (dist2 > 1.0)
{
discard;
}
vec3 norm = texture2DRect(normalMap, frag).xyz;
vec3 norm = texture2DRect(normalMap, frag.xy).xyz*2.0-1.0;
float da = dot(norm, lv);
if (da < 0.0)
{
@ -46,30 +66,32 @@ void main()
lv = normalize(lv);
da = dot(norm, lv);
float noise = texture2D(noiseMap, frag/128.0).b;
float noise = texture2D(noiseMap, frag.xy/128.0).b;
vec3 col = texture2DRect(diffuseRect, frag).rgb;
vec3 col = texture2DRect(diffuseRect, frag.xy).rgb;
float fa = gl_Color.a+1.0;
float dist_atten = clamp(1.0-(dist2-vary_light.w*(1.0-fa))/(vary_light.w*fa), 0.0, 1.0);
float dist_atten = clamp(1.0-(dist2-1.0*(1.0-fa))/fa, 0.0, 1.0);
float lit = da * dist_atten * noise;
col = gl_Color.rgb*lit*col;
vec4 spec = texture2DRect(specularRect, frag);
vec4 spec = texture2DRect(specularRect, frag.xy);
if (spec.a > 0.0)
{
vec3 ref = reflect(normalize(pos), norm);
float sa = dot(ref,lv);
sa = max(sa, 0.0);
sa = pow(sa, 128.0 * spec.a*spec.a/dist_atten)*min(dist_atten*4.0, 1.0);
sa *= noise;
col += da*sa*gl_Color.rgb*spec.rgb;
float sa = dot(normalize(lv-normalize(pos)),norm);
if (sa > 0.0)
{
sa = texture2D(lightFunc, vec2(sa, spec.a)).a * min(dist_atten*4.0, 1.0);
sa *= noise;
col += da*sa*gl_Color.rgb*spec.rgb;
}
}
//attenuate point light contribution by SSAO component
col *= texture2DRect(lightMap, frag.xy).g;
if (dot(col, col) <= 0.0)
{
discard;
}
gl_FragColor.rgb = col;
gl_FragColor.a = 0.0;
}

6
indra/newview/app_settings/shaders/class1/deferred/pointLightV.glsl
View File

@ -6,7 +6,7 @@
*/
varying vec4 vary_light;
varying vec3 vary_fragcoord;
varying vec4 vary_fragcoord;
uniform vec2 screen_res;
uniform float near_clip;
@ -14,10 +14,10 @@ uniform float near_clip;
void main()
{
//transform vertex
gl_Position = ftransform();
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
vary_fragcoord.xyz = pos.xyz + vec3(0,0,near_clip);
vary_fragcoord = pos;
vec4 tex = gl_MultiTexCoord0;
tex.w = 1.0;

57
indra/newview/app_settings/shaders/class1/deferred/postDeferredF.glsl Normal file
View File

@ -0,0 +1,57 @@
/**
* @file postDeferredF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect diffuseRect;
uniform sampler2DRect localLightMap;
uniform sampler2DRect sunLightMap;
uniform sampler2DRect giLightMap;
uniform sampler2D luminanceMap;
uniform sampler2DRect lightMap;
uniform vec3 lum_quad;
uniform float lum_lod;
uniform vec4 ambient;
uniform vec3 gi_quad;
uniform vec2 screen_res;
varying vec2 vary_fragcoord;
void main()
{
vec2 tc = vary_fragcoord.xy;
vec3 lum = texture2DLod(luminanceMap, tc/screen_res, lum_lod).rgb;
float luminance = lum.r;
luminance = luminance*lum_quad.y+lum_quad.z;
vec4 diff = texture2DRect(diffuseRect, vary_fragcoord.xy);
float ambocc = texture2DRect(lightMap, vary_fragcoord.xy).g;
vec3 gi_col = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
gi_col = gi_col*gi_col*gi_quad.x + gi_col*gi_quad.y+gi_quad.z*ambocc*ambient.rgb;
gi_col *= diff;
vec4 sun_col = texture2DRect(sunLightMap, vary_fragcoord.xy);
vec3 local_col = texture2DRect(localLightMap, vary_fragcoord.xy).rgb;
sun_col *= 1.0/min(luminance, 1.0);
gi_col *= 1.0/luminance;
vec3 col = sun_col.rgb+gi_col+local_col;
gl_FragColor.rgb = col.rgb;
col.rgb = max(col.rgb-vec3(1.0,1.0,1.0), vec3(0.0, 0.0, 0.0));
gl_FragColor.a = 0.0; // max(dot(col.rgb,col.rgb)*lum_quad.x, sun_col.a);
//gl_FragColor.rgb = vec3(lum_lod);
}

17
indra/newview/app_settings/shaders/class1/deferred/postDeferredV.glsl Normal file
View File

@ -0,0 +1,17 @@
/**
* @file postDeferredV.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
varying vec2 vary_fragcoord;
uniform vec2 screen_res;
void main()
{
//transform vertex
gl_Position = ftransform();
vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
}

79
indra/newview/app_settings/shaders/class1/deferred/postgiF.glsl Normal file
View File

@ -0,0 +1,79 @@
/**
* @file postgiF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
uniform sampler2DRect depthMap;
uniform sampler2DRect normalMap;
uniform sampler2DRect giLightMap;
uniform sampler2D noiseMap;
uniform vec2 kern[32];
uniform float dist_factor;
uniform float blur_size;
uniform vec2 delta;
uniform int kern_length;
uniform float kern_scale;
uniform vec3 blur_quad;
varying vec2 vary_fragcoord;
uniform mat4 inv_proj;
uniform vec2 screen_res;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
void main()
{
vec3 norm = texture2DRect(normalMap, vary_fragcoord.xy).xyz*2.0-1.0;
vec3 pos = getPosition(vary_fragcoord.xy).xyz;
vec3 ccol = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
vec2 dlt = kern_scale * delta/(1.0+norm.xy*norm.xy);
dlt /= max(-pos.z*dist_factor, 1.0);
float defined_weight = kern[0].x;
vec3 col = vec3(0.0);
for (int i = 0; i < kern_length; i++)
{
vec2 tc = vary_fragcoord.xy + kern[i].y*dlt;
vec3 sampNorm = texture2DRect(normalMap, tc.xy).xyz*2.0-1.0;
float d = dot(norm.xyz, sampNorm);
if (d > 0.8)
{
vec3 samppos = getPosition(tc.xy).xyz;
samppos -= pos;
if (dot(samppos,samppos) < -0.05*pos.z)
{
col += texture2DRect(giLightMap, tc).rgb*kern[i].x;
defined_weight += kern[i].x;
}
}
}
col /= defined_weight;
//col = ccol;
col = col*col*blur_quad.x + col*blur_quad.y + blur_quad.z;
gl_FragData[0].xyz = col;
//gl_FragColor = ccol;
}

17
indra/newview/app_settings/shaders/class1/deferred/postgiV.glsl Normal file
View File

@ -0,0 +1,17 @@
/**
* @file postgiV.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
varying vec2 vary_fragcoord;
uniform vec2 screen_res;
void main()
{
//transform vertex
gl_Position = ftransform();
vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
}

3
indra/newview/app_settings/shaders/class1/deferred/shadowF.glsl
View File

@ -7,8 +7,11 @@
uniform sampler2D diffuseMap;
varying vec4 post_pos;
void main()
{
gl_FragColor = vec4(1,1,1,texture2D(diffuseMap, gl_TexCoord[0].xy).a * gl_Color.a);
gl_FragDepth = max(post_pos.z/post_pos.w*0.5+0.5, 0.0);
}

10
indra/newview/app_settings/shaders/class1/deferred/shadowV.glsl
View File

@ -5,13 +5,17 @@
* $License$
*/
varying vec4 post_pos;
void main()
{
//transform vertex
vec4 pos = gl_ModelViewProjectionMatrix*gl_Vertex;
//smash geometry against the near clip plane (great for ortho projections)
pos.z = max(pos.z, -1.0);
gl_Position = pos;
post_pos = pos;
gl_Position = vec4(pos.x, pos.y, pos.w*0.5, pos.w);
gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
gl_FrontColor = gl_Color;
}

69
indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
View File

@ -12,9 +12,9 @@ uniform sampler2DRect specularRect;
uniform sampler2DRect positionMap;
uniform sampler2DRect normalMap;
uniform sampler2DRect depthMap;
uniform sampler2DRect lightMap;
uniform sampler2D noiseMap;
uniform samplerCube environmentMap;
uniform sampler2D lightFunc;
uniform float blur_size;
uniform float blur_fidelity;
@ -38,9 +38,9 @@ uniform vec4 max_y;
uniform vec4 glow;
uniform float scene_light_strength;
uniform vec3 env_mat[3];
uniform mat4 shadow_matrix[3];
uniform vec4 shadow_clip;
uniform mat3 ssao_effect_mat;
//uniform mat4 shadow_matrix[3];
//uniform vec4 shadow_clip;
//uniform mat3 ssao_effect_mat;
varying vec4 vary_light;
varying vec2 vary_fragcoord;
@ -52,6 +52,22 @@ vec3 vary_AmblitColor;
vec3 vary_AdditiveColor;
vec3 vary_AtmosAttenuation;
uniform mat4 inv_proj;
uniform vec2 screen_res;
vec4 getPosition(vec2 pos_screen)
{ //get position in screen space (world units) given window coordinate and depth map
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
vec3 getPositionEye()
{
return vary_PositionEye;
@ -162,17 +178,7 @@ void calcAtmospherics(vec3 inPositionEye, float ambFactor) {
temp2.x += .25;
//increase ambient when there are more clouds
vec4 tmpAmbient = ambient + (vec4(1.) - ambient) * cloud_shadow.x * 0.5;
/* decrease value and saturation (that in HSV, not HSL) for occluded areas
* // for HSV color/geometry used here, see http://gimp-savvy.com/BOOK/index.html?node52.html
* // The following line of code performs the equivalent of:
* float ambAlpha = tmpAmbient.a;
* float ambValue = dot(vec3(tmpAmbient), vec3(0.577)); // projection onto <1/rt(3), 1/rt(3), 1/rt(3)>, the neutral white-black axis
* vec3 ambHueSat = vec3(tmpAmbient) - vec3(ambValue);
* tmpAmbient = vec4(RenderSSAOEffect.valueFactor * vec3(ambValue) + RenderSSAOEffect.saturationFactor *(1.0 - ambFactor) * ambHueSat, ambAlpha);
*/
tmpAmbient = vec4(mix(ssao_effect_mat * tmpAmbient.rgb, tmpAmbient.rgb, ambFactor), tmpAmbient.a);
vec4 tmpAmbient = ambient + (vec4(1.) - ambient) * cloud_shadow.x * 0.5;
//haze color
setAdditiveColor(
@ -235,36 +241,27 @@ vec3 scaleSoftClip(vec3 light)
void main()
{
vec2 tc = vary_fragcoord.xy;
vec3 pos = texture2DRect(positionMap, tc).xyz;
vec3 norm = texture2DRect(normalMap, tc).xyz;
vec3 nz = texture2D(noiseMap, vary_fragcoord.xy/128.0).xyz;
vec3 pos = getPosition(tc).xyz;
vec3 norm = texture2DRect(normalMap, tc).xyz*2.0-1.0;
//vec3 nz = texture2D(noiseMap, vary_fragcoord.xy/128.0).xyz;
float da = max(dot(norm.xyz, vary_light.xyz), 0.0);
vec4 diffuse = vec4(texture2DRect(diffuseRect, tc).rgb, 1.0);
vec4 diffuse = texture2DRect(diffuseRect, tc);
vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
vec2 scol_ambocc = texture2DRect(lightMap, vary_fragcoord.xy).rg;
float scol = scol_ambocc.r;
float ambocc = scol_ambocc.g;
calcAtmospherics(pos.xyz, ambocc);
calcAtmospherics(pos.xyz, 0.0);
vec3 col = atmosAmbient(vec3(0));
col += atmosAffectDirectionalLight(min(da, scol));
col += atmosAffectDirectionalLight(clamp(da, diffuse.a, 1.0));
col *= diffuse.rgb;
if (spec.a > 0.2)
if (spec.a > 0.0)
{
vec3 ref = reflect(pos.xyz, norm.xyz);
vec3 rc;
rc.x = dot(ref, env_mat[0]);
rc.y = dot(ref, env_mat[1]);
rc.z = dot(ref, env_mat[2]);
vec3 refcol = textureCube(environmentMap, rc).rgb;
col.rgb += refcol * spec.rgb;
vec3 ref = normalize(reflect(pos.xyz, norm.xyz));
float sa = dot(ref, vary_light.xyz);
col.rgb += vary_SunlitColor*spec.rgb*texture2D(lightFunc, vec2(sa, spec.a)).a;
}
col = atmosLighting(col);
@ -272,8 +269,4 @@ void main()
gl_FragColor.rgb = col;
gl_FragColor.a = 0.0;
//gl_FragColor.rg = scol_ambocc.rg;
//gl_FragColor.rgb = norm.rgb*0.5+0.5;
//gl_FragColor.rgb = vec3(ambocc);
//gl_FragColor.rgb = vec3(scol);
}

177
indra/newview/app_settings/shaders/class1/deferred/spotLightF.glsl Normal file
View File

@ -0,0 +1,177 @@
/**
* @file spotLightF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
#version 120
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect diffuseRect;
uniform sampler2DRect specularRect;
uniform sampler2DRect depthMap;
uniform sampler2DRect normalMap;
uniform samplerCube environmentMap;
uniform sampler2D noiseMap;
uniform sampler2D lightFunc;
uniform sampler2D projectionMap;
uniform mat4 proj_mat; //screen space to light space
uniform float proj_near; //near clip for projection
uniform vec3 proj_p; //plane projection is emitting from (in screen space)
uniform vec3 proj_n;
uniform float proj_focus; //distance from plane to begin blurring
uniform float proj_lod; //(number of mips in proj map)
uniform float proj_range; //range between near clip and far clip plane of projection
uniform float proj_ambiance;
uniform float near_clip;
uniform float far_clip;
uniform vec3 proj_origin; //origin of projection to be used for angular attenuation
uniform float sun_wash;
varying vec4 vary_light;
varying vec4 vary_fragcoord;
uniform vec2 screen_res;
uniform mat4 inv_proj;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
void main()
{
vec4 frag = vary_fragcoord;
frag.xyz /= frag.w;
frag.xyz = frag.xyz*0.5+0.5;
frag.xy *= screen_res;
vec3 pos = getPosition(frag.xy).xyz;
vec3 lv = vary_light.xyz-pos.xyz;
float dist2 = dot(lv,lv);
dist2 /= vary_light.w;
if (dist2 > 1.0)
{
discard;
}
vec3 norm = texture2DRect(normalMap, frag.xy).xyz*2.0-1.0;
norm = normalize(norm);
float l_dist = -dot(lv, proj_n);
vec4 proj_tc = (proj_mat * vec4(pos.xyz, 1.0));
if (proj_tc.z < 0.0)
{
discard;
}
proj_tc.xyz /= proj_tc.w;
float fa = gl_Color.a+1.0;
float dist_atten = clamp(1.0-(dist2-1.0*(1.0-fa))/fa, 0.0, 1.0);
lv = proj_origin-pos.xyz;
lv = normalize(lv);
float da = dot(norm, lv);
vec3 col = vec3(0,0,0);
vec3 diff_tex = texture2DRect(diffuseRect, frag.xy).rgb;
float noise = texture2D(noiseMap, frag.xy/128.0).b;
if (proj_tc.z > 0.0 &&
proj_tc.x < 1.0 &&
proj_tc.y < 1.0 &&
proj_tc.x > 0.0 &&
proj_tc.y > 0.0)
{
float lit = 0.0;
if (da > 0.0)
{
float diff = clamp((l_dist-proj_focus)/proj_range, 0.0, 1.0);
float lod = diff * proj_lod;
vec4 plcol = texture2DLod(projectionMap, proj_tc.xy, lod);
vec3 lcol = gl_Color.rgb * plcol.rgb * plcol.a;
lit = da * dist_atten * noise;
col = lcol*lit*diff_tex;
}
float diff = clamp((proj_range-proj_focus)/proj_range, 0.0, 1.0);
float lod = diff * proj_lod;
vec4 amb_plcol = texture2DLod(projectionMap, proj_tc.xy, lod);
//float amb_da = mix(proj_ambiance, proj_ambiance*max(-da, 0.0), max(da, 0.0));
float amb_da = proj_ambiance;
amb_da += (da*da*0.5+0.5)*proj_ambiance;
amb_da *= dist_atten * noise;
amb_da = min(amb_da, 1.0-lit);
col += amb_da*gl_Color.rgb*diff_tex.rgb*amb_plcol.rgb*amb_plcol.a;
}
vec4 spec = texture2DRect(specularRect, frag.xy);
if (spec.a > 0.0)
{
vec3 ref = reflect(normalize(pos), norm);
//project from point pos in direction ref to plane proj_p, proj_n
vec3 pdelta = proj_p-pos;
float ds = dot(ref, proj_n);
if (ds < 0.0)
{
vec3 pfinal = pos + ref * dot(pdelta, proj_n)/ds;
vec3 stc = (proj_mat * vec4(pfinal.xyz, 1.0)).xyz;
if (stc.z > 0.0)
{
stc.xy /= stc.z+proj_near;
if (stc.x < 1.0 &&
stc.y < 1.0 &&
stc.x > 0.0 &&
stc.y > 0.0)
{
vec4 scol = texture2DLod(projectionMap, stc.xy, proj_lod-spec.a*proj_lod);
col += dist_atten*scol.rgb*gl_Color.rgb*scol.a*spec.rgb;
}
}
}
}
/*if (spec.a > 0.0)
{
//vec3 ref = reflect(normalize(pos), norm);
float sa = dot(normalize(lv-normalize(pos)),norm);;
//sa = max(sa, 0.0);
//sa = pow(sa, 128.0 * spec.a*spec.a/dist_atten)*min(dist_atten*4.0, 1.0);
sa = texture2D(lightFunc, vec2(sa, spec.a)).a * min(dist_atten*4.0, 1.0);
sa *= noise;
col += da*sa*lcol*spec.rgb;
}*/
gl_FragColor.rgb = col;
gl_FragColor.a = 0.0;
}

111
indra/newview/app_settings/shaders/class1/deferred/sunLightF.glsl
View File

@ -7,17 +7,21 @@
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect positionMap;
uniform sampler2DRect normalMap;
uniform sampler2DRect depthMap;
uniform sampler2DShadow shadowMap0;
uniform sampler2DShadow shadowMap1;
uniform sampler2DShadow shadowMap2;
uniform sampler2DShadow shadowMap3;
uniform sampler2DRect normalMap;
uniform sampler2DRectShadow shadowMap0;
uniform sampler2DRectShadow shadowMap1;
uniform sampler2DRectShadow shadowMap2;
uniform sampler2DRectShadow shadowMap3;
uniform sampler2DRectShadow shadowMap4;
uniform sampler2DRectShadow shadowMap5;
uniform sampler2D noiseMap;
uniform sampler2D lightFunc;
// Inputs
uniform mat4 shadow_matrix[4];
uniform mat4 shadow_matrix[6];
uniform vec4 shadow_clip;
uniform float ssao_radius;
uniform float ssao_max_radius;
@ -27,6 +31,25 @@ uniform float ssao_factor_inv;
varying vec2 vary_fragcoord;
varying vec4 vary_light;
uniform mat4 inv_proj;
uniform vec2 screen_res;
uniform float shadow_bias;
uniform float shadow_offset;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
//calculate decreases in ambient lighting when crowded out (SSAO)
float calcAmbientOcclusion(vec4 pos, vec3 norm)
{
@ -54,7 +77,7 @@ float calcAmbientOcclusion(vec4 pos, vec3 norm)
for (int i = 0; i < 8; i++)
{
vec2 samppos_screen = pos_screen + scale * reflect(kern[i], noise_reflect);
vec3 samppos_world = texture2DRect(positionMap, samppos_screen).xyz;
vec3 samppos_world = getPosition(samppos_screen).xyz;
vec3 diff = pos_world - samppos_world;
float dist2 = dot(diff, diff);
@ -74,14 +97,18 @@ float calcAmbientOcclusion(vec4 pos, vec3 norm)
angle_hidden = min(ssao_factor*angle_hidden/float(points), 1.0);
return 1.0 - (float(points != 0) * angle_hidden);
return (1.0 - (float(points != 0) * angle_hidden));
}
void main()
{
vec2 pos_screen = vary_fragcoord.xy;
vec4 pos = vec4(texture2DRect(positionMap, pos_screen).xyz, 1.0);
vec3 norm = texture2DRect(normalMap, pos_screen).xyz;
//try doing an unproject here
vec4 pos = getPosition(pos_screen);
vec3 norm = texture2DRect(normalMap, pos_screen).xyz*2.0-1.0;
/*if (pos.z == 0.0) // do nothing for sky *FIX: REMOVE THIS IF/WHEN THE POSITION MAP IS BEING USED AS A STENCIL
{
@ -90,35 +117,45 @@ void main()
}*/
float shadow = 1.0;
float dp_directional_light = max(0.0, dot(norm, vary_light.xyz));
float dp_directional_light = max(0.0, dot(norm, vary_light.xyz));
vec4 spos = vec4(pos.xyz + norm.xyz * (-pos.z/64.0*shadow_offset+shadow_bias), 1.0);
//vec3 debug = vec3(0,0,0);
if (dp_directional_light == 0.0)
{
// if we know this point is facing away from the sun then we know it's in shadow without having to do a squirrelly shadow-map lookup
shadow = 0.0;
}
else if (pos.z > -shadow_clip.w)
else if (spos.z > -shadow_clip.w)
{
if (pos.z < -shadow_clip.z)
vec4 lpos;
if (spos.z < -shadow_clip.z)
{
vec4 lpos = shadow_matrix[3]*pos;
shadow = shadow2DProj(shadowMap3, lpos).x;
lpos = shadow_matrix[3]*spos;
lpos.xy *= screen_res;
shadow = shadow2DRectProj(shadowMap3, lpos).x;
shadow += max((pos.z+shadow_clip.z)/(shadow_clip.z-shadow_clip.w)*2.0-1.0, 0.0);
}
else if (pos.z < -shadow_clip.y)
else if (spos.z < -shadow_clip.y)
{
vec4 lpos = shadow_matrix[2]*pos;
shadow = shadow2DProj(shadowMap2, lpos).x;
lpos = shadow_matrix[2]*spos;
lpos.xy *= screen_res;
shadow = shadow2DRectProj(shadowMap2, lpos).x;
}
else if (pos.z < -shadow_clip.x)
else if (spos.z < -shadow_clip.x)
{
vec4 lpos = shadow_matrix[1]*pos;
shadow = shadow2DProj(shadowMap1, lpos).x;
lpos = shadow_matrix[1]*spos;
lpos.xy *= screen_res;
shadow = shadow2DRectProj(shadowMap1, lpos).x;
}
else
{
vec4 lpos = shadow_matrix[0]*pos;
shadow = shadow2DProj(shadowMap0, lpos).x;
lpos = shadow_matrix[0]*spos;
lpos.xy *= screen_res;
shadow = shadow2DRectProj(shadowMap0, lpos).x;
}
// take the most-shadowed value out of these two:
@ -126,6 +163,17 @@ void main()
// * an unblurred dot product between the sun and this norm
// the goal is to err on the side of most-shadow to fill-in shadow holes and reduce artifacting
shadow = min(shadow, dp_directional_light);
/*debug.r = lpos.y / (lpos.w*screen_res.y);
lpos.xy /= lpos.w*32.0;
if (fract(lpos.x) < 0.1 || fract(lpos.y) < 0.1)
{
debug.gb = vec2(0.5, 0.5);
}
debug += (1.0-shadow)*0.5;*/
}
else
{
@ -135,5 +183,18 @@ void main()
gl_FragColor[0] = shadow;
gl_FragColor[1] = calcAmbientOcclusion(pos, norm);
//gl_FragColor[2] is unused as of August 2008, may be used for debugging
//spotlight shadow 1
vec4 lpos = shadow_matrix[4]*spos;
lpos.xy *= screen_res;
gl_FragColor[2] = shadow2DRectProj(shadowMap4, lpos).x;
//spotlight shadow 2
lpos = shadow_matrix[5]*spos;
lpos.xy *= screen_res;
gl_FragColor[3] = shadow2DRectProj(shadowMap5, lpos).x;
//gl_FragColor.rgb = pos.xyz;
//gl_FragColor.b = shadow;
//gl_FragColor.rgb = debug;
}

6
indra/newview/app_settings/shaders/class1/deferred/terrainF.glsl
View File

@ -12,7 +12,6 @@ uniform sampler2D detail_3;
uniform sampler2D alpha_ramp;
varying vec3 vary_normal;
varying vec4 vary_position;
void main()
{
@ -28,9 +27,8 @@ void main()
float alphaFinal = texture2D(alpha_ramp, gl_TexCoord[1].zw).a;
vec4 outColor = mix( mix(color3, color2, alpha2), mix(color1, color0, alpha1), alphaFinal );
gl_FragData[0] = vec4(outColor.rgb, 1.0);
gl_FragData[0] = vec4(outColor.rgb, 0.0);
gl_FragData[1] = vec4(outColor.rgb*0.2, 0.2);
gl_FragData[2] = vec4(normalize(vary_normal), 0.0);
gl_FragData[3] = vary_position;
gl_FragData[2] = vec4(normalize(vary_normal)*0.5+0.5, 0.0);
}

2
indra/newview/app_settings/shaders/class1/deferred/terrainV.glsl
View File

@ -6,7 +6,6 @@
*/
varying vec3 vary_normal;
varying vec4 vary_position;
vec4 texgen_object(vec4 vpos, vec4 tc, mat4 mat, vec4 tp0, vec4 tp1)
{
@ -27,7 +26,6 @@ void main()
//transform vertex
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
vary_position = gl_ModelViewMatrix * gl_Vertex;
vary_normal = normalize(gl_NormalMatrix * gl_Normal);
// Transform and pass tex coords

6
indra/newview/app_settings/shaders/class1/deferred/treeF.glsl
View File

@ -8,13 +8,11 @@
uniform sampler2D diffuseMap;
varying vec3 vary_normal;
varying vec4 vary_position;
void main()
{
vec4 col = texture2D(diffuseMap, gl_TexCoord[0].xy);
gl_FragData[0] = gl_Color*col;
gl_FragData[0] = vec4(gl_Color.rgb*col.rgb, col.a <= 0.5 ? 0.0 : 0.005);
gl_FragData[1] = vec4(0,0,0,0);
gl_FragData[2] = vec4(normalize(vary_normal), 0.0);
gl_FragData[3] = vary_position;
gl_FragData[2] = vec4(normalize(vary_normal)*0.5+0.5, 0.0);
}

3
indra/newview/app_settings/shaders/class1/deferred/treeV.glsl
View File

@ -6,7 +6,6 @@
*/
varying vec3 vary_normal;
varying vec4 vary_position;
void main()
{
@ -14,8 +13,6 @@ void main()
gl_Position = ftransform();
gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
vary_position = gl_ModelViewMatrix * gl_Vertex;
vary_normal = normalize(gl_NormalMatrix * gl_Normal);
gl_FrontColor = gl_Color;

70
indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
View File

@ -5,19 +5,21 @@
* $License$
*/
#extension GL_ARB_texture_rectangle : enable
vec3 scaleSoftClip(vec3 inColor);
vec3 atmosTransport(vec3 inColor);
uniform sampler2D bumpMap;
uniform sampler2D screenTex;
uniform sampler2D refTex;
uniform sampler2DShadow shadowMap0;
uniform sampler2DShadow shadowMap1;
uniform sampler2DShadow shadowMap2;
uniform sampler2DShadow shadowMap3;
uniform sampler2DRectShadow shadowMap0;
uniform sampler2DRectShadow shadowMap1;
uniform sampler2DRectShadow shadowMap2;
uniform sampler2DRectShadow shadowMap3;
uniform sampler2D noiseMap;
uniform mat4 shadow_matrix[4];
uniform mat4 shadow_matrix[6];
uniform vec4 shadow_clip;
uniform float sunAngle;
@ -32,7 +34,8 @@ uniform vec3 normScale;
uniform float fresnelScale;
uniform float fresnelOffset;
uniform float blurMultiplier;
uniform vec2 screen_res;
uniform mat4 norm_mat; //region space to screen space
//bigWave is (refCoord.w, view.w);
varying vec4 refCoord;
@ -88,7 +91,7 @@ void main()
refcol *= df1 * 0.333;
vec3 wavef = (wave1 + wave2 * 0.4 + wave3 * 0.6) * 0.5;
wavef.z *= max(-viewVec.z, 0.1);
//wavef.z *= max(-viewVec.z, 0.1);
wavef = normalize(wavef);
float df2 = dot(viewVec, wavef) * fresnelScale+fresnelOffset;
@ -101,10 +104,10 @@ void main()
refcol = mix(baseCol*df2, refcol, dweight);
//get specular component
float spec = clamp(dot(lightDir, (reflect(viewVec,wavef))),0.0,1.0);
//float spec = clamp(dot(lightDir, (reflect(viewVec,wavef))),0.0,1.0);
//harden specular
spec = pow(spec, 128.0);
//spec = pow(spec, 128.0);
//figure out distortion vector (ripply)
vec2 distort2 = distort+wavef.xy*refScale/max(dmod*df1, 1.0);
@ -118,40 +121,21 @@ void main()
float shadow = 1.0;
vec4 pos = vary_position;
vec3 nz = texture2D(noiseMap, gl_FragCoord.xy/128.0).xyz;
if (pos.z > -shadow_clip.w)
{
vec4 spos = pos;
if (pos.z < -shadow_clip.z)
{
vec4 lpos = (shadow_matrix[3]*spos);
shadow = shadow2DProj(shadowMap3, lpos).x;
}
else if (pos.z < -shadow_clip.y)
{
vec4 lpos = (shadow_matrix[2]*spos);
shadow = shadow2DProj(shadowMap2, lpos).x;
}
else if (pos.z < -shadow_clip.x)
{
vec4 lpos = (shadow_matrix[1]*spos);
shadow = shadow2DProj(shadowMap1, lpos).x;
}
else
{
vec4 lpos = (shadow_matrix[0]*spos);
shadow = shadow2DProj(shadowMap0, lpos).x;
}
}
//vec3 nz = texture2D(noiseMap, gl_FragCoord.xy/128.0).xyz;
vec4 spos = pos;
//spec *= shadow;
//color.rgb += spec * specular;
spec *= shadow;
color.rgb += spec * specular;
color.rgb = atmosTransport(color.rgb);
color.rgb = scaleSoftClip(color.rgb);
color.a = spec * sunAngle2;
//color.rgb = atmosTransport(color.rgb);
//color.rgb = scaleSoftClip(color.rgb);
//color.a = spec * sunAngle2;
gl_FragColor = color;
//wavef.z = -0.25f;
wavef = normalize(wavef);
wavef = (norm_mat*vec4(wavef, 1.0)).xyz;
gl_FragData[0] = vec4(color.rgb, 0.75);
gl_FragData[1] = vec4(1,1,1, 0.8);
gl_FragData[2] = vec4(wavef*0.5+0.5, 0.0);
}

132
indra/newview/app_settings/shaders/class2/deferred/alphaF.glsl Normal file
View File

@ -0,0 +1,132 @@
/**
* @file alphaF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
#extension GL_ARB_texture_rectangle : enable
uniform sampler2D diffuseMap;
uniform sampler2DRectShadow shadowMap0;
uniform sampler2DRectShadow shadowMap1;
uniform sampler2DRectShadow shadowMap2;
uniform sampler2DRectShadow shadowMap3;
uniform sampler2D noiseMap;
uniform sampler2DRect depthMap;
uniform mat4 shadow_matrix[6];
uniform vec4 shadow_clip;
uniform vec2 screen_res;
uniform vec2 shadow_res;
vec3 atmosLighting(vec3 light);
vec3 scaleSoftClip(vec3 light);
varying vec3 vary_ambient;
varying vec3 vary_directional;
varying vec3 vary_fragcoord;
varying vec3 vary_position;
varying vec3 vary_light;
uniform float alpha_soften;
uniform float shadow_bias;
uniform mat4 inv_proj;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos.xyz /= pos.w;
pos.w = 1.0;
return pos;
}
float pcfShadow(sampler2DRectShadow shadowMap, vec4 stc, float scl)
{
stc.xyz /= stc.w;
stc.z += shadow_bias;
float cs = shadow2DRect(shadowMap, stc.xyz).x;
float shadow = cs;
shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(scl, scl, 0.0)).x, cs);
shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(scl, -scl, 0.0)).x, cs);
shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(-scl, scl, 0.0)).x, cs);
shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(-scl, -scl, 0.0)).x, cs);
return shadow/5.0;
}
void main()
{
vec2 frag = vary_fragcoord.xy/vary_fragcoord.z*0.5+0.5;
frag *= screen_res;
vec3 samp_pos = getPosition(frag).xyz;
float shadow = 1.0;
vec4 pos = vec4(vary_position, 1.0);
vec4 spos = pos;
if (spos.z > -shadow_clip.w)
{
vec4 lpos;
if (spos.z < -shadow_clip.z)
{
lpos = shadow_matrix[3]*spos;
lpos.xy *= shadow_res;
shadow = pcfShadow(shadowMap3, lpos, 1.5);
shadow += max((pos.z+shadow_clip.z)/(shadow_clip.z-shadow_clip.w)*2.0-1.0, 0.0);
}
else if (spos.z < -shadow_clip.y)
{
lpos = shadow_matrix[2]*spos;
lpos.xy *= shadow_res;
shadow = pcfShadow(shadowMap2, lpos, 1.5);
}
else if (spos.z < -shadow_clip.x)
{
lpos = shadow_matrix[1]*spos;
lpos.xy *= shadow_res;
shadow = pcfShadow(shadowMap1, lpos, 1.5);
}
else
{
lpos = shadow_matrix[0]*spos;
lpos.xy *= shadow_res;
shadow = pcfShadow(shadowMap0, lpos, 1.5);
}
}
vec4 col = vec4(vary_ambient + vary_directional.rgb*shadow, gl_Color.a);
vec4 color = texture2D(diffuseMap, gl_TexCoord[0].xy) * col;
color.rgb = atmosLighting(color.rgb);
color.rgb = scaleSoftClip(color.rgb);
if (samp_pos.z != 0.0 && gl_Color.a < 1.0)
{
float dist_factor = alpha_soften;
float a = gl_Color.a;
a *= a;
dist_factor *= 1.0/(1.0-a);
color.a *= min((pos.z-samp_pos.z)*dist_factor, 1.0);
}
//gl_FragColor = gl_Color;
gl_FragColor = color;
//gl_FragColor = vec4(1,0,1,1)*shadow;
}

76
indra/newview/app_settings/shaders/class2/deferred/alphaV.glsl Normal file
View File

@ -0,0 +1,76 @@
/**
* @file alphaV.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
vec4 calcLighting(vec3 pos, vec3 norm, vec4 color, vec4 baseCol);
void calcAtmospherics(vec3 inPositionEye);
float calcDirectionalLight(vec3 n, vec3 l);
float calcPointLight(vec3 v, vec3 n, vec4 lp, float la);
vec3 atmosAmbient(vec3 light);
vec3 atmosAffectDirectionalLight(float lightIntensity);
vec3 scaleDownLight(vec3 light);
vec3 scaleUpLight(vec3 light);
varying vec3 vary_ambient;
varying vec3 vary_directional;
varying vec3 vary_fragcoord;
varying vec3 vary_position;
varying vec3 vary_light;
uniform float near_clip;
uniform float shadow_offset;
uniform float shadow_bias;
void main()
{
//transform vertex
gl_Position = ftransform();
gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;
vec4 pos = (gl_ModelViewMatrix * gl_Vertex);
vec3 norm = normalize(gl_NormalMatrix * gl_Normal);
float dp_directional_light = max(0.0, dot(norm, gl_LightSource[0].position.xyz));
vary_position = pos.xyz + gl_LightSource[0].position.xyz * (1.0-dp_directional_light)*shadow_offset;
calcAtmospherics(pos.xyz);
//vec4 color = calcLighting(pos.xyz, norm, gl_Color, vec4(0.));
vec4 col;
col.a = gl_Color.a;
// Add windlight lights
col.rgb = atmosAmbient(vec3(0.));
col.rgb = scaleUpLight(col.rgb);
// Collect normal lights (need to be divided by two, as we later multiply by 2)
col.rgb += gl_LightSource[2].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[2].position, gl_LightSource[2].linearAttenuation);
col.rgb += gl_LightSource[3].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[3].position, gl_LightSource[3].linearAttenuation);
col.rgb += gl_LightSource[4].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[4].position, gl_LightSource[4].linearAttenuation);
col.rgb += gl_LightSource[5].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[5].position, gl_LightSource[5].linearAttenuation);
col.rgb += gl_LightSource[6].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[6].position, gl_LightSource[6].linearAttenuation);
col.rgb += gl_LightSource[7].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[7].position, gl_LightSource[7].linearAttenuation);
col.rgb += gl_LightSource[1].diffuse.rgb*calcDirectionalLight(norm, gl_LightSource[1].position.xyz);
col.rgb = scaleDownLight(col.rgb);
vary_light = gl_LightSource[0].position.xyz;
vary_ambient = col.rgb*gl_Color.rgb;
vary_directional.rgb = gl_Color.rgb*atmosAffectDirectionalLight(max(calcDirectionalLight(norm, gl_LightSource[0].position.xyz), (1.0-gl_Color.a)*(1.0-gl_Color.a)));
col.rgb = min(col.rgb*gl_Color.rgb, 1.0);
gl_FrontColor = col;
gl_FogFragCoord = pos.z;
pos = gl_ModelViewProjectionMatrix * gl_Vertex;
vary_fragcoord.xyz = pos.xyz + vec3(0,0,near_clip);
}

98
indra/newview/app_settings/shaders/class2/deferred/avatarAlphaF.glsl Normal file
View File

@ -0,0 +1,98 @@
/**
* @file avatarAlphaF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
#extension GL_ARB_texture_rectangle : enable
uniform sampler2D diffuseMap;
uniform sampler2DRectShadow shadowMap0;
uniform sampler2DRectShadow shadowMap1;
uniform sampler2DRectShadow shadowMap2;
uniform sampler2DRectShadow shadowMap3;
uniform sampler2D noiseMap;
uniform mat4 shadow_matrix[6];
uniform vec4 shadow_clip;
uniform vec2 screen_res;
uniform vec2 shadow_res;
vec3 atmosLighting(vec3 light);
vec3 scaleSoftClip(vec3 light);
varying vec3 vary_ambient;
varying vec3 vary_directional;
varying vec3 vary_position;
varying vec3 vary_normal;
uniform float shadow_bias;
float pcfShadow(sampler2DRectShadow shadowMap, vec4 stc, float scl)
{
stc.xyz /= stc.w;
stc.z += shadow_bias;
float cs = shadow2DRect(shadowMap, stc.xyz).x;
float shadow = cs;
shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(scl, scl, 0.0)).x, cs);
shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(scl, -scl, 0.0)).x, cs);
shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(-scl, scl, 0.0)).x, cs);
shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(-scl, -scl, 0.0)).x, cs);
return shadow/5.0;
}
void main()
{
float shadow = 1.0;
vec4 pos = vec4(vary_position, 1.0);
vec3 norm = normalize(vary_normal);
//vec3 nz = texture2D(noiseMap, gl_FragCoord.xy/128.0).xyz;
vec4 spos = pos;
if (spos.z > -shadow_clip.w)
{
vec4 lpos;
if (spos.z < -shadow_clip.z)
{
lpos = shadow_matrix[3]*spos;
lpos.xy *= shadow_res;
shadow = pcfShadow(shadowMap3, lpos, 1.5);
shadow += max((pos.z+shadow_clip.z)/(shadow_clip.z-shadow_clip.w)*2.0-1.0, 0.0);
}
else if (spos.z < -shadow_clip.y)
{
lpos = shadow_matrix[2]*spos;
lpos.xy *= shadow_res;
shadow = pcfShadow(shadowMap2, lpos, 1.5);
}
else if (spos.z < -shadow_clip.x)
{
lpos = shadow_matrix[1]*spos;
lpos.xy *= shadow_res;
shadow = pcfShadow(shadowMap1, lpos, 1.5);
}
else
{
lpos = shadow_matrix[0]*spos;
lpos.xy *= shadow_res;
shadow = pcfShadow(shadowMap0, lpos, 1.5);
}
}
vec4 col = vec4(vary_ambient + vary_directional*shadow, gl_Color.a);
vec4 color = texture2D(diffuseMap, gl_TexCoord[0].xy) * col;
color.rgb = atmosLighting(color.rgb);
color.rgb = scaleSoftClip(color.rgb);
gl_FragColor = color;
}

84
indra/newview/app_settings/shaders/class2/deferred/avatarAlphaV.glsl Normal file
View File

@ -0,0 +1,84 @@
/**
* @file avatarAlphaV.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
vec4 calcLighting(vec3 pos, vec3 norm, vec4 color, vec4 baseCol);
mat4 getSkinnedTransform();
void calcAtmospherics(vec3 inPositionEye);
float calcDirectionalLight(vec3 n, vec3 l);
float calcPointLight(vec3 v, vec3 n, vec4 lp, float la);
vec3 atmosAmbient(vec3 light);
vec3 atmosAffectDirectionalLight(float lightIntensity);
vec3 scaleDownLight(vec3 light);
vec3 scaleUpLight(vec3 light);
varying vec3 vary_position;
varying vec3 vary_ambient;
varying vec3 vary_directional;
varying vec3 vary_normal;
uniform float near_clip;
uniform float shadow_offset;
uniform float shadow_bias;
void main()
{
gl_TexCoord[0] = gl_MultiTexCoord0;
vec4 pos;
vec3 norm;
mat4 trans = getSkinnedTransform();
pos.x = dot(trans[0], gl_Vertex);
pos.y = dot(trans[1], gl_Vertex);
pos.z = dot(trans[2], gl_Vertex);
pos.w = 1.0;
norm.x = dot(trans[0].xyz, gl_Normal);
norm.y = dot(trans[1].xyz, gl_Normal);
norm.z = dot(trans[2].xyz, gl_Normal);
norm = normalize(norm);
gl_Position = gl_ProjectionMatrix * pos;
float dp_directional_light = max(0.0, dot(norm, gl_LightSource[0].position.xyz));
vary_position = pos.xyz + gl_LightSource[0].position.xyz * (1.0-dp_directional_light)*shadow_offset;
vary_normal = norm;
calcAtmospherics(pos.xyz);
//vec4 color = calcLighting(pos.xyz, norm, gl_Color, vec4(0.));
vec4 col;
col.a = gl_Color.a;
// Add windlight lights
col.rgb = atmosAmbient(vec3(0.));
col.rgb = scaleUpLight(col.rgb);
// Collect normal lights (need to be divided by two, as we later multiply by 2)
col.rgb += gl_LightSource[2].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[2].position, gl_LightSource[2].linearAttenuation);
col.rgb += gl_LightSource[3].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[3].position, gl_LightSource[3].linearAttenuation);
col.rgb += gl_LightSource[4].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[4].position, gl_LightSource[4].linearAttenuation);
col.rgb += gl_LightSource[5].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[5].position, gl_LightSource[5].linearAttenuation);
col.rgb += gl_LightSource[6].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[6].position, gl_LightSource[6].linearAttenuation);
col.rgb += gl_LightSource[7].diffuse.rgb*calcPointLight(pos.xyz, norm, gl_LightSource[7].position, gl_LightSource[7].linearAttenuation);
col.rgb += gl_LightSource[1].diffuse.rgb*calcDirectionalLight(norm, gl_LightSource[1].position.xyz);
col.rgb = scaleDownLight(col.rgb);
vary_ambient = col.rgb*gl_Color.rgb;
vary_directional = gl_Color.rgb*atmosAffectDirectionalLight(max(calcDirectionalLight(norm, gl_LightSource[0].position.xyz), (1.0-gl_Color.a)*(1.0-gl_Color.a)));
col.rgb = min(col.rgb*gl_Color.rgb, 1.0);
gl_FrontColor = col;
gl_FogFragCoord = pos.z;
}

96
indra/newview/app_settings/shaders/class2/deferred/blurLightF.glsl Normal file
View File

@ -0,0 +1,96 @@
/**
* @file blurLightF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect depthMap;
uniform sampler2DRect normalMap;
uniform sampler2DRect lightMap;
uniform sampler2DRect edgeMap;
uniform float dist_factor;
uniform float blur_size;
uniform vec2 delta;
uniform vec3 kern[4];
uniform float kern_scale;
varying vec2 vary_fragcoord;
uniform mat4 inv_proj;
uniform vec2 screen_res;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
void main()
{
vec3 norm = texture2DRect(normalMap, vary_fragcoord.xy).xyz*2.0-1.0;
vec3 pos = getPosition(vary_fragcoord.xy).xyz;
vec4 ccol = texture2DRect(lightMap, vary_fragcoord.xy).rgba;
vec2 dlt = kern_scale * delta / (1.0+norm.xy*norm.xy);
dlt /= max(-pos.z*dist_factor, 1.0);
vec2 defined_weight = kern[0].xy; // special case the first (centre) sample's weight in the blur; we have to sample it anyway so we get it for 'free'
vec4 col = defined_weight.xyxx * ccol;
float e = 1.0;
for (int i = 0; i < 4; i++)
{
vec2 tc = vary_fragcoord.xy + kern[i].z*dlt;
e = max(e, 0.0);
vec2 wght = kern[i].xy*e;
col += texture2DRect(lightMap, tc)*wght.xyxx;
defined_weight += wght;
e *= e;
e -= texture2DRect(edgeMap, tc.xy).a+
texture2DRect(edgeMap, tc.xy+dlt*0.333).a+
texture2DRect(edgeMap, tc.xy-dlt*0.333).a;
}
e = 1.0;
for (int i = 0; i < 4; i++)
{
vec2 tc = vary_fragcoord.xy - kern[i].z*dlt;
e = max(e, 0.0);
vec2 wght = kern[i].xy*e;
col += texture2DRect(lightMap, tc)*wght.xyxx;
defined_weight += wght;
e *= e;
e -= texture2DRect(edgeMap, tc.xy).a+
texture2DRect(edgeMap, tc.xy+dlt*0.333).a+
texture2DRect(edgeMap, tc.xy-dlt*0.333).a;
}
col /= defined_weight.xyxx;
gl_FragColor = col;
//gl_FragColor = ccol;
}

17
indra/newview/app_settings/shaders/class2/deferred/blurLightV.glsl Normal file
View File

@ -0,0 +1,17 @@
/**
* @file blurLightF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
varying vec2 vary_fragcoord;
uniform vec2 screen_res;
void main()
{
//transform vertex
gl_Position = ftransform();
vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
}

58
indra/newview/app_settings/shaders/class2/deferred/edgeF.glsl Normal file
View File

@ -0,0 +1,58 @@
/**
* @file edgeF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect depthMap;
uniform sampler2DRect normalMap;
uniform float gi_dist_cutoff;
varying vec2 vary_fragcoord;
uniform float depth_cutoff;
uniform float norm_cutoff;
uniform mat4 inv_proj;
uniform vec2 screen_res;
float getDepth(vec2 pos_screen)
{
float z = texture2DRect(depthMap, pos_screen.xy).a;
z = z*2.0-1.0;
vec4 ndc = vec4(0.0, 0.0, z, 1.0);
vec4 p = inv_proj*ndc;
return p.z/p.w;
}
void main()
{
vec3 norm = texture2DRect(normalMap, vary_fragcoord.xy).xyz*2.0-1.0;
float depth = getDepth(vary_fragcoord.xy);
vec2 tc = vary_fragcoord.xy;
float sc = 0.75;
vec2 de;
de.x = (depth-getDepth(tc+vec2(sc, sc))) + (depth-getDepth(tc+vec2(-sc, -sc)));
de.y = (depth-getDepth(tc+vec2(-sc, sc))) + (depth-getDepth(tc+vec2(sc, -sc)));
de /= depth;
de *= de;
de = step(depth_cutoff, de);
vec2 ne;
ne.x = dot(texture2DRect(normalMap, tc+vec2(-sc,-sc)).rgb*2.0-1.0, norm);
ne.y = dot(texture2DRect(normalMap, tc+vec2(sc,sc)).rgb*2.0-1.0, norm);
ne = 1.0-ne;
ne = step(norm_cutoff, ne);
gl_FragColor.a = dot(de,de)+dot(ne,ne);
//gl_FragColor.a = dot(de,de);
}

17
indra/newview/app_settings/shaders/class2/deferred/edgeV.glsl Normal file
View File

@ -0,0 +1,17 @@
/**
* @file edgeV.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
varying vec2 vary_fragcoord;
uniform vec2 screen_res;
void main()
{
//transform vertex
gl_Position = ftransform();
vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
}

188
indra/newview/app_settings/shaders/class2/deferred/multiSpotLightF.glsl Normal file
View File

@ -0,0 +1,188 @@
/**
* @file multiSpotLightF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
#version 120
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect diffuseRect;
uniform sampler2DRect specularRect;
uniform sampler2DRect depthMap;
uniform sampler2DRect normalMap;
uniform samplerCube environmentMap;
uniform sampler2DRect lightMap;
uniform sampler2D noiseMap;
uniform sampler2D lightFunc;
uniform sampler2D projectionMap;
uniform mat4 proj_mat; //screen space to light space
uniform float proj_near; //near clip for projection
uniform vec3 proj_p; //plane projection is emitting from (in screen space)
uniform vec3 proj_n;
uniform float proj_focus; //distance from plane to begin blurring
uniform float proj_lod; //(number of mips in proj map)
uniform float proj_range; //range between near clip and far clip plane of projection
uniform float proj_ambient_lod;
uniform float proj_ambiance;
uniform float near_clip;
uniform float far_clip;
uniform vec3 proj_origin; //origin of projection to be used for angular attenuation
uniform float sun_wash;
uniform int proj_shadow_idx;
uniform float shadow_fade;
varying vec4 vary_light;
varying vec4 vary_fragcoord;
uniform vec2 screen_res;
uniform mat4 inv_proj;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
void main()
{
vec4 frag = vary_fragcoord;
frag.xyz /= frag.w;
frag.xyz = frag.xyz*0.5+0.5;
frag.xy *= screen_res;
vec3 pos = getPosition(frag.xy).xyz;
vec3 lv = vary_light.xyz-pos.xyz;
float dist2 = dot(lv,lv);
dist2 /= vary_light.w;
if (dist2 > 1.0)
{
discard;
}
float shadow = 1.0;
if (proj_shadow_idx >= 0)
{
vec4 shd = texture2DRect(lightMap, frag.xy);
float sh[2];
sh[0] = shd.b;
sh[1] = shd.a;
shadow = min(sh[proj_shadow_idx]+shadow_fade, 1.0);
}
vec3 norm = texture2DRect(normalMap, frag.xy).xyz*2.0-1.0;
norm = normalize(norm);
float l_dist = -dot(lv, proj_n);
vec4 proj_tc = (proj_mat * vec4(pos.xyz, 1.0));
if (proj_tc.z < 0.0)
{
discard;
}
proj_tc.xyz /= proj_tc.w;
float fa = gl_Color.a+1.0;
float dist_atten = min(1.0-(dist2-1.0*(1.0-fa))/fa, 1.0);
if (dist_atten <= 0.0)
{
discard;
}
lv = proj_origin-pos.xyz;
lv = normalize(lv);
float da = dot(norm, lv);
vec3 col = vec3(0,0,0);
vec3 diff_tex = texture2DRect(diffuseRect, frag.xy).rgb;
float noise = texture2D(noiseMap, frag.xy/128.0).b;
if (proj_tc.z > 0.0 &&
proj_tc.x < 1.0 &&
proj_tc.y < 1.0 &&
proj_tc.x > 0.0 &&
proj_tc.y > 0.0)
{
float lit = 0.0;
float amb_da = proj_ambiance;
if (da > 0.0)
{
float diff = clamp((l_dist-proj_focus)/proj_range, 0.0, 1.0);
float lod = diff * proj_lod;
vec4 plcol = texture2DLod(projectionMap, proj_tc.xy, lod);
vec3 lcol = gl_Color.rgb * plcol.rgb * plcol.a;
lit = da * dist_atten * noise;
col = lcol*lit*diff_tex*shadow;
amb_da += (da*0.5)*(1.0-shadow)*proj_ambiance;
}
//float diff = clamp((proj_range-proj_focus)/proj_range, 0.0, 1.0);
vec4 amb_plcol = texture2DLod(projectionMap, proj_tc.xy, proj_ambient_lod);
amb_da += (da*da*0.5+0.5)*proj_ambiance;
amb_da *= dist_atten * noise;
amb_da = min(amb_da, 1.0-lit);
col += amb_da*gl_Color.rgb*diff_tex.rgb*amb_plcol.rgb*amb_plcol.a;
}
vec4 spec = texture2DRect(specularRect, frag.xy);
if (spec.a > 0.0)
{
vec3 ref = reflect(normalize(pos), norm);
//project from point pos in direction ref to plane proj_p, proj_n
vec3 pdelta = proj_p-pos;
float ds = dot(ref, proj_n);
if (ds < 0.0)
{
vec3 pfinal = pos + ref * dot(pdelta, proj_n)/ds;
vec4 stc = (proj_mat * vec4(pfinal.xyz, 1.0));
if (stc.z > 0.0)
{
stc.xy /= stc.w;
if (stc.x < 1.0 &&
stc.y < 1.0 &&
stc.x > 0.0 &&
stc.y > 0.0)
{
vec4 scol = texture2DLod(projectionMap, stc.xy, proj_lod-spec.a*proj_lod);
col += dist_atten*scol.rgb*gl_Color.rgb*scol.a*spec.rgb*shadow;
}
}
}
}
//attenuate point light contribution by SSAO component
col *= texture2DRect(lightMap, frag.xy).g;
gl_FragColor.rgb = col;
gl_FragColor.a = 0.0;
}

59
indra/newview/app_settings/shaders/class2/deferred/postDeferredF.glsl Normal file
View File

@ -0,0 +1,59 @@
/**
* @file postDeferredF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
uniform sampler2DRect diffuseRect;
uniform sampler2DRect localLightMap;
uniform sampler2DRect sunLightMap;
uniform sampler2DRect giLightMap;
uniform sampler2D luminanceMap;
uniform sampler2DRect lightMap;
uniform vec3 gi_lum_quad;
uniform vec3 sun_lum_quad;
uniform vec3 lum_quad;
uniform float lum_lod;
uniform vec4 ambient;
uniform vec3 gi_quad;
uniform vec2 screen_res;
varying vec2 vary_fragcoord;
void main()
{
vec2 tc = vary_fragcoord.xy;
vec3 lcol = texture2DLod(luminanceMap, tc/screen_res, lum_lod).rgb;
float lum = sqrt(lcol.r)*lum_quad.x+lcol.r*lcol.r*lum_quad.y+lcol.r*lum_quad.z;
vec4 diff = texture2DRect(diffuseRect, vary_fragcoord.xy);
float ambocc = texture2DRect(lightMap, vary_fragcoord.xy).g;
vec3 gi_col = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
gi_col = gi_col*gi_col*gi_quad.x + gi_col*gi_quad.y+gi_quad.z*ambocc*ambient.rgb;
gi_col *= diff;
vec4 sun_col = texture2DRect(sunLightMap, vary_fragcoord.xy);
vec3 local_col = texture2DRect(localLightMap, vary_fragcoord.xy).rgb;
float sun_lum = 1.0-lum;
sun_lum = sun_lum*sun_lum*sun_lum_quad.x + sun_lum*sun_lum_quad.y+sun_lum_quad.z;
float gi_lum = lum;
gi_lum = gi_lum*gi_lum*gi_lum_quad.x+gi_lum*gi_lum_quad.y+gi_lum_quad.z;
gi_col *= 1.0/gi_lum;
vec3 col = sun_col.rgb*(1.0+max(sun_lum,0.0))+gi_col+local_col;
gl_FragColor.rgb = col.rgb;
gl_FragColor.a = max(sun_lum*min(sun_col.r+sun_col.g+sun_col.b, 1.0), sun_col.a);
//gl_FragColor.rgb = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
}

17
indra/newview/app_settings/shaders/class2/deferred/postDeferredV.glsl Normal file
View File

@ -0,0 +1,17 @@
/**
* @file postDeferredV.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
varying vec2 vary_fragcoord;
uniform vec2 screen_res;
void main()
{
//transform vertex
gl_Position = ftransform();
vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
}

294
indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl Normal file
View File

@ -0,0 +1,294 @@
/**
* @file softenLightF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect diffuseRect;
uniform sampler2DRect specularRect;
uniform sampler2DRect normalMap;
uniform sampler2DRect lightMap;
uniform sampler2D noiseMap;
uniform samplerCube environmentMap;
uniform sampler2D lightFunc;
uniform vec3 gi_quad;
uniform float blur_size;
uniform float blur_fidelity;
// Inputs
uniform vec4 morphFactor;
uniform vec3 camPosLocal;
//uniform vec4 camPosWorld;
uniform vec4 gamma;
uniform vec4 lightnorm;
uniform vec4 sunlight_color;
uniform vec4 ambient;
uniform vec4 blue_horizon;
uniform vec4 blue_density;
uniform vec4 haze_horizon;
uniform vec4 haze_density;
uniform vec4 cloud_shadow;
uniform vec4 density_multiplier;
uniform vec4 distance_multiplier;
uniform vec4 max_y;
uniform vec4 glow;
uniform float scene_light_strength;
uniform vec3 env_mat[3];
uniform vec4 shadow_clip;
uniform mat3 ssao_effect_mat;
uniform sampler2DRect depthMap;
uniform mat4 inv_proj;
uniform vec2 screen_res;
varying vec4 vary_light;
varying vec2 vary_fragcoord;
vec3 vary_PositionEye;
vec3 vary_SunlitColor;
vec3 vary_AmblitColor;
vec3 vary_AdditiveColor;
vec3 vary_AtmosAttenuation;
vec4 getPosition(vec2 pos_screen)
{ //get position in screen space (world units) given window coordinate and depth map
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
vec3 getPositionEye()
{
return vary_PositionEye;
}
vec3 getSunlitColor()
{
return vary_SunlitColor;
}
vec3 getAmblitColor()
{
return vary_AmblitColor;
}
vec3 getAdditiveColor()
{
return vary_AdditiveColor;
}
vec3 getAtmosAttenuation()
{
return vary_AtmosAttenuation;
}
void setPositionEye(vec3 v)
{
vary_PositionEye = v;
}
void setSunlitColor(vec3 v)
{
vary_SunlitColor = v;
}
void setAmblitColor(vec3 v)
{
vary_AmblitColor = v;
}
void setAdditiveColor(vec3 v)
{
vary_AdditiveColor = v;
}
void setAtmosAttenuation(vec3 v)
{
vary_AtmosAttenuation = v;
}
void calcAtmospherics(vec3 inPositionEye, float ambFactor) {
vec3 P = inPositionEye;
setPositionEye(P);
//(TERRAIN) limit altitude
if (P.y > max_y.x) P *= (max_y.x / P.y);
if (P.y < -max_y.x) P *= (-max_y.x / P.y);
vec3 tmpLightnorm = lightnorm.xyz;
vec3 Pn = normalize(P);
float Plen = length(P);
vec4 temp1 = vec4(0);
vec3 temp2 = vec3(0);
vec4 blue_weight;
vec4 haze_weight;
vec4 sunlight = sunlight_color;
vec4 light_atten;
//sunlight attenuation effect (hue and brightness) due to atmosphere
//this is used later for sunlight modulation at various altitudes
light_atten = (blue_density * 1.0 + vec4(haze_density.r) * 0.25) * (density_multiplier.x * max_y.x);
//I had thought blue_density and haze_density should have equal weighting,
//but attenuation due to haze_density tends to seem too strong
temp1 = blue_density + vec4(haze_density.r);
blue_weight = blue_density / temp1;
haze_weight = vec4(haze_density.r) / temp1;
//(TERRAIN) compute sunlight from lightnorm only (for short rays like terrain)
temp2.y = max(0.0, tmpLightnorm.y);
temp2.y = 1. / temp2.y;
sunlight *= exp( - light_atten * temp2.y);
// main atmospheric scattering line integral
temp2.z = Plen * density_multiplier.x;
// Transparency (-> temp1)
// ATI Bugfix -- can't store temp1*temp2.z*distance_multiplier.x in a variable because the ati
// compiler gets confused.
temp1 = exp(-temp1 * temp2.z * distance_multiplier.x);
//final atmosphere attenuation factor
setAtmosAttenuation(temp1.rgb);
//compute haze glow
//(can use temp2.x as temp because we haven't used it yet)
temp2.x = dot(Pn, tmpLightnorm.xyz);
temp2.x = 1. - temp2.x;
//temp2.x is 0 at the sun and increases away from sun
temp2.x = max(temp2.x, .03); //was glow.y
//set a minimum "angle" (smaller glow.y allows tighter, brighter hotspot)
temp2.x *= glow.x;
//higher glow.x gives dimmer glow (because next step is 1 / "angle")
temp2.x = pow(temp2.x, glow.z);
//glow.z should be negative, so we're doing a sort of (1 / "angle") function
//add "minimum anti-solar illumination"
temp2.x += .25;
//increase ambient when there are more clouds
vec4 tmpAmbient = ambient + (vec4(1.) - ambient) * cloud_shadow.x * 0.5;
/* decrease value and saturation (that in HSV, not HSL) for occluded areas
* // for HSV color/geometry used here, see http://gimp-savvy.com/BOOK/index.html?node52.html
* // The following line of code performs the equivalent of:
* float ambAlpha = tmpAmbient.a;
* float ambValue = dot(vec3(tmpAmbient), vec3(0.577)); // projection onto <1/rt(3), 1/rt(3), 1/rt(3)>, the neutral white-black axis
* vec3 ambHueSat = vec3(tmpAmbient) - vec3(ambValue);
* tmpAmbient = vec4(RenderSSAOEffect.valueFactor * vec3(ambValue) + RenderSSAOEffect.saturationFactor *(1.0 - ambFactor) * ambHueSat, ambAlpha);
*/
tmpAmbient = vec4(mix(ssao_effect_mat * tmpAmbient.rgb, tmpAmbient.rgb, ambFactor), tmpAmbient.a);
//haze color
setAdditiveColor(
vec3(blue_horizon * blue_weight * (sunlight*(1.-cloud_shadow.x) + tmpAmbient)
+ (haze_horizon.r * haze_weight) * (sunlight*(1.-cloud_shadow.x) * temp2.x
+ tmpAmbient)));
//brightness of surface both sunlight and ambient
setSunlitColor(vec3(sunlight * .5));
setAmblitColor(vec3(tmpAmbient * .25));
setAdditiveColor(getAdditiveColor() * vec3(1.0 - temp1));
}
vec3 atmosLighting(vec3 light)
{
light *= getAtmosAttenuation().r;
light += getAdditiveColor();
return (2.0 * light);
}
vec3 atmosTransport(vec3 light) {
light *= getAtmosAttenuation().r;
light += getAdditiveColor() * 2.0;
return light;
}
vec3 atmosGetDiffuseSunlightColor()
{
return getSunlitColor();
}
vec3 scaleDownLight(vec3 light)
{
return (light / scene_light_strength );
}
vec3 scaleUpLight(vec3 light)
{
return (light * scene_light_strength);
}
vec3 atmosAmbient(vec3 light)
{
return getAmblitColor() + light / 2.0;
}
vec3 atmosAffectDirectionalLight(float lightIntensity)
{
return getSunlitColor() * lightIntensity;
}
vec3 scaleSoftClip(vec3 light)
{
//soft clip effect:
light = 1. - clamp(light, vec3(0.), vec3(1.));
light = 1. - pow(light, gamma.xxx);
return light;
}
void main()
{
vec2 tc = vary_fragcoord.xy;
vec3 pos = getPosition(tc).xyz;
vec3 norm = texture2DRect(normalMap, tc).xyz*2.0-1.0;
//vec3 nz = texture2D(noiseMap, vary_fragcoord.xy/128.0).xyz;
float da = max(dot(norm.xyz, vary_light.xyz), 0.0);
vec4 diffuse = texture2DRect(diffuseRect, tc);
vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
vec2 scol_ambocc = texture2DRect(lightMap, vary_fragcoord.xy).rg;
float scol = max(scol_ambocc.r, diffuse.a);
float ambocc = scol_ambocc.g;
calcAtmospherics(pos.xyz, ambocc);
vec3 col = atmosAmbient(vec3(0));
col += atmosAffectDirectionalLight(max(min(da, scol), diffuse.a));
col *= diffuse.rgb;
if (spec.a > 0.0)
{
vec3 ref = normalize(reflect(pos.xyz, norm.xyz));
float sa = dot(ref, vary_light.xyz);
col.rgb += vary_SunlitColor*scol*spec.rgb*texture2D(lightFunc, vec2(sa, spec.a)).a;
}
col = atmosLighting(col);
col = scaleSoftClip(col);
gl_FragColor.rgb = col;
//gl_FragColor.rgb = gi_col.rgb;
gl_FragColor.a = 0.0;
//gl_FragColor.rg = scol_ambocc.rg;
//gl_FragColor.rgb = texture2DRect(lightMap, vary_fragcoord.xy).rgb;
//gl_FragColor.rgb = norm.rgb*0.5+0.5;
//gl_FragColor.rgb = vec3(ambocc);
//gl_FragColor.rgb = vec3(scol);
}

24
indra/newview/app_settings/shaders/class2/deferred/softenLightV.glsl Normal file
View File

@ -0,0 +1,24 @@
/**
* @file softenLightF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
uniform vec2 screen_res;
varying vec4 vary_light;
varying vec2 vary_fragcoord;
void main()
{
//transform vertex
gl_Position = ftransform();
vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
vec4 tex = gl_MultiTexCoord0;
tex.w = 1.0;
vary_light = gl_MultiTexCoord0;
}

199
indra/newview/app_settings/shaders/class2/deferred/spotLightF.glsl Normal file
View File

@ -0,0 +1,199 @@
/**
* @file spotLightF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
#version 120
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect diffuseRect;
uniform sampler2DRect specularRect;
uniform sampler2DRect depthMap;
uniform sampler2DRect normalMap;
uniform samplerCube environmentMap;
uniform sampler2DRect lightMap;
uniform sampler2D noiseMap;
uniform sampler2D lightFunc;
uniform sampler2D projectionMap;
uniform mat4 proj_mat; //screen space to light space
uniform float proj_near; //near clip for projection
uniform vec3 proj_p; //plane projection is emitting from (in screen space)
uniform vec3 proj_n;
uniform float proj_focus; //distance from plane to begin blurring
uniform float proj_lod; //(number of mips in proj map)
uniform float proj_range; //range between near clip and far clip plane of projection
uniform float proj_ambiance;
uniform float near_clip;
uniform float far_clip;
uniform vec3 proj_origin; //origin of projection to be used for angular attenuation
uniform float sun_wash;
uniform int proj_shadow_idx;
uniform float shadow_fade;
varying vec4 vary_light;
varying vec4 vary_fragcoord;
uniform vec2 screen_res;
uniform mat4 inv_proj;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
void main()
{
vec4 frag = vary_fragcoord;
frag.xyz /= frag.w;
frag.xyz = frag.xyz*0.5+0.5;
frag.xy *= screen_res;
float shadow = 1.0;
if (proj_shadow_idx >= 0)
{
vec4 shd = texture2DRect(lightMap, frag.xy);
float sh[2];
sh[0] = shd.b;
sh[1] = shd.a;
shadow = min(sh[proj_shadow_idx]+shadow_fade, 1.0);
}
vec3 pos = getPosition(frag.xy).xyz;
vec3 lv = vary_light.xyz-pos.xyz;
float dist2 = dot(lv,lv);
dist2 /= vary_light.w;
if (dist2 > 1.0)
{
discard;
}
vec3 norm = texture2DRect(normalMap, frag.xy).xyz*2.0-1.0;
norm = normalize(norm);
float l_dist = -dot(lv, proj_n);
vec4 proj_tc = (proj_mat * vec4(pos.xyz, 1.0));
if (proj_tc.z < 0.0)
{
discard;
}
proj_tc.xyz /= proj_tc.w;
float fa = gl_Color.a+1.0;
float dist_atten = clamp(1.0-(dist2-1.0*(1.0-fa))/fa, 0.0, 1.0);
lv = proj_origin-pos.xyz;
lv = normalize(lv);
float da = dot(norm, lv);
vec3 col = vec3(0,0,0);
vec3 diff_tex = texture2DRect(diffuseRect, frag.xy).rgb;
float noise = texture2D(noiseMap, frag.xy/128.0).b;
if (proj_tc.z > 0.0 &&
proj_tc.x < 1.0 &&
proj_tc.y < 1.0 &&
proj_tc.x > 0.0 &&
proj_tc.y > 0.0)
{
float lit = 0.0;
if (da > 0.0)
{
float diff = clamp((l_dist-proj_focus)/proj_range, 0.0, 1.0);
float lod = diff * proj_lod;
vec4 plcol = texture2DLod(projectionMap, proj_tc.xy, lod);
vec3 lcol = gl_Color.rgb * plcol.rgb * plcol.a;
lit = da * dist_atten * noise;
col = lcol*lit*diff_tex*shadow;
}
float diff = clamp((proj_range-proj_focus)/proj_range, 0.0, 1.0);
float lod = diff * proj_lod;
vec4 amb_plcol = texture2DLod(projectionMap, proj_tc.xy, lod);
//float amb_da = mix(proj_ambiance, proj_ambiance*max(-da, 0.0), max(da, 0.0));
float amb_da = proj_ambiance;
if (da > 0.0)
{
amb_da += (da*0.5)*(1.0-shadow)*proj_ambiance;
}
amb_da += (da*da*0.5+0.5)*proj_ambiance;
amb_da *= dist_atten * noise;
amb_da = min(amb_da, 1.0-lit);
col += amb_da*gl_Color.rgb*diff_tex.rgb*amb_plcol.rgb*amb_plcol.a;
}
vec4 spec = texture2DRect(specularRect, frag.xy);
if (spec.a > 0.0)
{
vec3 ref = reflect(normalize(pos), norm);
//project from point pos in direction ref to plane proj_p, proj_n
vec3 pdelta = proj_p-pos;
float ds = dot(ref, proj_n);
if (ds < 0.0)
{
vec3 pfinal = pos + ref * dot(pdelta, proj_n)/ds;
vec3 stc = (proj_mat * vec4(pfinal.xyz, 1.0)).xyz;
if (stc.z > 0.0)
{
stc.xy /= stc.z+proj_near;
if (stc.x < 1.0 &&
stc.y < 1.0 &&
stc.x > 0.0 &&
stc.y > 0.0)
{
vec4 scol = texture2DLod(projectionMap, stc.xy, proj_lod-spec.a*proj_lod);
col += dist_atten*scol.rgb*gl_Color.rgb*scol.a*spec.rgb*shadow;
}
}
}
}
/*if (spec.a > 0.0)
{
//vec3 ref = reflect(normalize(pos), norm);
float sa = dot(normalize(lv-normalize(pos)),norm);;
//sa = max(sa, 0.0);
//sa = pow(sa, 128.0 * spec.a*spec.a/dist_atten)*min(dist_atten*4.0, 1.0);
sa = texture2D(lightFunc, vec2(sa, spec.a)).a * min(dist_atten*4.0, 1.0);
sa *= noise;
col += da*sa*lcol*spec.rgb;
}*/
//attenuate point light contribution by SSAO component
col *= texture2DRect(lightMap, frag.xy).g;
gl_FragColor.rgb = col;
gl_FragColor.a = 0.0;
}

235
indra/newview/app_settings/shaders/class2/deferred/sunLightF.glsl Normal file
View File

@ -0,0 +1,235 @@
/**
* @file sunLightF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect depthMap;
uniform sampler2DRect normalMap;
uniform sampler2DRectShadow shadowMap0;
uniform sampler2DRectShadow shadowMap1;
uniform sampler2DRectShadow shadowMap2;
uniform sampler2DRectShadow shadowMap3;
uniform sampler2DShadow shadowMap4;
uniform sampler2DShadow shadowMap5;
uniform sampler2D noiseMap;
uniform sampler2D lightFunc;
// Inputs
uniform mat4 shadow_matrix[6];
uniform vec4 shadow_clip;
uniform float ssao_radius;
uniform float ssao_max_radius;
uniform float ssao_factor;
uniform float ssao_factor_inv;
varying vec2 vary_fragcoord;
varying vec4 vary_light;
uniform mat4 inv_proj;
uniform vec2 screen_res;
uniform vec2 shadow_res;
uniform vec2 proj_shadow_res;
uniform float shadow_bias;
uniform float shadow_offset;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
//calculate decreases in ambient lighting when crowded out (SSAO)
float calcAmbientOcclusion(vec4 pos, vec3 norm)
{
vec2 kern[8];
// exponentially (^2) distant occlusion samples spread around origin
kern[0] = vec2(-1.0, 0.0) * 0.125*0.125;
kern[1] = vec2(1.0, 0.0) * 0.250*0.250;
kern[2] = vec2(0.0, 1.0) * 0.375*0.375;
kern[3] = vec2(0.0, -1.0) * 0.500*0.500;
kern[4] = vec2(0.7071, 0.7071) * 0.625*0.625;
kern[5] = vec2(-0.7071, -0.7071) * 0.750*0.750;
kern[6] = vec2(-0.7071, 0.7071) * 0.875*0.875;
kern[7] = vec2(0.7071, -0.7071) * 1.000*1.000;
vec2 pos_screen = vary_fragcoord.xy;
vec3 pos_world = pos.xyz;
vec2 noise_reflect = texture2D(noiseMap, vary_fragcoord.xy/128.0).xy;
float angle_hidden = 0.0;
int points = 0;
float scale = min(ssao_radius / -pos_world.z, ssao_max_radius);
// it was found that keeping # of samples a constant was the fastest, probably due to compiler optimizations (unrolling?)
for (int i = 0; i < 8; i++)
{
vec2 samppos_screen = pos_screen + scale * reflect(kern[i], noise_reflect);
vec3 samppos_world = getPosition(samppos_screen).xyz;
vec3 diff = pos_world - samppos_world;
float dist2 = dot(diff, diff);
// assume each sample corresponds to an occluding sphere with constant radius, constant x-sectional area
// --> solid angle shrinking by the square of distance
//radius is somewhat arbitrary, can approx with just some constant k * 1 / dist^2
//(k should vary inversely with # of samples, but this is taken care of later)
//if (dot((samppos_world - 0.05*norm - pos_world), norm) > 0.0) // -0.05*norm to shift sample point back slightly for flat surfaces
// angle_hidden += min(1.0/dist2, ssao_factor_inv); // dist != 0 follows from conditional. max of 1.0 (= ssao_factor_inv * ssao_factor)
angle_hidden = angle_hidden + float(dot((samppos_world - 0.05*norm - pos_world), norm) > 0.0) * min(1.0/dist2, ssao_factor_inv);
// 'blocked' samples (significantly closer to camera relative to pos_world) are "no data", not "no occlusion"
points = points + int(diff.z > -1.0);
}
angle_hidden = min(ssao_factor*angle_hidden/float(points), 1.0);
return (1.0 - (float(points != 0) * angle_hidden));
}
float pcfShadow(sampler2DRectShadow shadowMap, vec4 stc, float scl)
{
stc.xyz /= stc.w;
stc.z += shadow_bias*scl;
float cs = shadow2DRect(shadowMap, stc.xyz).x;
float shadow = cs;
shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(1.5, 1.5, 0.0)).x, cs);
shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(1.5, -1.5, 0.0)).x, cs);
shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(-1.5, 1.5, 0.0)).x, cs);
shadow += max(shadow2DRect(shadowMap, stc.xyz+vec3(-1.5, -1.5, 0.0)).x, cs);
return shadow/5.0;
//return shadow;
}
float pcfShadow(sampler2DShadow shadowMap, vec4 stc, float scl)
{
stc.xyz /= stc.w;
stc.z += shadow_bias*scl;
float cs = shadow2D(shadowMap, stc.xyz).x;
float shadow = cs;
vec2 off = 1.5/proj_shadow_res;
shadow += max(shadow2D(shadowMap, stc.xyz+vec3(off.x, off.y, 0.0)).x, cs);
shadow += max(shadow2D(shadowMap, stc.xyz+vec3(off.x, -off.y, 0.0)).x, cs);
shadow += max(shadow2D(shadowMap, stc.xyz+vec3(-off.x, off.y, 0.0)).x, cs);
shadow += max(shadow2D(shadowMap, stc.xyz+vec3(-off.x, -off.y, 0.0)).x, cs);
return shadow/5.0;
//return shadow;
}
void main()
{
vec2 pos_screen = vary_fragcoord.xy;
//try doing an unproject here
vec4 pos = getPosition(pos_screen);
vec3 norm = texture2DRect(normalMap, pos_screen).xyz*2.0-1.0;
/*if (pos.z == 0.0) // do nothing for sky *FIX: REMOVE THIS IF/WHEN THE POSITION MAP IS BEING USED AS A STENCIL
{
gl_FragColor = vec4(0.0); // doesn't matter
return;
}*/
float shadow = 1.0;
float dp_directional_light = max(0.0, dot(norm, vary_light.xyz));
vec4 spos = vec4(pos.xyz + vary_light.xyz * (1.0-dp_directional_light)*shadow_offset, 1.0);
if (spos.z > -shadow_clip.w)
{
if (dp_directional_light == 0.0)
{
// if we know this point is facing away from the sun then we know it's in shadow without having to do a squirrelly shadow-map lookup
shadow = 0.0;
}
else
{
vec4 lpos;
if (spos.z < -shadow_clip.z)
{
lpos = shadow_matrix[3]*spos;
lpos.xy *= shadow_res;
shadow = pcfShadow(shadowMap3, lpos, 0.25);
shadow += max((pos.z+shadow_clip.z)/(shadow_clip.z-shadow_clip.w)*2.0-1.0, 0.0);
}
else if (spos.z < -shadow_clip.y)
{
lpos = shadow_matrix[2]*spos;
lpos.xy *= shadow_res;
shadow = pcfShadow(shadowMap2, lpos, 0.5);
}
else if (spos.z < -shadow_clip.x)
{
lpos = shadow_matrix[1]*spos;
lpos.xy *= shadow_res;
shadow = pcfShadow(shadowMap1, lpos, 0.75);
}
else
{
lpos = shadow_matrix[0]*spos;
lpos.xy *= shadow_res;
shadow = pcfShadow(shadowMap0, lpos, 1.0);
}
// take the most-shadowed value out of these two:
// * the blurred sun shadow in the light (shadow) map
// * an unblurred dot product between the sun and this norm
// the goal is to err on the side of most-shadow to fill-in shadow holes and reduce artifacting
shadow = min(shadow, dp_directional_light);
//lpos.xy /= lpos.w*32.0;
//if (fract(lpos.x) < 0.1 || fract(lpos.y) < 0.1)
//{
// shadow = 0.0;
//}
}
}
else
{
// more distant than the shadow map covers
shadow = 1.0;
}
gl_FragColor[0] = shadow;
gl_FragColor[1] = calcAmbientOcclusion(pos, norm);
//spotlight shadow 1
vec4 lpos = shadow_matrix[4]*spos;
gl_FragColor[2] = pcfShadow(shadowMap4, lpos, 0.1).x;
//spotlight shadow 2
lpos = shadow_matrix[5]*spos;
gl_FragColor[3] = pcfShadow(shadowMap5, lpos, 0.1).x;
//gl_FragColor.rgb = pos.xyz;
//gl_FragColor.b = shadow;
}

25
indra/newview/app_settings/shaders/class2/deferred/sunLightV.glsl Normal file
View File

@ -0,0 +1,25 @@
/**
* @file sunLightF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
varying vec4 vary_light;
varying vec2 vary_fragcoord;
uniform vec2 screen_res;
void main()
{
//transform vertex
gl_Position = ftransform();
vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
vary_fragcoord = (pos.xy * 0.5 + 0.5)*screen_res;
vec4 tex = gl_MultiTexCoord0;
tex.w = 1.0;
vary_light = gl_MultiTexCoord0;
gl_FrontColor = gl_Color;
}

84
indra/newview/app_settings/shaders/class3/deferred/giDownsampleF.glsl Normal file
View File

@ -0,0 +1,84 @@
/**
* @file giDownsampleF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
uniform sampler2DRect giLightMap;
uniform vec2 kern[32];
uniform float dist_factor;
uniform float blur_size;
uniform vec2 delta;
uniform int kern_length;
uniform float kern_scale;
uniform vec3 blur_quad;
varying vec2 vary_fragcoord;
uniform mat4 inv_proj;
uniform vec2 screen_res;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
float getDepth(vec2 pos_screen)
{
float z = texture2DRect(depthMap, pos_screen.xy).a;
z = z*2.0-1.0;
vec4 ndc = vec4(0.0, 0.0, z, 1.0);
vec4 p = inv_proj*ndc;
return p.z/p.w;
}
void main()
{
vec3 norm = texture2DRect(normalMap, vary_fragcoord.xy).xyz*2.0-1.0;
float depth = getDepth(vary_fragcoord.xy);
vec3 ccol = texture2DRect(giLightMap, vary_fragcoord.xy).rgb;
vec2 dlt = kern_scale * delta/(vec2(1.0,1.0)+norm.xy*norm.xy);
dlt /= clamp(-depth*blur_quad.x, 1.0, 3.0);
float defined_weight = kern[0].x;
vec3 col = ccol*kern[0].x;
for (int i = 0; i < kern_length; i++)
{
vec2 tc = vary_fragcoord.xy + kern[i].y*dlt;
vec3 sampNorm = texture2DRect(normalMap, tc.xy).xyz*2.0-1.0;
float d = dot(norm.xyz, sampNorm);
if (d > 0.5)
{
float sampdepth = getDepth(tc.xy);
sampdepth -= depth;
if (sampdepth*sampdepth < blur_quad.z)
{
col += texture2DRect(giLightMap, tc).rgb*kern[i].x;
defined_weight += kern[i].x;
}
}
}
col /= defined_weight;
//col = ccol;
col = col*blur_quad.y;
gl_FragData[0].xyz = col;
//gl_FragColor = ccol;
}

17
indra/newview/app_settings/shaders/class3/deferred/giDownsampleV.glsl Normal file
View File

@ -0,0 +1,17 @@
/**
* @file postgiV.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
varying vec2 vary_fragcoord;
uniform vec2 screen_res;
void main()
{
//transform vertex
gl_Position = ftransform();
vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
}

190
indra/newview/app_settings/shaders/class3/deferred/giF.glsl Normal file
View File

@ -0,0 +1,190 @@
/**
* @file giF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect depthMap;
uniform sampler2DRect normalMap;
uniform sampler2DRect lightMap;
uniform sampler2DRect specularRect;
uniform sampler2D noiseMap;
uniform sampler2D diffuseGIMap;
uniform sampler2D specularGIMap;
uniform sampler2D normalGIMap;
uniform sampler2D depthGIMap;
uniform sampler2D lightFunc;
// Inputs
varying vec2 vary_fragcoord;
uniform vec2 screen_res;
uniform vec4 sunlight_color;
uniform mat4 inv_proj;
uniform mat4 gi_mat; //gPipeline.mGIMatrix - eye space to sun space
uniform mat4 gi_mat_proj; //gPipeline.mGIMatrixProj - eye space to projected sun space
uniform mat4 gi_norm_mat; //gPipeline.mGINormalMatrix - eye space normal to sun space normal matrix
uniform mat4 gi_inv_proj; //gPipeline.mGIInvProj - projected sun space to sun space
uniform float gi_sample_width;
uniform float gi_noise;
uniform float gi_attenuation;
uniform float gi_range;
vec4 getPosition(vec2 pos_screen)
{
float depth = texture2DRect(depthMap, pos_screen.xy).a;
vec2 sc = pos_screen.xy*2.0;
sc /= screen_res;
sc -= vec2(1.0,1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = inv_proj * ndc;
pos /= pos.w;
pos.w = 1.0;
return pos;
}
vec4 getGIPosition(vec2 gi_tc)
{
float depth = texture2D(depthGIMap, gi_tc).a;
vec2 sc = gi_tc*2.0;
sc -= vec2(1.0, 1.0);
vec4 ndc = vec4(sc.x, sc.y, 2.0*depth-1.0, 1.0);
vec4 pos = gi_inv_proj*ndc;
pos.xyz /= pos.w;
pos.w = 1.0;
return pos;
}
vec3 giAmbient(vec3 pos, vec3 norm)
{
vec4 gi_c = gi_mat_proj * vec4(pos, 1.0);
gi_c.xyz /= gi_c.w;
vec4 gi_pos = gi_mat*vec4(pos,1.0);
vec3 gi_norm = (gi_norm_mat*vec4(norm,1.0)).xyz;
gi_norm = normalize(gi_norm);
vec4 c_spec = texture2DRect(specularRect, vary_fragcoord.xy);
vec3 nz = texture2D(noiseMap, vary_fragcoord.xy/128.0).rgb;
gi_pos.xyz += nz.x*gi_noise*gi_norm.xyz;
vec2 tcx = gi_norm.xy;
vec2 tcy = gi_norm.yx;
vec4 eye_pos = gi_mat*vec4(0,0,0,1.0);
vec3 eye_dir = normalize(gi_pos.xyz-eye_pos.xyz);
vec3 eye_ref = reflect(eye_dir, gi_norm);
float da = 0.0; //texture2DRect(lightMap, vary_fragcoord.xy).r*0.5;
vec3 fdiff = vec3(da);
float fda = da;
vec3 rcol = vec3(0,0,0);
float fsa = 0.0;
for (int i = -1; i <= 1; i += 2 )
{
for (int j = -1; j <= 1; j+= 2)
{
vec2 tc = vec2(i, j)*0.75+gi_norm.xy*nz.z;
tc += nz.xy*2.0;
tc *= gi_sample_width*0.25;
tc += gi_c.xy;
vec3 lnorm = -(texture2D(normalGIMap, tc.xy).xyz*2.0-1.0);
vec3 lpos = getGIPosition(tc.xy).xyz;
vec3 at = lpos-gi_pos.xyz;
float dist = length(at);
float dist_atten = clamp(1.0/(gi_attenuation*dist), 0.0, 1.0);
if (dist_atten > 0.01)
{ //possible contribution of indirect light to this surface
vec3 ldir = at;
float ld = -dot(ldir, lnorm);
if (ld < 0.0)
{
float ang_atten = dot(ldir, gi_norm);
if (ang_atten > 0.0)
{
vec4 spec = texture2D(specularGIMap, tc.xy);
at = normalize(at);
vec3 diff;
float da = 0.0;
//contribution from indirect source to visible pixel
vec3 ha = at;
ha.z -= 1.0;
ha = normalize(ha);
if (spec.a > 0.0)
{
float sa = dot(ha,lnorm);
da = texture2D(lightFunc, vec2(sa, spec.a)).a;
}
else
{
da = -lnorm.z;
}
diff = texture2D(diffuseGIMap, tc.xy).rgb+spec.rgb*spec.a*2.0;
if (da > 0.0)
{ //contribution from visible pixel to eye
vec3 ha = normalize(at-eye_dir);
if (c_spec.a > 0.0)
{
float sa = dot(ha, gi_norm);
da = dist_atten*texture2D(lightFunc, vec2(sa, c_spec.a)).a;
}
else
{
da = dist_atten*dot(gi_norm, normalize(ldir));
}
fda += da;
fdiff += da*(c_spec.rgb*c_spec.a*2.0+vec3(1,1,1))*diff.rgb;
}
}
}
}
}
}
fdiff *= sunlight_color.rgb;
vec3 ret = fda*fdiff;
return clamp(ret,vec3(0.0), vec3(1.0));
}
void main()
{
vec2 pos_screen = vary_fragcoord.xy;
vec4 pos = getPosition(pos_screen);
float rad = gi_range*0.5;
vec3 norm = texture2DRect(normalMap, pos_screen).xyz*2.0-1.0;
float dist = max(length(pos.xyz)-rad, 0.0);
float da = clamp(1.0-dist/rad, 0.0, 1.0);
vec3 ambient = da > 0.0 ? giAmbient(pos.xyz, norm) : vec3(0);
gl_FragData[0].xyz = mix(vec3(0), ambient, da);
}

25
indra/newview/app_settings/shaders/class3/deferred/giFinalF.glsl Normal file
View File

@ -0,0 +1,25 @@
/**
* @file giFinalF.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
#extension GL_ARB_texture_rectangle : enable
uniform sampler2DRect diffuseRect;
uniform sampler2D bloomMap;
uniform sampler2DRect edgeMap;
uniform vec2 screen_res;
varying vec2 vary_fragcoord;
void main()
{
vec4 bloom = texture2D(bloomMap, vary_fragcoord.xy/screen_res);
vec4 diff = texture2DRect(diffuseRect, vary_fragcoord.xy);
gl_FragColor = bloom + diff;
//gl_FragColor.rgb = vec3(texture2DRect(edgeMap, vary_fragcoord.xy).a);
}

17
indra/newview/app_settings/shaders/class3/deferred/giFinalV.glsl Normal file
View File

@ -0,0 +1,17 @@
/**
* @file giFinalV.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
varying vec2 vary_fragcoord;
uniform vec2 screen_res;
void main()
{
//transform vertex
gl_Position = ftransform();
vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
vary_fragcoord = (pos.xy*0.5+0.5)*screen_res;
}

22
indra/newview/app_settings/shaders/class3/deferred/giV.glsl Normal file
View File

@ -0,0 +1,22 @@
/**
* @file giV.glsl
*
* Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
* $License$
*/
varying vec2 vary_fragcoord;
uniform vec2 screen_res;
void main()
{
//transform vertex
gl_Position = ftransform();
vec4 pos = gl_ModelViewProjectionMatrix * gl_Vertex;
vary_fragcoord = (pos.xy * 0.5 + 0.5)*screen_res;
vec4 tex = gl_MultiTexCoord0;
tex.w = 1.0;
gl_FrontColor = gl_Color;
}

Some files were not shown because too many files have changed in this diff Show More