llglsandbox.cpp

Go to the documentation of this file.

#include "llviewerprecompiledheaders.h"

#include "llviewercontrol.h"

#include "llgl.h"
#include "llglimmediate.h"
#include "llglheaders.h"
#include "llparcel.h"
#include "llui.h"

#include "lldrawable.h"
#include "lltextureentry.h"
#include "llviewercamera.h"

#include "llvoavatar.h"
#include "llagent.h"
#include "lltoolmgr.h"
#include "llselectmgr.h"
#include "llhudmanager.h"
#include "llrendersphere.h"
#include "llviewerobjectlist.h"
#include "lltoolselectrect.h"
#include "llviewerwindow.h"
#include "llcompass.h"
#include "llsurface.h"
#include "llwind.h"
#include "llworld.h"
#include "llviewerparcelmgr.h"
#include "llviewerregion.h"
#include "llpreviewtexture.h"
#include "llresmgr.h"
#include "pipeline.h"
#include "llspatialpartition.h"
 
BOOL LLAgent::setLookAt(ELookAtType target_type, LLViewerObject *object, LLVector3 position)
{
        if(object && object->isAttachment())
        {
                LLViewerObject* parent = object;
                while(parent)
                {
                        if (parent == mAvatarObject)
                        {
                                // looking at an attachment on ourselves, which we don't want to do
                                object = mAvatarObject;
                                position.clearVec();
                        }
                        parent = (LLViewerObject*)parent->getParent();
                }
        }
        if(!mLookAt || mLookAt->isDead())
        {
                mLookAt = (LLHUDEffectLookAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_LOOKAT);
                mLookAt->setSourceObject(mAvatarObject);
        }

        return mLookAt->setLookAt(target_type, object, position);
}

BOOL LLAgent::setPointAt(EPointAtType target_type, LLViewerObject *object, LLVector3 position)
{
        // disallow pointing at attachments and avatars
        if (object && (object->isAttachment() || object->isAvatar()))
        {
                return FALSE;
        }

        if(!mPointAt || mPointAt->isDead())
        {
                mPointAt = (LLHUDEffectPointAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINTAT);
                mPointAt->setSourceObject(mAvatarObject);
        }

        return mPointAt->setPointAt(target_type, object, position);
}

ELookAtType LLAgent::getLookAtType()
{ 
        if (mLookAt) 
        {
                return mLookAt->getLookAtType();
        }

        return LOOKAT_TARGET_NONE;
}

EPointAtType LLAgent::getPointAtType()
{ 
        if (mPointAt) 
        {
                return mPointAt->getPointAtType();
        }

        return POINTAT_TARGET_NONE;
}

// Draw a representation of current autopilot target
void LLAgent::renderAutoPilotTarget()
{
        if (mAutoPilot)
        {
                F32 height_meters;
                LLVector3d target_global;

                glMatrixMode(GL_MODELVIEW);
                gGL.pushMatrix();

                // not textured
                LLGLSNoTexture no_texture;

                // lovely green
                glColor4f(0.f, 1.f, 1.f, 1.f);

                target_global = mAutoPilotTargetGlobal;

                gGL.translatef((F32)(target_global.mdV[VX]), (F32)(target_global.mdV[VY]), (F32)(target_global.mdV[VZ]));

                height_meters = 1.f;

                glScalef(height_meters, height_meters, height_meters);

                gSphere.render(1500.f);

                gGL.popMatrix();
        }
}

extern BOOL gDebugSelect;

// Returns true if you got at least one object
void LLToolSelectRect::handleRectangleSelection(S32 x, S32 y, MASK mask)
{
        LLVector3 av_pos = gAgent.getPositionAgent();
        F32 select_dist_squared = gSavedSettings.getF32("MaxSelectDistance");
        select_dist_squared = select_dist_squared * select_dist_squared;

        BOOL deselect = (mask == MASK_CONTROL);
        S32 left =      llmin(x, mDragStartX);
        S32 right =     llmax(x, mDragStartX);
        S32 top =       llmax(y, mDragStartY);
        S32 bottom =llmin(y, mDragStartY);

        left = llround((F32) left * LLUI::sGLScaleFactor.mV[VX]);
        right = llround((F32) right * LLUI::sGLScaleFactor.mV[VX]);
        top = llround((F32) top * LLUI::sGLScaleFactor.mV[VY]);
        bottom = llround((F32) bottom * LLUI::sGLScaleFactor.mV[VY]);

        F32 old_far_plane = LLViewerCamera::getInstance()->getFar();
        F32 old_near_plane = LLViewerCamera::getInstance()->getNear();

        S32 width = right - left + 1;
        S32 height = top - bottom + 1;

        BOOL grow_selection = FALSE;
        BOOL shrink_selection = FALSE;

        if (height > mDragLastHeight || width > mDragLastWidth)
        {
                grow_selection = TRUE;
        }
        if (height < mDragLastHeight || width < mDragLastWidth)
        {
                shrink_selection = TRUE;
        }

        if (!grow_selection && !shrink_selection)
        {
                // nothing to do
                return;
        }

        mDragLastHeight = height;
        mDragLastWidth = width;

        S32 center_x = (left + right) / 2;
        S32 center_y = (top + bottom) / 2;

        // save drawing mode
        glMatrixMode(GL_PROJECTION);
        gGL.pushMatrix();

        BOOL limit_select_distance = gSavedSettings.getBOOL("LimitSelectDistance");
        if (limit_select_distance)
        {
                // ...select distance from control
                LLVector3 relative_av_pos = av_pos;
                relative_av_pos -= LLViewerCamera::getInstance()->getOrigin();

                F32 new_far = relative_av_pos * LLViewerCamera::getInstance()->getAtAxis() + gSavedSettings.getF32("MaxSelectDistance");
                F32 new_near = relative_av_pos * LLViewerCamera::getInstance()->getAtAxis() - gSavedSettings.getF32("MaxSelectDistance");

                new_near = llmax(new_near, 0.1f);

                LLViewerCamera::getInstance()->setFar(new_far);
                LLViewerCamera::getInstance()->setNear(new_near);
        }
        LLViewerCamera::getInstance()->setPerspective(FOR_SELECTION, 
                                                        center_x-width/2, center_y-height/2, width, height, 
                                                        limit_select_distance);

        if (shrink_selection)
        {
                struct f : public LLSelectedObjectFunctor
                {
                        virtual bool apply(LLViewerObject* vobjp)
                        {
                                LLDrawable* drawable = vobjp->mDrawable;
                                if (!drawable || vobjp->getPCode() != LL_PCODE_VOLUME || vobjp->isAttachment())
                                {
                                        return true;
                                }
                                S32 result = LLViewerCamera::getInstance()->sphereInFrustum(drawable->getPositionAgent(), drawable->getRadius());
                                switch (result)
                                {
                                  case 0:
                                        LLSelectMgr::getInstance()->unhighlightObjectOnly(vobjp);
                                        break;
                                  case 1:
                                        // check vertices
                                        if (!LLViewerCamera::getInstance()->areVertsVisible(vobjp, LLSelectMgr::sRectSelectInclusive))
                                        {
                                                LLSelectMgr::getInstance()->unhighlightObjectOnly(vobjp);
                                        }
                                        break;
                                  default:
                                        break;
                                }
                                return true;
                        }
                } func;
                LLSelectMgr::getInstance()->getHighlightedObjects()->applyToObjects(&func);
        }

        if (grow_selection)
        {
                std::vector<LLDrawable*> potentials;
                                
                for (LLWorld::region_list_t::iterator iter = LLWorld::getInstance()->getRegionList().begin(); 
                        iter != LLWorld::getInstance()->getRegionList().end(); ++iter)
                {
                        LLViewerRegion* region = *iter;
                        for (U32 i = 0; i < LLViewerRegion::NUM_PARTITIONS; i++)
                        {
                                LLSpatialPartition* part = region->getSpatialPartition(i);
                                if (part)
                                {       
                                        part->cull(*LLViewerCamera::getInstance(), &potentials, TRUE);
                                }
                        }
                }
                
                for (std::vector<LLDrawable*>::iterator iter = potentials.begin();
                         iter != potentials.end(); iter++)
                {
                        LLDrawable* drawable = *iter;
                        LLViewerObject* vobjp = drawable->getVObj();

                        if (!drawable || !vobjp ||
                                vobjp->getPCode() != LL_PCODE_VOLUME || 
                                vobjp->isAttachment() ||
                                (deselect && !vobjp->isSelected()))
                        {
                                continue;
                        }

                        if (limit_select_distance && dist_vec_squared(drawable->getWorldPosition(), av_pos) > select_dist_squared)
                        {
                                continue;
                        }

                        S32 result = LLViewerCamera::getInstance()->sphereInFrustum(drawable->getPositionAgent(), drawable->getRadius());
                        if (result)
                        {
                                switch (result)
                                {
                                case 1:
                                        // check vertices
                                        if (LLViewerCamera::getInstance()->areVertsVisible(vobjp, LLSelectMgr::sRectSelectInclusive))
                                        {
                                                LLSelectMgr::getInstance()->highlightObjectOnly(vobjp);
                                        }
                                        break;
                                case 2:
                                        LLSelectMgr::getInstance()->highlightObjectOnly(vobjp);
                                        break;
                                default:
                                        break;
                                }
                        }
                }
        }

        // restore drawing mode
        glMatrixMode(GL_PROJECTION);
        gGL.popMatrix();
        glMatrixMode(GL_MODELVIEW);

        // restore camera
        LLViewerCamera::getInstance()->setFar(old_far_plane);
        LLViewerCamera::getInstance()->setNear(old_near_plane);
        gViewerWindow->setup3DRender();
}


const F32 COMPASS_SIZE = 64;
static const F32 COMPASS_RANGE = 0.33f;

void LLCompass::draw()
{
        glMatrixMode(GL_MODELVIEW);
        gGL.pushMatrix();

        S32 width = 32;
        S32 height = 32;

        LLGLSUIDefault gls_ui;

        gGL.translatef( COMPASS_SIZE/2.f, COMPASS_SIZE/2.f, 0.f);

        if (mBkgndTexture)
        {
                mBkgndTexture->bind();
                gGL.color4f(1.0f, 1.0f, 1.0f, 1.0f);
                
                gGL.begin(LLVertexBuffer::QUADS);
                
                gGL.texCoord2f(1.f, 1.f);
                gGL.vertex2i(width, height);
                
                gGL.texCoord2f(0.f, 1.f);
                gGL.vertex2i(-width, height);
                
                gGL.texCoord2f(0.f, 0.f);
                gGL.vertex2i(-width, -height);
                
                gGL.texCoord2f(1.f, 0.f);
                gGL.vertex2i(width, -height);
                
                gGL.end();
        }

        // rotate subsequent draws to agent rotation
        F32 rotation = atan2( gAgent.getFrameAgent().getAtAxis().mV[VX], gAgent.getFrameAgent().getAtAxis().mV[VY] );
        glRotatef( - rotation * RAD_TO_DEG, 0.f, 0.f, -1.f);
        
        if (mTexture)
        {
                mTexture->bind();
                gGL.color4f(1.0f, 1.0f, 1.0f, 1.0f);
                
                gGL.begin(LLVertexBuffer::QUADS);
                
                gGL.texCoord2f(1.f, 1.f);
                gGL.vertex2i(width, height);
                
                gGL.texCoord2f(0.f, 1.f);
                gGL.vertex2i(-width, height);
                
                gGL.texCoord2f(0.f, 0.f);
                gGL.vertex2i(-width, -height);
                
                gGL.texCoord2f(1.f, 0.f);
                gGL.vertex2i(width, -height);
                
                gGL.end();
        }

        gGL.popMatrix();

}



void LLHorizontalCompass::draw()
{
        LLGLSUIDefault gls_ui;
        
        S32 width = getRect().getWidth();
        S32 height = getRect().getHeight();
        S32 half_width = width / 2;

        if( mTexture )
        {
                const LLVector3& at_axis = LLViewerCamera::getInstance()->getAtAxis();
                F32 center = atan2( at_axis.mV[VX], at_axis.mV[VY] );

                center += F_PI;
                center = llclamp( center, 0.0f, F_TWO_PI ); // probably not necessary...
                center /= F_TWO_PI;
                F32 left = center - COMPASS_RANGE;
                F32 right = center + COMPASS_RANGE;

                mTexture->bind();
                gGL.color4f(1.0f, 1.0f, 1.0f, 1.0f );
                gGL.begin( LLVertexBuffer::QUADS );

                gGL.texCoord2f(right, 1.f);
                gGL.vertex2i(width, height);

                gGL.texCoord2f(left, 1.f);
                gGL.vertex2i(0, height);

                gGL.texCoord2f(left, 0.f);
                gGL.vertex2i(0, 0);

                gGL.texCoord2f(right, 0.f);
                gGL.vertex2i(width, 0);

                gGL.end();
        }

        // Draw the focus line
        {
                LLGLSNoTexture gls_no_texture;
                gGL.color4fv( mFocusColor.mV );
                gl_line_2d( half_width, 0, half_width, height );
        }
}


const F32 WIND_ALTITUDE                 = 180.f;


void LLWind::renderVectors()
{
        // Renders the wind as vectors (used for debug)
        S32 i,j;
        F32 x,y;

        F32 region_width_meters = LLWorld::getInstance()->getRegionWidthInMeters();

        LLGLSNoTexture gls_no_texture;
        gGL.pushMatrix();
        LLVector3 origin_agent;
        origin_agent = gAgent.getPosAgentFromGlobal(mOriginGlobal);
        gGL.translatef(origin_agent.mV[VX], origin_agent.mV[VY], WIND_ALTITUDE);
        for (j = 0; j < mSize; j++)
        {
                for (i = 0; i < mSize; i++)
                {
                        x = mCloudVelX[i + j*mSize] * WIND_SCALE_HACK;
                        y = mCloudVelY[i + j*mSize] * WIND_SCALE_HACK;
                        gGL.pushMatrix();
                        gGL.translatef((F32)i * region_width_meters/mSize, (F32)j * region_width_meters/mSize, 0.0);
                        gGL.color3f(0,1,0);
                        gGL.begin(LLVertexBuffer::POINTS);
                                gGL.vertex3f(0,0,0);
                        gGL.end();
                        gGL.color3f(1,0,0);
                        gGL.begin(LLVertexBuffer::LINES);
                                gGL.vertex3f(x * 0.1f, y * 0.1f ,0.f);
                                gGL.vertex3f(x, y, 0.f);
                        gGL.end();
                        gGL.popMatrix();
                }
        }
        gGL.popMatrix();
}




// Used by lltoolselectland
void LLViewerParcelMgr::renderRect(const LLVector3d &west_south_bottom_global, 
                                                                   const LLVector3d &east_north_top_global )
{
        LLGLSUIDefault gls_ui;
        LLGLSNoTexture gls_no_texture;
        LLGLDepthTest gls_depth(GL_TRUE);

        LLVector3 west_south_bottom_agent = gAgent.getPosAgentFromGlobal(west_south_bottom_global);
        F32 west        = west_south_bottom_agent.mV[VX];
        F32 south       = west_south_bottom_agent.mV[VY];
//      F32 bottom      = west_south_bottom_agent.mV[VZ] - 1.f;

        LLVector3 east_north_top_agent = gAgent.getPosAgentFromGlobal(east_north_top_global);
        F32 east        = east_north_top_agent.mV[VX];
        F32 north       = east_north_top_agent.mV[VY];
//      F32 top         = east_north_top_agent.mV[VZ] + 1.f;

        // HACK: At edge of last region of world, we need to make sure the region
        // resolves correctly so we can get a height value.
        const F32 FUDGE = 0.01f;

        F32 sw_bottom = LLWorld::getInstance()->resolveLandHeightAgent( LLVector3( west, south, 0.f ) );
        F32 se_bottom = LLWorld::getInstance()->resolveLandHeightAgent( LLVector3( east-FUDGE, south, 0.f ) );
        F32 ne_bottom = LLWorld::getInstance()->resolveLandHeightAgent( LLVector3( east-FUDGE, north-FUDGE, 0.f ) );
        F32 nw_bottom = LLWorld::getInstance()->resolveLandHeightAgent( LLVector3( west, north-FUDGE, 0.f ) );

        F32 sw_top = sw_bottom + PARCEL_POST_HEIGHT;
        F32 se_top = se_bottom + PARCEL_POST_HEIGHT;
        F32 ne_top = ne_bottom + PARCEL_POST_HEIGHT;
        F32 nw_top = nw_bottom + PARCEL_POST_HEIGHT;

        LLUI::setLineWidth(2.f);
        gGL.color4f(1.f, 1.f, 0.f, 1.f);

        // Cheat and give this the same pick-name as land
        gGL.begin(LLVertexBuffer::LINES);

        gGL.vertex3f(west, north, nw_bottom);
        gGL.vertex3f(west, north, nw_top);

        gGL.vertex3f(east, north, ne_bottom);
        gGL.vertex3f(east, north, ne_top);

        gGL.vertex3f(east, south, se_bottom);
        gGL.vertex3f(east, south, se_top);

        gGL.vertex3f(west, south, sw_bottom);
        gGL.vertex3f(west, south, sw_top);

        gGL.end();

        gGL.color4f(1.f, 1.f, 0.f, 0.2f);
        gGL.begin(LLVertexBuffer::QUADS);

        gGL.vertex3f(west, north, nw_bottom);
        gGL.vertex3f(west, north, nw_top);
        gGL.vertex3f(east, north, ne_top);
        gGL.vertex3f(east, north, ne_bottom);

        gGL.vertex3f(east, north, ne_bottom);
        gGL.vertex3f(east, north, ne_top);
        gGL.vertex3f(east, south, se_top);
        gGL.vertex3f(east, south, se_bottom);

        gGL.vertex3f(east, south, se_bottom);
        gGL.vertex3f(east, south, se_top);
        gGL.vertex3f(west, south, sw_top);
        gGL.vertex3f(west, south, sw_bottom);

        gGL.vertex3f(west, south, sw_bottom);
        gGL.vertex3f(west, south, sw_top);
        gGL.vertex3f(west, north, nw_top);
        gGL.vertex3f(west, north, nw_bottom);

        gGL.end();

        LLUI::setLineWidth(1.f);
}

/*
void LLViewerParcelMgr::renderParcel(LLParcel* parcel )
{
        S32 i;
        S32 count = parcel->getBoxCount();
        for (i = 0; i < count; i++)
        {
                const LLParcelBox& box = parcel->getBox(i);

                F32 west = box.mMin.mV[VX];
                F32 south = box.mMin.mV[VY];

                F32 east = box.mMax.mV[VX];
                F32 north = box.mMax.mV[VY];

                // HACK: At edge of last region of world, we need to make sure the region
                // resolves correctly so we can get a height value.
                const F32 FUDGE = 0.01f;

                F32 sw_bottom = LLWorld::getInstance()->resolveLandHeightAgent( LLVector3( west, south, 0.f ) );
                F32 se_bottom = LLWorld::getInstance()->resolveLandHeightAgent( LLVector3( east-FUDGE, south, 0.f ) );
                F32 ne_bottom = LLWorld::getInstance()->resolveLandHeightAgent( LLVector3( east-FUDGE, north-FUDGE, 0.f ) );
                F32 nw_bottom = LLWorld::getInstance()->resolveLandHeightAgent( LLVector3( west, north-FUDGE, 0.f ) );

                // little hack to make nearby lines not Z-fight
                east -= 0.1f;
                north -= 0.1f;

                F32 sw_top = sw_bottom + POST_HEIGHT;
                F32 se_top = se_bottom + POST_HEIGHT;
                F32 ne_top = ne_bottom + POST_HEIGHT;
                F32 nw_top = nw_bottom + POST_HEIGHT;

                LLGLSNoTexture gls_no_texture;
                LLGLDepthTest gls_depth(GL_TRUE);

                LLUI::setLineWidth(2.f);
                gGL.color4f(0.f, 1.f, 1.f, 1.f);

                // Cheat and give this the same pick-name as land
                gGL.begin(LLVertexBuffer::LINES);

                gGL.vertex3f(west, north, nw_bottom);
                gGL.vertex3f(west, north, nw_top);

                gGL.vertex3f(east, north, ne_bottom);
                gGL.vertex3f(east, north, ne_top);

                gGL.vertex3f(east, south, se_bottom);
                gGL.vertex3f(east, south, se_top);

                gGL.vertex3f(west, south, sw_bottom);
                gGL.vertex3f(west, south, sw_top);

                gGL.end();

                gGL.color4f(0.f, 1.f, 1.f, 0.2f);
                gGL.begin(LLVertexBuffer::QUADS);

                gGL.vertex3f(west, north, nw_bottom);
                gGL.vertex3f(west, north, nw_top);
                gGL.vertex3f(east, north, ne_top);
                gGL.vertex3f(east, north, ne_bottom);

                gGL.vertex3f(east, north, ne_bottom);
                gGL.vertex3f(east, north, ne_top);
                gGL.vertex3f(east, south, se_top);
                gGL.vertex3f(east, south, se_bottom);

                gGL.vertex3f(east, south, se_bottom);
                gGL.vertex3f(east, south, se_top);
                gGL.vertex3f(west, south, sw_top);
                gGL.vertex3f(west, south, sw_bottom);

                gGL.vertex3f(west, south, sw_bottom);
                gGL.vertex3f(west, south, sw_top);
                gGL.vertex3f(west, north, nw_top);
                gGL.vertex3f(west, north, nw_bottom);

                gGL.end();

                LLUI::setLineWidth(1.f);
        }
}
*/


// north = a wall going north/south.  Need that info to set up texture
// coordinates correctly.
void LLViewerParcelMgr::renderOneSegment(F32 x1, F32 y1, F32 x2, F32 y2, F32 height, U8 direction, LLViewerRegion* regionp)
{
        // HACK: At edge of last region of world, we need to make sure the region
        // resolves correctly so we can get a height value.
        const F32 BORDER = REGION_WIDTH_METERS - 0.1f;

        F32 clamped_x1 = x1;
        F32 clamped_y1 = y1;
        F32 clamped_x2 = x2;
        F32 clamped_y2 = y2;

        if (clamped_x1 > BORDER) clamped_x1 = BORDER;
        if (clamped_y1 > BORDER) clamped_y1 = BORDER;
        if (clamped_x2 > BORDER) clamped_x2 = BORDER;
        if (clamped_y2 > BORDER) clamped_y2 = BORDER;

        F32 z;
        F32 z1;
        F32 z2;

        z1 = regionp->getLand().resolveHeightRegion( LLVector3( clamped_x1, clamped_y1, 0.f ) );
        z2 = regionp->getLand().resolveHeightRegion( LLVector3( clamped_x2, clamped_y2, 0.f ) );

        // Convert x1 and x2 from region-local to agent coords.
        LLVector3 origin = regionp->getOriginAgent();
        x1 += origin.mV[VX];
        x2 += origin.mV[VX];
        y1 += origin.mV[VY];
        y2 += origin.mV[VY];

        if (height < 1.f)
        {
                z = z1+height;
                gGL.vertex3f(x1, y1, z);

                gGL.vertex3f(x1, y1, z1);

                gGL.vertex3f(x2, y2, z2);

                z = z2+height;
                gGL.vertex3f(x2, y2, z);
        }
        else
        {
                F32 tex_coord1;
                F32 tex_coord2;

                if (WEST_MASK == direction)
                {
                        tex_coord1 = y1;
                        tex_coord2 = y2;
                }
                else if (SOUTH_MASK == direction)
                {
                        tex_coord1 = x1;
                        tex_coord2 = x2;
                }
                else if (EAST_MASK == direction)
                {
                        tex_coord1 = y2;
                        tex_coord2 = y1;
                }
                else /* (NORTH_MASK == direction) */
                {
                        tex_coord1 = x2;
                        tex_coord2 = x1;
                }


                gGL.texCoord2f(tex_coord1*0.5f+0.5f, z1*0.5f);
                gGL.vertex3f(x1, y1, z1);

                gGL.texCoord2f(tex_coord2*0.5f+0.5f, z2*0.5f);
                gGL.vertex3f(x2, y2, z2);

                // top edge stairsteps
                z = llmax(z2+height, z1+height);
                gGL.texCoord2f(tex_coord2*0.5f+0.5f, z*0.5f);
                gGL.vertex3f(x2, y2, z);

                gGL.texCoord2f(tex_coord1*0.5f+0.5f, z*0.5f);
                gGL.vertex3f(x1, y1, z);
        }
}


void LLViewerParcelMgr::renderHighlightSegments(const U8* segments, LLViewerRegion* regionp)
{
        S32 x, y;
        F32 x1, y1;     // start point
        F32 x2, y2;     // end point
        bool has_segments = false;

        LLGLSUIDefault gls_ui;
        LLGLSNoTexture gls_no_texture;
        LLGLDepthTest gls_depth(GL_TRUE);

        gGL.color4f(1.f, 1.f, 0.f, 0.2f);

        const S32 STRIDE = (mParcelsPerEdge+1);

        // Cheat and give this the same pick-name as land
        
        
        for (y = 0; y < STRIDE; y++)
        {
                for (x = 0; x < STRIDE; x++)
                {
                        U8 segment_mask = segments[x + y*STRIDE];

                        if (segment_mask & SOUTH_MASK)
                        {
                                x1 = x * PARCEL_GRID_STEP_METERS;
                                y1 = y * PARCEL_GRID_STEP_METERS;

                                x2 = x1 + PARCEL_GRID_STEP_METERS;
                                y2 = y1;
                                
                                if (!has_segments)
                                {
                                        has_segments = true;
                                        gGL.begin(LLVertexBuffer::QUADS);
                                }
                                renderOneSegment(x1, y1, x2, y2, PARCEL_POST_HEIGHT, SOUTH_MASK, regionp);
                        }

                        if (segment_mask & WEST_MASK)
                        {
                                x1 = x * PARCEL_GRID_STEP_METERS;
                                y1 = y * PARCEL_GRID_STEP_METERS;

                                x2 = x1;
                                y2 = y1 + PARCEL_GRID_STEP_METERS;

                                if (!has_segments)
                                {
                                        has_segments = true;
                                        gGL.begin(LLVertexBuffer::QUADS);
                                }
                                renderOneSegment(x1, y1, x2, y2, PARCEL_POST_HEIGHT, WEST_MASK, regionp);
                        }
                }
        }

        if (has_segments)
        {
                gGL.end();
        }
}


void LLViewerParcelMgr::renderCollisionSegments(U8* segments, BOOL use_pass, LLViewerRegion* regionp)
{

        S32 x, y;
        F32 x1, y1;     // start point
        F32 x2, y2;     // end point
        F32 alpha = 0;
        F32 dist = 0;
        F32 dx, dy;
        F32 collision_height;

        const S32 STRIDE = (mParcelsPerEdge+1);
        
        LLVector3 pos = gAgent.getPositionAgent();

        F32 pos_x = pos.mV[VX];
        F32 pos_y = pos.mV[VY];

        LLGLSUIDefault gls_ui;
        LLGLDepthTest gls_depth(GL_TRUE);
        LLGLDisable cull(GL_CULL_FACE);
        
        if (mCollisionBanned == BA_BANNED)
        {
                collision_height = BAN_HEIGHT;
        }
        else
        {
                collision_height = PARCEL_HEIGHT;
        }

        
        if (use_pass && (mCollisionBanned == BA_NOT_ON_LIST))
        {
                LLViewerImage::bindTexture(mPassImage);
        }
        else
        {
                LLViewerImage::bindTexture(mBlockedImage);
        }

        gGL.begin(LLVertexBuffer::QUADS);

        for (y = 0; y < STRIDE; y++)
        {
                for (x = 0; x < STRIDE; x++)
                {
                        U8 segment_mask = segments[x + y*STRIDE];
                        U8 direction;
                        const F32 MAX_ALPHA = 0.95f;
                        const S32 DIST_OFFSET = 5;
                        const S32 MIN_DIST_SQ = DIST_OFFSET*DIST_OFFSET;
                        const S32 MAX_DIST_SQ = 169;

                        if (segment_mask & SOUTH_MASK)
                        {
                                x1 = x * PARCEL_GRID_STEP_METERS;
                                y1 = y * PARCEL_GRID_STEP_METERS;

                                x2 = x1 + PARCEL_GRID_STEP_METERS;
                                y2 = y1;

                                if (gRenderForSelect)
                                {
                                        LLColor4U color((U8)(GL_NAME_PARCEL_WALL >> 16), (U8)(GL_NAME_PARCEL_WALL >> 8), (U8)GL_NAME_PARCEL_WALL);
                                        gGL.color4ubv(color.mV);
                                }
                                else
                                {
                                        dy = (pos_y - y1) + DIST_OFFSET;
                                        
                                        if (pos_x < x1)
                                                dx = pos_x - x1;
                                        else if (pos_x > x2)
                                                dx = pos_x - x2;
                                        else 
                                                dx = 0;
                                        
                                        dist = dx*dx+dy*dy;

                                        if (dist < MIN_DIST_SQ)
                                                alpha = MAX_ALPHA;
                                        else if (dist > MAX_DIST_SQ)
                                                alpha = 0.0f;
                                        else
                                                alpha = 30/dist;

                                        alpha = llclamp(alpha, 0.0f, MAX_ALPHA);

                                        gGL.color4f(1.f, 1.f, 1.f, alpha);
                                }

                                if ((pos_y - y1) < 0) direction = SOUTH_MASK;
                                else            direction = NORTH_MASK;

                                // avoid Z fighting
                                renderOneSegment(x1+0.1f, y1+0.1f, x2+0.1f, y2+0.1f, collision_height, direction, regionp);

                        }

                        if (segment_mask & WEST_MASK)
                        {
                                x1 = x * PARCEL_GRID_STEP_METERS;
                                y1 = y * PARCEL_GRID_STEP_METERS;

                                x2 = x1;
                                y2 = y1 + PARCEL_GRID_STEP_METERS;

                                if (gRenderForSelect)
                                {
                                        LLColor4U color((U8)(GL_NAME_PARCEL_WALL >> 16), (U8)(GL_NAME_PARCEL_WALL >> 8), (U8)GL_NAME_PARCEL_WALL);
                                        gGL.color4ubv(color.mV);
                                }
                                else
                                {                                       
                                        dx = (pos_x - x1) + DIST_OFFSET;
                
                                        if (pos_y < y1) 
                                                dy = pos_y - y1;
                                        else if (pos_y > y2)
                                                dy = pos_y - y2;
                                        else 
                                                dy = 0;

                                        dist = dx*dx+dy*dy;
                                        
                                        if (dist < MIN_DIST_SQ) 
                                                alpha = MAX_ALPHA;
                                        else if (dist > MAX_DIST_SQ)
                                                alpha = 0.0f;
                                        else
                                                alpha = 30/dist;

                                        alpha = llclamp(alpha, 0.0f, MAX_ALPHA);

                                        gGL.color4f(1.f, 1.f, 1.f, alpha);
                                }

                                if ((pos_x - x1) > 0) direction = WEST_MASK;
                                else            direction = EAST_MASK;
                                
                                // avoid Z fighting
                                renderOneSegment(x1+0.1f, y1+0.1f, x2+0.1f, y2+0.1f, collision_height, direction, regionp);

                        }
                }
        }

        gGL.end();
}

void draw_line_cube(F32 width, const LLVector3& center)
{
        width = 0.5f * width;
        gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] + width,center.mV[VZ] + width);
        gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] + width,center.mV[VZ] + width);
        gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] + width,center.mV[VZ] + width);
        gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] - width,center.mV[VZ] + width);
        gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] - width,center.mV[VZ] + width);
        gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] - width,center.mV[VZ] + width);
        gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] - width,center.mV[VZ] + width);
        gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] + width,center.mV[VZ] + width);

        gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] + width,center.mV[VZ] - width);
        gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] + width,center.mV[VZ] - width);
        gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] + width,center.mV[VZ] - width);
        gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] - width,center.mV[VZ] - width);
        gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] - width,center.mV[VZ] - width);
        gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] - width,center.mV[VZ] - width);
        gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] - width,center.mV[VZ] - width);
        gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] + width,center.mV[VZ] - width);

        gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] + width,center.mV[VZ] + width);
        gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] + width,center.mV[VZ] - width);
        gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] + width,center.mV[VZ] + width);
        gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] + width,center.mV[VZ] - width);
        gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] - width,center.mV[VZ] + width);
        gGL.vertex3f(center.mV[VX] - width ,center.mV[VY] - width,center.mV[VZ] - width);
        gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] - width,center.mV[VZ] + width);
        gGL.vertex3f(center.mV[VX] + width ,center.mV[VY] - width,center.mV[VZ] - width);
}


void LLViewerObjectList::renderObjectBeacons()
{
        if (mDebugBeacons.empty())
        {
                return;
        }

        //const LLFontGL *font = LLResMgr::getInstance()->getRes(LLFONT_SANSSERIF);

        LLGLSUIDefault gls_ui;

        {
                LLGLSNoTexture gls_ui_no_texture;

                S32 last_line_width = -1;
                // gGL.begin(LLVertexBuffer::LINES); // Always happens in (line_width != last_line_width)
                
                for (S32 i = 0; i < mDebugBeacons.count(); i++)
                {
                        const LLDebugBeacon &debug_beacon = mDebugBeacons[i];
                        LLColor4 color = debug_beacon.mColor;
                        color.mV[3] *= 0.25f;
                        S32 line_width = debug_beacon.mLineWidth;
                        if (line_width != last_line_width)
                        {
                                if (i > 0)
                                {
                                        gGL.end();
                                        gGL.flush();
                                }
                                glLineWidth( (F32)line_width );
                                last_line_width = line_width;
                                gGL.begin(LLVertexBuffer::LINES);
                        }

                        const LLVector3 &thisline = debug_beacon.mPositionAgent;
                        gGL.color4fv(color.mV);
                        gGL.vertex3f(thisline.mV[VX],thisline.mV[VY],thisline.mV[VZ] - 50.f);
                        gGL.vertex3f(thisline.mV[VX],thisline.mV[VY],thisline.mV[VZ] + 50.f);
                        gGL.vertex3f(thisline.mV[VX] - 2.f,thisline.mV[VY],thisline.mV[VZ]);
                        gGL.vertex3f(thisline.mV[VX] + 2.f,thisline.mV[VY],thisline.mV[VZ]);
                        gGL.vertex3f(thisline.mV[VX],thisline.mV[VY] - 2.f,thisline.mV[VZ]);
                        gGL.vertex3f(thisline.mV[VX],thisline.mV[VY] + 2.f,thisline.mV[VZ]);

                        draw_line_cube(0.10f, thisline);
                }
                gGL.end();
        }

        {
                LLGLSNoTexture gls_ui_no_texture;
                LLGLDepthTest gls_depth(GL_TRUE);
                
                S32 last_line_width = -1;
                // gGL.begin(LLVertexBuffer::LINES); // Always happens in (line_width != last_line_width)
                
                for (S32 i = 0; i < mDebugBeacons.count(); i++)
                {
                        const LLDebugBeacon &debug_beacon = mDebugBeacons[i];

                        S32 line_width = debug_beacon.mLineWidth;
                        if (line_width != last_line_width)
                        {
                                if (i > 0)
                                {
                                        gGL.end();
                                        gGL.flush();
                                }
                                glLineWidth( (F32)line_width );
                                last_line_width = line_width;
                                gGL.begin(LLVertexBuffer::LINES);
                        }

                        const LLVector3 &thisline = debug_beacon.mPositionAgent;
                        gGL.color4fv(debug_beacon.mColor.mV);
                        gGL.vertex3f(thisline.mV[VX],thisline.mV[VY],thisline.mV[VZ] - 0.5f);
                        gGL.vertex3f(thisline.mV[VX],thisline.mV[VY],thisline.mV[VZ] + 0.5f);
                        gGL.vertex3f(thisline.mV[VX] - 0.5f,thisline.mV[VY],thisline.mV[VZ]);
                        gGL.vertex3f(thisline.mV[VX] + 0.5f,thisline.mV[VY],thisline.mV[VZ]);
                        gGL.vertex3f(thisline.mV[VX],thisline.mV[VY] - 0.5f,thisline.mV[VZ]);
                        gGL.vertex3f(thisline.mV[VX],thisline.mV[VY] + 0.5f,thisline.mV[VZ]);

                        draw_line_cube(0.10f, thisline);
                }
                
                gGL.end();
                gGL.flush();
                glLineWidth(1.f);

                for (S32 i = 0; i < mDebugBeacons.count(); i++)
                {
                        LLDebugBeacon &debug_beacon = mDebugBeacons[i];
                        if (debug_beacon.mString == "")
                        {
                                continue;
                        }
                        LLHUDText *hud_textp = (LLHUDText *)LLHUDObject::addHUDObject(LLHUDObject::LL_HUD_TEXT);

                        hud_textp->setZCompare(FALSE);
                        LLColor4 color;
                        color = debug_beacon.mTextColor;
                        color.mV[3] *= 1.f;

                        hud_textp->setString(utf8str_to_wstring(debug_beacon.mString.c_str()));
                        hud_textp->setColor(color);
                        hud_textp->setPositionAgent(debug_beacon.mPositionAgent);
                        debug_beacon.mHUDObject = hud_textp;
                }
        }
}


void pre_show_depth_buffer()
{
        glClear(GL_STENCIL_BUFFER_BIT);
        glEnable(GL_STENCIL_TEST);
        glStencilFunc(GL_ALWAYS,0,0);
        glStencilOp(GL_INCR,GL_INCR,GL_INCR);
}

void post_show_depth_buffer()
{
        int xsize =500, ysize =500;
        U8 *buf = new U8[xsize*ysize];

        glReadPixels(0,0,xsize,ysize,GL_STENCIL_INDEX,GL_UNSIGNED_BYTE, buf);

        int total = 0;
        int i;
        for (i=0;i<xsize*ysize;i++) 
        {
                total += buf[i];
                buf[i] <<= 3;
        }

        float DC = (float)total/(float)(ysize*xsize);
        int DCline = llfloor((xsize-20) * DC / 10.0f);
        int stride = xsize / 10;

        int y = 2;

        for (i=0;i<DCline;i++)
        {
                if (i % stride == 0) i+=2;
                if (i > xsize) y=6;
                buf[ysize*(y+0)+i]=255;
                buf[ysize*(y+1)+i]=255;
                buf[ysize*(y+2)+i]=255;
        }
        glDrawPixels(xsize,ysize,GL_RED,GL_UNSIGNED_BYTE,buf);

        delete [] buf;
}

---