diff options
Diffstat (limited to 'indra/newview/llsurface.cpp')
| -rw-r--r-- | indra/newview/llsurface.cpp | 1337 |
1 files changed, 1337 insertions, 0 deletions
diff --git a/indra/newview/llsurface.cpp b/indra/newview/llsurface.cpp new file mode 100644 index 0000000000..fc0c46bbe1 --- /dev/null +++ b/indra/newview/llsurface.cpp @@ -0,0 +1,1337 @@ +/** + * @file llsurface.cpp + * @brief Implementation of LLSurface class + * + * Copyright (c) 2000-$CurrentYear$, Linden Research, Inc. + * $License$ + */ + +#include "llviewerprecompiledheaders.h" + +#include "llsurface.h" + +#include "llviewerimagelist.h" +#include "llpatchvertexarray.h" +#include "patch_dct.h" +#include "patch_code.h" +#include "bitpack.h" +#include "llviewerobjectlist.h" +#include "llregionhandle.h" +#include "llagent.h" +#include "viewer.h" +#include "llworld.h" +#include "llviewercontrol.h" +#include "llviewerimage.h" +#include "llsurfacepatch.h" +#include "llvosurfacepatch.h" +#include "llvowater.h" +#include "pipeline.h" +#include "llviewerregion.h" +#include "llvlcomposition.h" +#include "noise.h" +#include "llviewercamera.h" +#include "llglheaders.h" +#include "lldrawpool.h" +#include "lldrawable.h" + +extern LLPipeline gPipeline; + +LLColor4U MAX_WATER_COLOR(0, 48, 96, 240); + + +S32 LLSurface::sTextureSize = 256; +S32 LLSurface::sTexelsUpdated = 0; +F32 LLSurface::sTextureUpdateTime = 0.f; +LLStat LLSurface::sTexelsUpdatedPerSecStat; + +extern void bad_network_handler(); + +// ---------------- LLSurface:: Public Members --------------- + +LLSurface::LLSurface(U32 type, LLViewerRegion *regionp) : + mGridsPerEdge(0), + mOOGridsPerEdge(0.f), + mPatchesPerEdge(0), + mType(type), + mOriginGlobal(0.0, 0.0, 0.0), + mSTexturep(NULL), + mWaterTexturep(NULL), + mGridsPerPatchEdge(0), + mMetersPerGrid(1.0f), + mMetersPerEdge(1.0f), + mRegionp(regionp) +{ + // Surface data + mSurfaceZ = NULL; + mNorm = NULL; + + // Patch data + mPatchList = NULL; + + // One of each for each camera + mVisiblePatchCount = 0; + + mHasZData = FALSE; + // "uninitialized" min/max z + mMinZ = 10000.f; + mMaxZ = -10000.f; + + mWaterObjp = NULL; + + // In here temporarily. + mSurfacePatchUpdateCount = 0; + + for (S32 i = 0; i < 8; i++) + { + mNeighbors[i] = NULL; + } +} + + +LLSurface::~LLSurface() +{ + delete [] mSurfaceZ; + mSurfaceZ = NULL; + + delete [] mNorm; + + mGridsPerEdge = 0; + mGridsPerPatchEdge = 0; + mPatchesPerEdge = 0; + mNumberOfPatches = 0; + destroyPatchData(); + + LLDrawPool *poolp = gPipeline.findPool(LLDrawPool::POOL_TERRAIN, mSTexturep); + if (!poolp) + { + llwarns << "No pool for terrain on destruction!" << llendl; + } + else if (poolp->mReferences.empty()) + { + gPipeline.removePool(poolp); + // Don't enable this until we blitz the draw pool for it as well. -- djs + if (mSTexturep) + { + gImageList.deleteImage(mSTexturep); + mSTexturep = NULL; + } + if (mWaterTexturep) + { + gImageList.deleteImage(mWaterTexturep); + mWaterTexturep = NULL; + } + } + else + { + llerrs << "Terrain pool not empty!" << llendl; + } +} + +void LLSurface::initClasses() +{ +} + +void LLSurface::setRegion(LLViewerRegion *regionp) +{ + mRegionp = regionp; +} + +// Assumes that arguments are powers of 2, and that +// grids_per_edge / grids_per_patch_edge = power of 2 +void LLSurface::create(const S32 grids_per_edge, + const S32 grids_per_patch_edge, + const LLVector3d &origin_global, + const F32 width) +{ + // Initialize various constants for the surface + mGridsPerEdge = grids_per_edge + 1; // Add 1 for the east and north buffer + mOOGridsPerEdge = 1.f / mGridsPerEdge; + mGridsPerPatchEdge = grids_per_patch_edge; + mPatchesPerEdge = (mGridsPerEdge - 1) / mGridsPerPatchEdge; + mNumberOfPatches = mPatchesPerEdge * mPatchesPerEdge; + mMetersPerGrid = width / ((F32)(mGridsPerEdge - 1)); + mMetersPerEdge = mMetersPerGrid * (mGridsPerEdge - 1); + + mOriginGlobal.setVec(origin_global); + + mPVArray.create(mGridsPerEdge, mGridsPerPatchEdge, gWorldPointer->getRegionScale()); + + S32 number_of_grids = mGridsPerEdge * mGridsPerEdge; + + ///////////////////////////////////// + // + // Initialize data arrays for surface + /// + mSurfaceZ = new F32[number_of_grids]; + mNorm = new LLVector3[number_of_grids]; + + // Reset the surface to be a flat square grid + for(S32 i=0; i < number_of_grids; i++) + { + // Surface is flat and zero + // Normals all point up + mSurfaceZ[i] = 0.0f; + mNorm[i].setVec(0.f, 0.f, 1.f); + } + + + mVisiblePatchCount = 0; + + + /////////////////////// + // + // Initialize textures + // + + initTextures(); + + // Has to be done after texture initialization + createPatchData(); +} + +LLViewerImage* LLSurface::getSTexture() +{ + if (mSTexturep.notNull() && !mSTexturep->getHasGLTexture()) + { + createSTexture(); + } + return mSTexturep; +} + +LLViewerImage* LLSurface::getWaterTexture() +{ + if (mWaterTexturep.notNull() && !mWaterTexturep->getHasGLTexture()) + { + createWaterTexture(); + } + return mWaterTexturep; +} + +void LLSurface::createSTexture() +{ + if (!mSTexturep) + { + // Fill with dummy gray data. + LLPointer<LLImageRaw> raw = new LLImageRaw(sTextureSize, sTextureSize, 3); + U8 *default_texture = raw->getData(); + for (S32 i = 0; i < sTextureSize; i++) + { + for (S32 j = 0; j < sTextureSize; j++) + { + *(default_texture + (i*sTextureSize + j)*3) = 128; + *(default_texture + (i*sTextureSize + j)*3 + 1) = 128; + *(default_texture + (i*sTextureSize + j)*3 + 2) = 128; + } + } + + mSTexturep = new LLViewerImage(raw, FALSE); + mSTexturep->dontDiscard(); + mSTexturep->bind(); + mSTexturep->setClamp(TRUE, TRUE); + gImageList.addImage(mSTexturep); + } +} + +void LLSurface::createWaterTexture() +{ + if (!mWaterTexturep) + { + // Create the water texture + LLPointer<LLImageRaw> raw = new LLImageRaw(sTextureSize/2, sTextureSize/2, 4); + U8 *default_texture = raw->getData(); + for (S32 i = 0; i < sTextureSize/2; i++) + { + for (S32 j = 0; j < sTextureSize/2; j++) + { + *(default_texture + (i*sTextureSize/2 + j)*4) = MAX_WATER_COLOR.mV[0]; + *(default_texture + (i*sTextureSize/2 + j)*4 + 1) = MAX_WATER_COLOR.mV[1]; + *(default_texture + (i*sTextureSize/2 + j)*4 + 2) = MAX_WATER_COLOR.mV[2]; + *(default_texture + (i*sTextureSize/2 + j)*4 + 3) = MAX_WATER_COLOR.mV[3]; + } + } + mWaterTexturep = new LLViewerImage(raw, FALSE); + mWaterTexturep->dontDiscard(); + mWaterTexturep->bind(); + mWaterTexturep->setClamp(TRUE, TRUE); + gImageList.addImage(mWaterTexturep); + } +} + +void LLSurface::initTextures() +{ + /////////////////////// + // + // Main surface texture + // + createSTexture(); + + /////////////////////// + // + // Water texture + // + if (gSavedSettings.getBOOL("RenderWater") ) + { + createWaterTexture(); + mWaterObjp = (LLVOWater *)gObjectList.createObjectViewer(LLViewerObject::LL_VO_WATER, mRegionp); + gPipeline.addObject(mWaterObjp); + LLVector3d water_pos_global = from_region_handle(mRegionp->getHandle()); + water_pos_global += LLVector3d(128.0, 128.0, DEFAULT_WATER_HEIGHT); + mWaterObjp->setPositionGlobal(water_pos_global); + } +} + + +void LLSurface::setOriginGlobal(const LLVector3d &origin_global) +{ + LLVector3d new_origin_global; + mOriginGlobal = origin_global; + LLSurfacePatch *patchp; + S32 i, j; + // Need to update the southwest corners of the patches + for (j=0; j<mPatchesPerEdge; j++) + { + for (i=0; i<mPatchesPerEdge; i++) + { + patchp = getPatch(i, j); + + new_origin_global = patchp->getOriginGlobal(); + + new_origin_global.mdV[0] = mOriginGlobal.mdV[0] + i * mMetersPerGrid * mGridsPerPatchEdge; + new_origin_global.mdV[1] = mOriginGlobal.mdV[1] + j * mMetersPerGrid * mGridsPerPatchEdge; + patchp->setOriginGlobal(new_origin_global); + } + } + + // Hack! + if (mWaterObjp.notNull() && mWaterObjp->mDrawable.notNull()) + { + const F64 x = origin_global.mdV[VX] + 128.0; + const F64 y = origin_global.mdV[VY] + 128.0; + const F64 z = mWaterObjp->getPositionGlobal().mdV[VZ]; + + LLVector3d water_origin_global(x, y, z); + + mWaterObjp->setPositionGlobal(water_origin_global); + gPipeline.markMoved(mWaterObjp->mDrawable); + } +} + + +void LLSurface::connectNeighbor(LLSurface *neighborp, U32 direction) +{ + S32 i; + LLSurfacePatch *patchp, *neighbor_patchp; + + if (gNoRender) + { + return; + } + + mNeighbors[direction] = neighborp; + neighborp->mNeighbors[gDirOpposite[direction]] = this; + + // Connect patches + if (NORTHEAST == direction) + { + patchp = getPatch(mPatchesPerEdge - 1, mPatchesPerEdge - 1); + neighbor_patchp = neighborp->getPatch(0, 0); + + patchp->connectNeighbor(neighbor_patchp, direction); + neighbor_patchp->connectNeighbor(patchp, gDirOpposite[direction]); + + patchp->updateNorthEdge(); // Only update one of north or east. + patchp->dirtyZ(); + } + else if (NORTHWEST == direction) + { + patchp = getPatch(0, mPatchesPerEdge - 1); + neighbor_patchp = neighborp->getPatch(mPatchesPerEdge - 1, 0); + + patchp->connectNeighbor(neighbor_patchp, direction); + neighbor_patchp->connectNeighbor(patchp, gDirOpposite[direction]); + } + else if (SOUTHWEST == direction) + { + patchp = getPatch(0, 0); + neighbor_patchp = neighborp->getPatch(mPatchesPerEdge - 1, mPatchesPerEdge - 1); + + patchp->connectNeighbor(neighbor_patchp, direction); + neighbor_patchp->connectNeighbor(patchp, gDirOpposite[direction]); + + neighbor_patchp->updateNorthEdge(); // Only update one of north or east. + neighbor_patchp->dirtyZ(); + } + else if (SOUTHEAST == direction) + { + patchp = getPatch(mPatchesPerEdge - 1, 0); + neighbor_patchp = neighborp->getPatch(0, mPatchesPerEdge - 1); + + patchp->connectNeighbor(neighbor_patchp, direction); + neighbor_patchp->connectNeighbor(patchp, gDirOpposite[direction]); + } + else if (EAST == direction) + { + // Do east/west connections, first + for (i = 0; i < (S32)mPatchesPerEdge; i++) + { + patchp = getPatch(mPatchesPerEdge - 1, i); + neighbor_patchp = neighborp->getPatch(0, i); + + patchp->connectNeighbor(neighbor_patchp, direction); + neighbor_patchp->connectNeighbor(patchp, gDirOpposite[direction]); + + patchp->updateEastEdge(); + patchp->dirtyZ(); + } + + // Now do northeast/southwest connections + for (i = 0; i < (S32)mPatchesPerEdge - 1; i++) + { + patchp = getPatch(mPatchesPerEdge - 1, i); + neighbor_patchp = neighborp->getPatch(0, i+1); + + patchp->connectNeighbor(neighbor_patchp, NORTHEAST); + neighbor_patchp->connectNeighbor(patchp, SOUTHWEST); + } + // Now do southeast/northwest connections + for (i = 1; i < (S32)mPatchesPerEdge; i++) + { + patchp = getPatch(mPatchesPerEdge - 1, i); + neighbor_patchp = neighborp->getPatch(0, i-1); + + patchp->connectNeighbor(neighbor_patchp, SOUTHEAST); + neighbor_patchp->connectNeighbor(patchp, NORTHWEST); + } + } + else if (NORTH == direction) + { + // Do north/south connections, first + for (i = 0; i < (S32)mPatchesPerEdge; i++) + { + patchp = getPatch(i, mPatchesPerEdge - 1); + neighbor_patchp = neighborp->getPatch(i, 0); + + patchp->connectNeighbor(neighbor_patchp, direction); + neighbor_patchp->connectNeighbor(patchp, gDirOpposite[direction]); + + patchp->updateNorthEdge(); + patchp->dirtyZ(); + } + + // Do northeast/southwest connections + for (i = 0; i < (S32)mPatchesPerEdge - 1; i++) + { + patchp = getPatch(i, mPatchesPerEdge - 1); + neighbor_patchp = neighborp->getPatch(i+1, 0); + + patchp->connectNeighbor(neighbor_patchp, NORTHEAST); + neighbor_patchp->connectNeighbor(patchp, SOUTHWEST); + } + // Do southeast/northwest connections + for (i = 1; i < (S32)mPatchesPerEdge; i++) + { + patchp = getPatch(i, mPatchesPerEdge - 1); + neighbor_patchp = neighborp->getPatch(i-1, 0); + + patchp->connectNeighbor(neighbor_patchp, NORTHWEST); + neighbor_patchp->connectNeighbor(patchp, SOUTHEAST); + } + } + else if (WEST == direction) + { + // Do east/west connections, first + for (i = 0; i < mPatchesPerEdge; i++) + { + patchp = getPatch(0, i); + neighbor_patchp = neighborp->getPatch(mPatchesPerEdge - 1, i); + + patchp->connectNeighbor(neighbor_patchp, direction); + neighbor_patchp->connectNeighbor(patchp, gDirOpposite[direction]); + + neighbor_patchp->updateEastEdge(); + neighbor_patchp->dirtyZ(); + } + + // Now do northeast/southwest connections + for (i = 1; i < mPatchesPerEdge; i++) + { + patchp = getPatch(0, i); + neighbor_patchp = neighborp->getPatch(mPatchesPerEdge - 1, i - 1); + + patchp->connectNeighbor(neighbor_patchp, SOUTHWEST); + neighbor_patchp->connectNeighbor(patchp, NORTHEAST); + } + + // Now do northwest/southeast connections + for (i = 0; i < mPatchesPerEdge - 1; i++) + { + patchp = getPatch(0, i); + neighbor_patchp = neighborp->getPatch(mPatchesPerEdge - 1, i + 1); + + patchp->connectNeighbor(neighbor_patchp, NORTHWEST); + neighbor_patchp->connectNeighbor(patchp, SOUTHEAST); + } + } + else if (SOUTH == direction) + { + // Do north/south connections, first + for (i = 0; i < mPatchesPerEdge; i++) + { + patchp = getPatch(i, 0); + neighbor_patchp = neighborp->getPatch(i, mPatchesPerEdge - 1); + + patchp->connectNeighbor(neighbor_patchp, direction); + neighbor_patchp->connectNeighbor(patchp, gDirOpposite[direction]); + + neighbor_patchp->updateNorthEdge(); + neighbor_patchp->dirtyZ(); + } + + // Now do northeast/southwest connections + for (i = 1; i < mPatchesPerEdge; i++) + { + patchp = getPatch(i, 0); + neighbor_patchp = neighborp->getPatch(i - 1, mPatchesPerEdge - 1); + + patchp->connectNeighbor(neighbor_patchp, SOUTHWEST); + neighbor_patchp->connectNeighbor(patchp, NORTHEAST); + } + // Now do northeast/southwest connections + for (i = 0; i < mPatchesPerEdge - 1; i++) + { + patchp = getPatch(i, 0); + neighbor_patchp = neighborp->getPatch(i + 1, mPatchesPerEdge - 1); + + patchp->connectNeighbor(neighbor_patchp, SOUTHEAST); + neighbor_patchp->connectNeighbor(patchp, NORTHWEST); + } + } +} + +void LLSurface::disconnectNeighbor(LLSurface *surfacep) +{ + S32 i; + for (i = 0; i < 8; i++) + { + if (surfacep == mNeighbors[i]) + { + mNeighbors[i] = NULL; + } + } + + // Iterate through surface patches, removing any connectivity to removed surface. + for (i = 0; i < mNumberOfPatches; i++) + { + (mPatchList + i)->disconnectNeighbor(surfacep); + } +} + + +void LLSurface::disconnectAllNeighbors() +{ + S32 i; + for (i = 0; i < 8; i++) + { + if (mNeighbors[i]) + { + mNeighbors[i]->disconnectNeighbor(this); + mNeighbors[i] = NULL; + } + } +} + + + +const LLVector3d &LLSurface::getOriginGlobal() const +{ + return mOriginGlobal; +} + +LLVector3 LLSurface::getOriginAgent() const +{ + return gAgent.getPosAgentFromGlobal(mOriginGlobal); +} + +F32 LLSurface::getMetersPerGrid() const +{ + return mMetersPerGrid; +} + +S32 LLSurface::getGridsPerEdge() const +{ + return mGridsPerEdge; +} + +S32 LLSurface::getPatchesPerEdge() const +{ + return mPatchesPerEdge; +} + +S32 LLSurface::getGridsPerPatchEdge() const +{ + return mGridsPerPatchEdge; +} + +void LLSurface::moveZ(const S32 x, const S32 y, const F32 delta) +{ + llassert(x >= 0); + llassert(y >= 0); + llassert(x < mGridsPerEdge); + llassert(y < mGridsPerEdge); + mSurfaceZ[x + y*mGridsPerEdge] += delta; +} + + +void LLSurface::updatePatchVisibilities(LLAgent &agent) +{ + LLVector3 pos_region = mRegionp->getPosRegionFromGlobal(gAgent.getCameraPositionGlobal()); + + LLSurfacePatch *patchp; + + mVisiblePatchCount = 0; + for (S32 i=0; i<mNumberOfPatches; i++) + { + patchp = mPatchList + i; + + patchp->updateVisibility(); + if (patchp->getVisible()) + { + mVisiblePatchCount++; + patchp->updateCameraDistanceRegion(pos_region); + } + } +} + + + +BOOL LLSurface::idleUpdate() +{ + if (!gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_TERRAIN)) + { + return TRUE; + } + + // Perform idle time update of non-critical stuff. + // In this case, texture and normal updates. + LLTimer update_timer; + LLSurfacePatch *patchp = NULL; + + // If the Z height data has changed, we need to rebuild our + // property line vertex arrays. + if (mDirtyPatchList.count() > 0) + { + getRegion()->dirtyHeights(); + } + + S32 i = 0; + while (i < mDirtyPatchList.count()) + { + patchp = mDirtyPatchList[i]; + patchp->updateNormals(); + patchp->updateVerticalStats(); + + if ((update_timer.getElapsedTimeF32() < 0.05f) && patchp->updateTexture()) + { + patchp->clearDirty(); + mDirtyPatchList.remove(i); + } + else + { + i++; + } + } + return TRUE; +} + +// TODO -- move this to LLViewerRegion class +void LLSurface::renderSurfaceBounds() +{ + // Shows the edge of the surface, so that visibility across regions can be seen + LLVector3 origin_agent = getOriginAgent(); + + glPushMatrix(); + LLGLSNoTexture no_texture; + + F32 region_width_meters = gWorldPointer->getRegionWidthInMeters(); + glTranslatef(origin_agent.mV[VX] + (region_width_meters * 0.005f), + origin_agent.mV[VY] + (region_width_meters * 0.005f), 0.f); + + glColor4ub(0, 128, 0, 64); + + F32 length = region_width_meters * 0.995f; + F32 height = length/8.0f; + + glBegin(GL_QUADS); + glVertex3f(length, 0, 0); + glVertex3f(0,0, 0); + glVertex3f(0,0, height); + glVertex3f(length,0, height); + + glVertex3f(length,0, height); + glVertex3f(0,0, height); + glVertex3f(0,0, 0); + glVertex3f(length, 0, 0); + glEnd(); + + glTranslatef(length, 0, 0); + glRotated(90, 0, 0, 1); + glBegin(GL_QUADS); + glVertex3f(length, 0, 0); + glVertex3f(0,0, 0); + glVertex3f(0,0, height); + glVertex3f(length,0, height); + + glVertex3f(length,0, height); + glVertex3f(0,0, height); + glVertex3f(0,0, 0); + glVertex3f(length, 0, 0); + + glEnd(); + glTranslatef(length, 0, 0); + glRotated(90, 0, 0, 1); + glBegin(GL_QUADS); + glVertex3f(length, 0, 0); + glVertex3f(0,0, 0); + glVertex3f(0,0, height); + glVertex3f(length,0, height); + + glVertex3f(length,0, height); + glVertex3f(0,0, height); + glVertex3f(0,0, 0); + glVertex3f(length, 0, 0); + glEnd(); + glTranslatef(length, 0, 0); + glRotated(90, 0, 0, 1); + glBegin(GL_QUADS); + glVertex3f(length, 0, 0); + glVertex3f(0,0, 0); + glVertex3f(0,0, height); + glVertex3f(length,0, height); + + glVertex3f(length,0, height); + glVertex3f(0,0, height); + glVertex3f(0,0, 0); + glVertex3f(length, 0, 0); + glEnd(); + glTranslatef(length, 0, 0); + glRotated(90, 0, 0, 1); + + glPopMatrix(); +} + + +void LLSurface::decompressDCTPatch(LLBitPack &bitpack, LLGroupHeader *gopp, BOOL b_large_patch) +{ + + LLPatchHeader ph; + S32 j, i; + S32 patch[LARGE_PATCH_SIZE*LARGE_PATCH_SIZE]; + LLSurfacePatch *patchp; + + init_patch_decompressor(gopp->patch_size); + gopp->stride = mGridsPerEdge; + set_group_of_patch_header(gopp); + + while (1) + { + decode_patch_header(bitpack, &ph); + if (ph.quant_wbits == END_OF_PATCHES) + { + break; + } + + i = ph.patchids >> 5; + j = ph.patchids & 0x1F; + + if ((i >= mPatchesPerEdge) || (j >= mPatchesPerEdge)) + { + llwarns << "Received invalid terrain packet - patch header patch ID incorrect!" + << " patches per edge " << mPatchesPerEdge + << " i " << i + << " j " << j + << " dc_offset " << ph.dc_offset + << " range " << (S32)ph.range + << " quant_wbits " << (S32)ph.quant_wbits + << " patchids " << (S32)ph.patchids + << llendl; + bad_network_handler(); + return; + } + + patchp = &mPatchList[j*mPatchesPerEdge + i]; + + + decode_patch(bitpack, patch); + decompress_patch(patchp->getDataZ(), patch, &ph); + + // Update edges for neighbors. Need to guarantee that this gets done before we generate vertical stats. + patchp->updateNorthEdge(); + patchp->updateEastEdge(); + if (patchp->getNeighborPatch(WEST)) + { + patchp->getNeighborPatch(WEST)->updateEastEdge(); + } + if (patchp->getNeighborPatch(SOUTHWEST)) + { + patchp->getNeighborPatch(SOUTHWEST)->updateEastEdge(); + patchp->getNeighborPatch(SOUTHWEST)->updateNorthEdge(); + } + if (patchp->getNeighborPatch(SOUTH)) + { + patchp->getNeighborPatch(SOUTH)->updateNorthEdge(); + } + + // Dirty patch statistics, and flag that the patch has data. + patchp->dirtyZ(); + patchp->setHasReceivedData(); + } +} + + +// Retrurns TRUE if "position" is within the bounds of surface. +// "position" is region-local +BOOL LLSurface::containsPosition(const LLVector3 &position) +{ + if (position.mV[VX] < 0.0f || position.mV[VX] > mMetersPerEdge || + position.mV[VY] < 0.0f || position.mV[VY] > mMetersPerEdge) + { + return FALSE; + } + return TRUE; +} + + +F32 LLSurface::resolveHeightRegion(const F32 x, const F32 y) const +{ + F32 height = 0.0f; + F32 oometerspergrid = 1.f/mMetersPerGrid; + + // Check to see if v is actually above surface + // We use (mGridsPerEdge-1) below rather than (mGridsPerEdge) + // becuase of the east and north buffers + + if (x >= 0.f && + x <= mMetersPerEdge && + y >= 0.f && + y <= mMetersPerEdge) + { + const S32 left = llfloor(x * oometerspergrid); + const S32 bottom = llfloor(y * oometerspergrid); + + // Don't walk off the edge of the array! + const S32 right = ( left+1 < (S32)mGridsPerEdge-1 ? left+1 : left ); + const S32 top = ( bottom+1 < (S32)mGridsPerEdge-1 ? bottom+1 : bottom ); + + // Figure out if v is in first or second triangle of the square + // and calculate the slopes accordingly + // | | + // -(i,j+1)---(i+1,j+1)-- + // | 1 / | ^ + // | / 2 | | + // | / | j + // --(i,j)----(i+1,j)-- + // | | + // + // i -> + // where N = mGridsPerEdge + + const F32 left_bottom = getZ( left, bottom ); + const F32 right_bottom = getZ( right, bottom ); + const F32 left_top = getZ( left, top ); + const F32 right_top = getZ( right, top ); + + // dx and dy are incremental steps from (mSurface + k) + F32 dx = x - left * mMetersPerGrid; + F32 dy = y - bottom * mMetersPerGrid; + + if (dy > dx) + { + // triangle 1 + dy *= left_top - left_bottom; + dx *= right_top - left_top; + } + else + { + // triangle 2 + dx *= right_bottom - left_bottom; + dy *= right_top - right_bottom; + } + height = left_bottom + (dx + dy) * oometerspergrid; + } + return height; +} + + +F32 LLSurface::resolveHeightGlobal(const LLVector3d& v) const +{ + if (!mRegionp) + { + return 0.f; + } + + LLVector3 pos_region = mRegionp->getPosRegionFromGlobal(v); + + return resolveHeightRegion(pos_region); +} + + +LLVector3 LLSurface::resolveNormalGlobal(const LLVector3d& pos_global) const +{ + if (!mSurfaceZ) + { + // Hmm. Uninitialized surface! + return LLVector3::z_axis; + } + // + // Returns the vector normal to a surface at location specified by vector v + // + F32 oometerspergrid = 1.f/mMetersPerGrid; + LLVector3 normal; + F32 dzx, dzy; + + if (pos_global.mdV[VX] >= mOriginGlobal.mdV[VX] && + pos_global.mdV[VX] < mOriginGlobal.mdV[VX] + mMetersPerEdge && + pos_global.mdV[VY] >= mOriginGlobal.mdV[VY] && + pos_global.mdV[VY] < mOriginGlobal.mdV[VY] + mMetersPerEdge) + { + U32 i, j, k; + F32 dx, dy; + i = (U32) ((pos_global.mdV[VX] - mOriginGlobal.mdV[VX]) * oometerspergrid); + j = (U32) ((pos_global.mdV[VY] - mOriginGlobal.mdV[VY]) * oometerspergrid ); + k = i + j*mGridsPerEdge; + + // Figure out if v is in first or second triangle of the square + // and calculate the slopes accordingly + // | | + // -(k+N)---(k+1+N)-- + // | 1 / | ^ + // | / 2 | | + // | / | j + // --(k)----(k+1)-- + // | | + // + // i -> + // where N = mGridsPerEdge + + // dx and dy are incremental steps from (mSurface + k) + dx = (F32)(pos_global.mdV[VX] - i*mMetersPerGrid - mOriginGlobal.mdV[VX]); + dy = (F32)(pos_global.mdV[VY] - j*mMetersPerGrid - mOriginGlobal.mdV[VY]); + if (dy > dx) + { // triangle 1 + dzx = *(mSurfaceZ + k + 1 + mGridsPerEdge) - *(mSurfaceZ + k + mGridsPerEdge); + dzy = *(mSurfaceZ + k) - *(mSurfaceZ + k + mGridsPerEdge); + normal.setVec(-dzx,dzy,1); + } + else + { // triangle 2 + dzx = *(mSurfaceZ + k) - *(mSurfaceZ + k + 1); + dzy = *(mSurfaceZ + k + 1 + mGridsPerEdge) - *(mSurfaceZ + k + 1); + normal.setVec(dzx,-dzy,1); + } + } + normal.normVec(); + return normal; + + +} + +LLSurfacePatch *LLSurface::resolvePatchRegion(const F32 x, const F32 y) const +{ +// x and y should be region-local coordinates. +// If x and y are outside of the surface, then the returned +// index will be for the nearest boundary patch. +// +// 12 | 13| 14| 15 +// | | | +// +---+---+---+---+ +// | 12| 13| 14| 15| +// ----+---+---+---+---+----- +// 8 | 8 | 9 | 10| 11| 11 +// ----+---+---+---+---+----- +// 4 | 4 | 5 | 6 | 7 | 7 +// ----+---+---+---+---+----- +// | 0 | 1 | 2 | 3 | +// +---+---+---+---+ +// | | | +// 0 | 1 | 2 | 3 +// + +// When x and y are not region-local do the following first + + S32 i, j; + if (x < 0.0f) + { + i = 0; + } + else if (x >= mMetersPerEdge) + { + i = mPatchesPerEdge - 1; + } + else + { + i = (U32) (x / (mMetersPerGrid * mGridsPerPatchEdge)); + } + + if (y < 0.0f) + { + j = 0; + } + else if (y >= mMetersPerEdge) + { + j = mPatchesPerEdge - 1; + } + else + { + j = (U32) (y / (mMetersPerGrid * mGridsPerPatchEdge)); + } + + // *NOTE: Super paranoia code follows. + S32 index = i + j * mPatchesPerEdge; + if((index < 0) || (index >= mNumberOfPatches)) + { + if(0 == mNumberOfPatches) + { + llwarns << "No patches for current region!" << llendl; + return NULL; + } + S32 old_index = index; + index = llclamp(old_index, 0, (mNumberOfPatches - 1)); + llwarns << "Clamping out of range patch index " << old_index + << " to " << index << llendl; + } + return &(mPatchList[index]); +} + + +LLSurfacePatch *LLSurface::resolvePatchRegion(const LLVector3 &pos_region) const +{ + return resolvePatchRegion(pos_region.mV[VX], pos_region.mV[VY]); +} + + +LLSurfacePatch *LLSurface::resolvePatchGlobal(const LLVector3d &pos_global) const +{ + LLVector3 pos_region = mRegionp->getPosRegionFromGlobal(pos_global); + return resolvePatchRegion(pos_region); +} + + +std::ostream& operator<<(std::ostream &s, const LLSurface &S) +{ + s << "{ \n"; + s << " mGridsPerEdge = " << S.mGridsPerEdge - 1 << " + 1\n"; + s << " mGridsPerPatchEdge = " << S.mGridsPerPatchEdge << "\n"; + s << " mPatchesPerEdge = " << S.mPatchesPerEdge << "\n"; + s << " mOriginGlobal = " << S.mOriginGlobal << "\n"; + s << " mMetersPerGrid = " << S.mMetersPerGrid << "\n"; + s << " mVisiblePatchCount = " << S.mVisiblePatchCount << "\n"; + s << "}"; + return s; +} + + +// ---------------- LLSurface:: Protected ---------------- + +void LLSurface::createPatchData() +{ + // Assumes mGridsPerEdge, mGridsPerPatchEdge, and mPatchesPerEdge have been properly set + // TODO -- check for create() called when surface is not empty + S32 i, j; + LLSurfacePatch *patchp; + + // Allocate memory + mPatchList = new LLSurfacePatch[mNumberOfPatches]; + + // One of each for each camera + mVisiblePatchCount = mNumberOfPatches; + + for (j=0; j<mPatchesPerEdge; j++) + { + for (i=0; i<mPatchesPerEdge; i++) + { + patchp = getPatch(i, j); + patchp->setSurface(this); + } + } + + for (j=0; j<mPatchesPerEdge; j++) + { + for (i=0; i<mPatchesPerEdge; i++) + { + patchp = getPatch(i, j); + patchp->mHasReceivedData = FALSE; + patchp->mSTexUpdate = TRUE; + + S32 data_offset = i * mGridsPerPatchEdge + j * mGridsPerPatchEdge * mGridsPerEdge; + + patchp->setDataZ(mSurfaceZ + data_offset); + patchp->setDataNorm(mNorm + data_offset); + + + // We make each patch point to its neighbors so we can do resolution checking + // when butting up different resolutions. Patches that don't have neighbors + // somewhere will point to NULL on that side. + if (i < mPatchesPerEdge-1) + { + patchp->setNeighborPatch(EAST,getPatch(i+1, j)); + } + else + { + patchp->setNeighborPatch(EAST, NULL); + } + + if (j < mPatchesPerEdge-1) + { + patchp->setNeighborPatch(NORTH, getPatch(i, j+1)); + } + else + { + patchp->setNeighborPatch(NORTH, NULL); + } + + if (i > 0) + { + patchp->setNeighborPatch(WEST, getPatch(i - 1, j)); + } + else + { + patchp->setNeighborPatch(WEST, NULL); + } + + if (j > 0) + { + patchp->setNeighborPatch(SOUTH, getPatch(i, j-1)); + } + else + { + patchp->setNeighborPatch(SOUTH, NULL); + } + + if (i < (mPatchesPerEdge-1) && j < (mPatchesPerEdge-1)) + { + patchp->setNeighborPatch(NORTHEAST, getPatch(i + 1, j + 1)); + } + else + { + patchp->setNeighborPatch(NORTHEAST, NULL); + } + + if (i > 0 && j < (mPatchesPerEdge-1)) + { + patchp->setNeighborPatch(NORTHWEST, getPatch(i - 1, j + 1)); + } + else + { + patchp->setNeighborPatch(NORTHWEST, NULL); + } + + if (i > 0 && j > 0) + { + patchp->setNeighborPatch(SOUTHWEST, getPatch(i - 1, j - 1)); + } + else + { + patchp->setNeighborPatch(SOUTHWEST, NULL); + } + + if (i < (mPatchesPerEdge-1) && j > 0) + { + patchp->setNeighborPatch(SOUTHEAST, getPatch(i + 1, j - 1)); + } + else + { + patchp->setNeighborPatch(SOUTHEAST, NULL); + } + + LLVector3d origin_global; + origin_global.mdV[0] = mOriginGlobal.mdV[0] + i * mMetersPerGrid * mGridsPerPatchEdge; + origin_global.mdV[1] = mOriginGlobal.mdV[0] + j * mMetersPerGrid * mGridsPerPatchEdge; + origin_global.mdV[2] = 0.f; + patchp->setOriginGlobal(origin_global); + } + } +} + + +void LLSurface::destroyPatchData() +{ + // Delete all of the cached patch data for these patches. + + delete [] mPatchList; + mPatchList = NULL; + mVisiblePatchCount = 0; +} + + +void LLSurface::setTextureSize(const S32 texture_size) +{ + sTextureSize = texture_size; +} + + +U32 LLSurface::getRenderLevel(const U32 render_stride) const +{ + return mPVArray.mRenderLevelp[render_stride]; +} + + +U32 LLSurface::getRenderStride(const U32 render_level) const +{ + return mPVArray.mRenderStridep[render_level]; +} + + +LLSurfacePatch *LLSurface::getPatch(const S32 x, const S32 y) const +{ + if ((x < 0) || (x >= mPatchesPerEdge)) + { + llerrs << "Asking for patch out of bounds" << llendl; + return NULL; + } + if ((y < 0) || (y >= mPatchesPerEdge)) + { + llerrs << "Asking for patch out of bounds" << llendl; + return NULL; + } + + return mPatchList + x + y*mPatchesPerEdge; +} + + +void LLSurface::dirtyAllPatches() +{ + S32 i; + for (i = 0; i < mNumberOfPatches; i++) + { + mPatchList[i].dirtyZ(); + } +} + +void LLSurface::dirtySurfacePatch(LLSurfacePatch *patchp) +{ + // Put surface patch on dirty surface patch list + if (-1 == mDirtyPatchList.find(patchp)) + { + mDirtyPatchList.put(patchp); + } +} + + +void LLSurface::setWaterHeight(F32 height) +{ + if (!mWaterObjp.isNull()) + { + LLVector3 water_pos_region = mWaterObjp->getPositionRegion(); + water_pos_region.mV[VZ] = height; + mWaterObjp->setPositionRegion(water_pos_region); + } + else + { + llwarns << "LLSurface::setWaterHeight with no water object!" << llendl; + } +} + +F32 LLSurface::getWaterHeight() const +{ + if (!mWaterObjp.isNull()) + { + // we have a water object, the usual case + return mWaterObjp->getPositionRegion().mV[VZ]; + } + else + { + return DEFAULT_WATER_HEIGHT; + } +} + + +BOOL LLSurface::generateWaterTexture(const F32 x, const F32 y, + const F32 width, const F32 height) +{ + if (!getWaterTexture()) + { + return FALSE; + } + + S32 tex_width = mWaterTexturep->getWidth(); + S32 tex_height = mWaterTexturep->getHeight(); + S32 tex_comps = mWaterTexturep->getComponents(); + S32 tex_stride = tex_width * tex_comps; + LLPointer<LLImageRaw> raw = new LLImageRaw(tex_width, tex_height, tex_comps); + U8 *rawp = raw->getData(); + + F32 scale = 256.f * getMetersPerGrid() / (F32)tex_width; + F32 scale_inv = 1.f / scale; + + S32 x_begin, y_begin, x_end, y_end; + + x_begin = llround(x * scale_inv); + y_begin = llround(y * scale_inv); + x_end = llround((x + width) * scale_inv); + y_end = llround((y + width) * scale_inv); + + if (x_end > tex_width) + { + x_end = tex_width; + } + if (y_end > tex_width) + { + y_end = tex_width; + } + + LLVector3d origin_global = from_region_handle(getRegion()->getHandle()); + + // OK, for now, just have the composition value equal the height at the point. + LLVector3 location; + LLColor4U coloru; + + const F32 WATER_HEIGHT = getWaterHeight(); + + S32 i, j, offset; + for (j = y_begin; j < y_end; j++) + { + for (i = x_begin; i < x_end; i++) + { + //F32 nv[2]; + //nv[0] = i/256.f; + //nv[1] = j/256.f; + // const S32 modulation = noise2(nv)*40; + offset = j*tex_stride + i*tex_comps; + location.mV[VX] = i*scale; + location.mV[VY] = j*scale; + + // Sample multiple points + const F32 height = resolveHeightRegion(location); + + if (height > WATER_HEIGHT) + { + // Above water... + coloru = MAX_WATER_COLOR; + coloru.mV[3] = ABOVE_WATERLINE_ALPHA; + *(rawp + offset++) = coloru.mV[0]; + *(rawp + offset++) = coloru.mV[1]; + *(rawp + offset++) = coloru.mV[2]; + *(rawp + offset++) = coloru.mV[3]; + } + else + { + // Want non-linear curve for transparency gradient + coloru = MAX_WATER_COLOR; + const F32 frac = 1.f - 2.f/(2.f - (height - WATER_HEIGHT)); + S32 alpha = 64 + llround((255-64)*frac); + + alpha = llmin(llround((F32)MAX_WATER_COLOR.mV[3]), alpha); + alpha = llmax(64, alpha); + + coloru.mV[3] = alpha; + *(rawp + offset++) = coloru.mV[0]; + *(rawp + offset++) = coloru.mV[1]; + *(rawp + offset++) = coloru.mV[2]; + *(rawp + offset++) = coloru.mV[3]; + } + } + } + + mWaterTexturep->setSubImage(raw, x_begin, y_begin, x_end - x_begin, y_end - y_begin); + return TRUE; +} |