diff options
Diffstat (limited to 'indra')
64 files changed, 946 insertions, 1005 deletions
diff --git a/indra/llcommon/llmemtype.h b/indra/llcommon/llmemtype.h index 9bf6cad9f7..2e275bd523 100644 --- a/indra/llcommon/llmemtype.h +++ b/indra/llcommon/llmemtype.h @@ -84,6 +84,9 @@ public: MTYPE_REGIONS, MTYPE_INVENTORY, MTYPE_ANIMATION, + MTYPE_VOLUME, + MTYPE_PRIMITIVE, + MTYPE_NETWORK, MTYPE_PHYSICS, MTYPE_INTERESTLIST, diff --git a/indra/llcommon/llversionviewer.h b/indra/llcommon/llversionviewer.h index a1fd0ff509..dbf1d3154b 100644 --- a/indra/llcommon/llversionviewer.h +++ b/indra/llcommon/llversionviewer.h @@ -34,7 +34,7 @@ const S32 LL_VERSION_MAJOR = 1; const S32 LL_VERSION_MINOR = 20; -const S32 LL_VERSION_PATCH = 2; +const S32 LL_VERSION_PATCH = 4; const S32 LL_VERSION_BUILD = 0; const char * const LL_CHANNEL = "Second Life Release"; diff --git a/indra/llimage/llimage.cpp b/indra/llimage/llimage.cpp index c8cfad84f6..2948675396 100644 --- a/indra/llimage/llimage.cpp +++ b/indra/llimage/llimage.cpp @@ -768,8 +768,8 @@ void LLImageRaw::copyScaled( LLImageRaw* src ) LLMemType mt1((LLMemType::EMemType)mMemType); LLImageRaw* dst = this; // Just for clarity. - llassert( (1 == src->getComponents()) || (3 == src->getComponents()) || (4 == src->getComponents()) ); - llassert( src->getComponents() == dst->getComponents() ); + llassert_always( (1 == src->getComponents()) || (3 == src->getComponents()) || (4 == src->getComponents()) ); + llassert_always( src->getComponents() == dst->getComponents() ); if( (src->getWidth() == dst->getWidth()) && (src->getHeight() == dst->getHeight()) ) { @@ -779,6 +779,7 @@ void LLImageRaw::copyScaled( LLImageRaw* src ) // Vertical S32 temp_data_size = src->getWidth() * dst->getHeight() * getComponents(); + llassert_always(temp_data_size > 0); U8* temp_buffer = new U8[ temp_data_size ]; for( S32 col = 0; col < src->getWidth(); col++ ) { diff --git a/indra/llmath/llvolume.cpp b/indra/llmath/llvolume.cpp index a0990c5fc1..f4052f336f 100644 --- a/indra/llmath/llvolume.cpp +++ b/indra/llmath/llvolume.cpp @@ -34,6 +34,7 @@ #include <set> #include "llerror.h" +#include "llmemtype.h" #include "llvolumemgr.h" #include "v2math.h" @@ -155,6 +156,8 @@ BOOL LLTriangleLineSegmentIntersect( const LLVector3& pt1, const LLVector3& pt2, LLProfile::Face* LLProfile::addCap(S16 faceID) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + Face *face = vector_append(mFaces, 1); face->mIndex = 0; @@ -167,6 +170,8 @@ LLProfile::Face* LLProfile::addCap(S16 faceID) LLProfile::Face* LLProfile::addFace(S32 i, S32 count, F32 scaleU, S16 faceID, BOOL flat) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + Face *face = vector_append(mFaces, 1); face->mIndex = i; @@ -182,8 +187,10 @@ LLProfile::Face* LLProfile::addFace(S32 i, S32 count, F32 scaleU, S16 faceID, BO // What is the bevel parameter used for? - DJS 04/05/02 // Bevel parameter is currently unused but presumedly would support // filleted and chamfered corners -void LLProfile::genNGon(S32 sides, F32 offset, F32 bevel, F32 ang_scale, S32 split) +void LLProfile::genNGon(const LLProfileParams& params, S32 sides, F32 offset, F32 bevel, F32 ang_scale, S32 split) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + // Generate an n-sided "circular" path. // 0 is (1,0), and we go counter-clockwise along a circular path from there. const F32 tableScale[] = { 1, 1, 1, 0.5f, 0.707107f, 0.53f, 0.525f, 0.5f }; @@ -194,8 +201,8 @@ void LLProfile::genNGon(S32 sides, F32 offset, F32 bevel, F32 ang_scale, S32 spl mMaxX = 0.f; mMinX = 0.f; - F32 begin = mParams.getBegin(); - F32 end = mParams.getEnd(); + F32 begin = params.getBegin(); + F32 end = params.getEnd(); t_step = 1.0f / sides; ang_step = 2.0f*F_PI*t_step*ang_scale; @@ -311,7 +318,7 @@ void LLProfile::genNGon(S32 sides, F32 offset, F32 bevel, F32 ang_scale, S32 spl mConcave = FALSE; } mOpen = TRUE; - if (!isHollow()) + if (params.getHollow() <= 0) { // put center point if not hollow. mProfile.push_back(LLVector3(0,0,0)); @@ -327,7 +334,7 @@ void LLProfile::genNGon(S32 sides, F32 offset, F32 bevel, F32 ang_scale, S32 spl mTotal = mProfile.size(); } -void LLProfile::genNormals() +void LLProfile::genNormals(const LLProfileParams& params) { S32 count = mProfile.size(); @@ -347,8 +354,7 @@ void LLProfile::genNormals() LLVector2 pt0,pt1; - BOOL hollow; - hollow = isHollow(); + BOOL hollow = (params.getHollow() > 0); S32 i0, i1, i2, i3, i4; @@ -428,7 +434,7 @@ void LLProfile::genNormals() // Hollow is percent of the original bounding box, not of this particular // profile's geometry. Thus, a swept triangle needs lower hollow values than // a swept square. -LLProfile::Face* LLProfile::addHole(BOOL flat, F32 sides, F32 offset, F32 box_hollow, F32 ang_scale, S32 split) +LLProfile::Face* LLProfile::addHole(const LLProfileParams& params, BOOL flat, F32 sides, F32 offset, F32 box_hollow, F32 ang_scale, S32 split) { // Note that addHole will NOT work for non-"circular" profiles, if we ever decide to use them. @@ -436,11 +442,12 @@ LLProfile::Face* LLProfile::addHole(BOOL flat, F32 sides, F32 offset, F32 box_ho mTotalOut = mTotal; // Why is the "bevel" parameter -1? DJS 04/05/02 - genNGon(llfloor(sides),offset,-1, ang_scale, split); + genNGon(params, llfloor(sides),offset,-1, ang_scale, split); Face *face = addFace(mTotalOut, mTotal-mTotalOut,0,LL_FACE_INNER_SIDE, flat); - LLVector3 pt[128]; + std::vector<LLVector3> pt; + pt.resize(mTotal) ; for (S32 i=mTotalOut;i<mTotal;i++) { @@ -489,8 +496,10 @@ S32 sculpt_sides(F32 detail) } -BOOL LLProfile::generate(BOOL path_open,F32 detail, S32 split, BOOL is_sculpted) +BOOL LLProfile::generate(const LLProfileParams& params, BOOL path_open,F32 detail, S32 split, BOOL is_sculpted) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + if ((!mDirty) && (!is_sculpted)) { return FALSE; @@ -508,9 +517,9 @@ BOOL LLProfile::generate(BOOL path_open,F32 detail, S32 split, BOOL is_sculpted) // Generate the face data S32 i; - F32 begin = mParams.getBegin(); - F32 end = mParams.getEnd(); - F32 hollow = mParams.getHollow(); + F32 begin = params.getBegin(); + F32 end = params.getEnd(); + F32 hollow = params.getHollow(); // Quick validation to eliminate some server crashes. if (begin > end - 0.01f) @@ -521,11 +530,11 @@ BOOL LLProfile::generate(BOOL path_open,F32 detail, S32 split, BOOL is_sculpted) S32 face_num = 0; - switch (mParams.getCurveType() & LL_PCODE_PROFILE_MASK) + switch (params.getCurveType() & LL_PCODE_PROFILE_MASK) { case LL_PCODE_PROFILE_SQUARE: { - genNGon(4,-0.375, 0, 1, split); + genNGon(params, 4,-0.375, 0, 1, split); if (path_open) { addCap (LL_FACE_PATH_BEGIN); @@ -544,20 +553,20 @@ BOOL LLProfile::generate(BOOL path_open,F32 detail, S32 split, BOOL is_sculpted) if (hollow) { - switch (mParams.getCurveType() & LL_PCODE_HOLE_MASK) + switch (params.getCurveType() & LL_PCODE_HOLE_MASK) { case LL_PCODE_HOLE_TRIANGLE: // This offset is not correct, but we can't change it now... DK 11/17/04 - addHole(TRUE, 3, -0.375f, hollow, 1.f, split); + addHole(params, TRUE, 3, -0.375f, hollow, 1.f, split); break; case LL_PCODE_HOLE_CIRCLE: // TODO: Compute actual detail levels for cubes - addHole(FALSE, MIN_DETAIL_FACES * detail, -0.375f, hollow, 1.f); + addHole(params, FALSE, MIN_DETAIL_FACES * detail, -0.375f, hollow, 1.f); break; case LL_PCODE_HOLE_SAME: case LL_PCODE_HOLE_SQUARE: default: - addHole(TRUE, 4, -0.375f, hollow, 1.f, split); + addHole(params, TRUE, 4, -0.375f, hollow, 1.f, split); break; } } @@ -571,7 +580,7 @@ BOOL LLProfile::generate(BOOL path_open,F32 detail, S32 split, BOOL is_sculpted) case LL_PCODE_PROFILE_RIGHTTRI: case LL_PCODE_PROFILE_EQUALTRI: { - genNGon(3,0, 0, 1, split); + genNGon(params, 3,0, 0, 1, split); for (i = 0; i <(S32) mProfile.size(); i++) { // Scale by 3 to generate proper tex coords. @@ -593,19 +602,19 @@ BOOL LLProfile::generate(BOOL path_open,F32 detail, S32 split, BOOL is_sculpted) // because the triangle doesn't fill the bounding box. F32 triangle_hollow = hollow / 2.f; - switch (mParams.getCurveType() & LL_PCODE_HOLE_MASK) + switch (params.getCurveType() & LL_PCODE_HOLE_MASK) { case LL_PCODE_HOLE_CIRCLE: // TODO: Actually generate level of detail for triangles - addHole(FALSE, MIN_DETAIL_FACES * detail, 0, triangle_hollow, 1.f); + addHole(params, FALSE, MIN_DETAIL_FACES * detail, 0, triangle_hollow, 1.f); break; case LL_PCODE_HOLE_SQUARE: - addHole(TRUE, 4, 0, triangle_hollow, 1.f, split); + addHole(params, TRUE, 4, 0, triangle_hollow, 1.f, split); break; case LL_PCODE_HOLE_SAME: case LL_PCODE_HOLE_TRIANGLE: default: - addHole(TRUE, 3, 0, triangle_hollow, 1.f, split); + addHole(params, TRUE, 3, 0, triangle_hollow, 1.f, split); break; } } @@ -619,7 +628,7 @@ BOOL LLProfile::generate(BOOL path_open,F32 detail, S32 split, BOOL is_sculpted) F32 circle_detail = MIN_DETAIL_FACES * detail; if (hollow) { - hole_type = mParams.getCurveType() & LL_PCODE_HOLE_MASK; + hole_type = params.getCurveType() & LL_PCODE_HOLE_MASK; if (hole_type == LL_PCODE_HOLE_SQUARE) { // Snap to the next multiple of four sides, @@ -633,7 +642,7 @@ BOOL LLProfile::generate(BOOL path_open,F32 detail, S32 split, BOOL is_sculpted) if (is_sculpted) sides = sculpt_sides(detail); - genNGon(sides); + genNGon(params, sides); if (path_open) { @@ -654,15 +663,15 @@ BOOL LLProfile::generate(BOOL path_open,F32 detail, S32 split, BOOL is_sculpted) switch (hole_type) { case LL_PCODE_HOLE_SQUARE: - addHole(TRUE, 4, 0, hollow, 1.f, split); + addHole(params, TRUE, 4, 0, hollow, 1.f, split); break; case LL_PCODE_HOLE_TRIANGLE: - addHole(TRUE, 3, 0, hollow, 1.f, split); + addHole(params, TRUE, 3, 0, hollow, 1.f, split); break; case LL_PCODE_HOLE_CIRCLE: case LL_PCODE_HOLE_SAME: default: - addHole(FALSE, circle_detail, 0, hollow, 1.f); + addHole(params, FALSE, circle_detail, 0, hollow, 1.f); break; } } @@ -677,7 +686,7 @@ BOOL LLProfile::generate(BOOL path_open,F32 detail, S32 split, BOOL is_sculpted) F32 circle_detail = MIN_DETAIL_FACES * detail * 0.5f; if (hollow) { - hole_type = mParams.getCurveType() & LL_PCODE_HOLE_MASK; + hole_type = params.getCurveType() & LL_PCODE_HOLE_MASK; if (hole_type == LL_PCODE_HOLE_SQUARE) { // Snap to the next multiple of four sides (div 2), @@ -685,12 +694,12 @@ BOOL LLProfile::generate(BOOL path_open,F32 detail, S32 split, BOOL is_sculpted) circle_detail = llceil(circle_detail / 2.0f) * 2.0f; } } - genNGon(llfloor(circle_detail), 0.5f, 0.f, 0.5f); + genNGon(params, llfloor(circle_detail), 0.5f, 0.f, 0.5f); if (path_open) { addCap(LL_FACE_PATH_BEGIN); } - if (mOpen && !mParams.getHollow()) + if (mOpen && !params.getHollow()) { addFace(0,mTotal-1,0,LL_FACE_OUTER_SIDE_0, FALSE); } @@ -704,21 +713,21 @@ BOOL LLProfile::generate(BOOL path_open,F32 detail, S32 split, BOOL is_sculpted) switch (hole_type) { case LL_PCODE_HOLE_SQUARE: - addHole(TRUE, 2, 0.5f, hollow, 0.5f, split); + addHole(params, TRUE, 2, 0.5f, hollow, 0.5f, split); break; case LL_PCODE_HOLE_TRIANGLE: - addHole(TRUE, 3, 0.5f, hollow, 0.5f, split); + addHole(params, TRUE, 3, 0.5f, hollow, 0.5f, split); break; case LL_PCODE_HOLE_CIRCLE: case LL_PCODE_HOLE_SAME: default: - addHole(FALSE, circle_detail, 0.5f, hollow, 0.5f); + addHole(params, FALSE, circle_detail, 0.5f, hollow, 0.5f); break; } } // Special case for openness of sphere - if ((mParams.getEnd() - mParams.getBegin()) < 1.f) + if ((params.getEnd() - params.getBegin()) < 1.f) { mOpen = TRUE; } @@ -731,7 +740,7 @@ BOOL LLProfile::generate(BOOL path_open,F32 detail, S32 split, BOOL is_sculpted) } break; default: - llerrs << "Unknown profile: getCurveType()=" << mParams.getCurveType() << llendl; + llerrs << "Unknown profile: getCurveType()=" << params.getCurveType() << llendl; break; }; @@ -754,7 +763,7 @@ BOOL LLProfile::generate(BOOL path_open,F32 detail, S32 split, BOOL is_sculpted) } } - //genNormals(); + //genNormals(params); return TRUE; } @@ -763,6 +772,8 @@ BOOL LLProfile::generate(BOOL path_open,F32 detail, S32 split, BOOL is_sculpted) BOOL LLProfileParams::importFile(FILE *fp) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + const S32 BUFSIZE = 16384; char buffer[BUFSIZE]; /* Flawfinder: ignore */ // *NOTE: changing the size or type of these buffers will require @@ -838,6 +849,8 @@ BOOL LLProfileParams::exportFile(FILE *fp) const BOOL LLProfileParams::importLegacyStream(std::istream& input_stream) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + const S32 BUFSIZE = 16384; char buffer[BUFSIZE]; /* Flawfinder: ignore */ // *NOTE: changing the size or type of these buffers will require @@ -929,6 +942,7 @@ bool LLProfileParams::fromLLSD(LLSD& sd) void LLProfileParams::copyParams(const LLProfileParams ¶ms) { + LLMemType m1(LLMemType::MTYPE_VOLUME); setCurveType(params.getCurveType()); setBegin(params.getBegin()); setEnd(params.getEnd()); @@ -940,22 +954,22 @@ LLPath::~LLPath() { } -void LLPath::genNGon(S32 sides, F32 startOff, F32 end_scale, F32 twist_scale) +void LLPath::genNGon(const LLPathParams& params, S32 sides, F32 startOff, F32 end_scale, F32 twist_scale) { // Generates a circular path, starting at (1, 0, 0), counterclockwise along the xz plane. const F32 tableScale[] = { 1, 1, 1, 0.5f, 0.707107f, 0.53f, 0.525f, 0.5f }; - F32 revolutions = mParams.getRevolutions(); - F32 skew = mParams.getSkew(); + F32 revolutions = params.getRevolutions(); + F32 skew = params.getSkew(); F32 skew_mag = fabs(skew); - F32 hole_x = mParams.getScaleX() * (1.0f - skew_mag); - F32 hole_y = mParams.getScaleY(); + F32 hole_x = params.getScaleX() * (1.0f - skew_mag); + F32 hole_y = params.getScaleY(); // Calculate taper begin/end for x,y (Negative means taper the beginning) F32 taper_x_begin = 1.0f; - F32 taper_x_end = 1.0f - mParams.getTaperX(); + F32 taper_x_end = 1.0f - params.getTaperX(); F32 taper_y_begin = 1.0f; - F32 taper_y_end = 1.0f - mParams.getTaperY(); + F32 taper_y_end = 1.0f - params.getTaperY(); if ( taper_x_end > 1.0f ) { @@ -983,7 +997,7 @@ void LLPath::genNGon(S32 sides, F32 startOff, F32 end_scale, F32 twist_scale) // Now check the radius offset to calculate the start,end radius. (Negative means // decrease the start radius instead). F32 radius_end = radius_start; - F32 radius_offset = mParams.getRadiusOffset(); + F32 radius_offset = params.getRadiusOffset(); if (radius_offset < 0.f) { radius_start *= 1.f + radius_offset; @@ -994,7 +1008,7 @@ void LLPath::genNGon(S32 sides, F32 startOff, F32 end_scale, F32 twist_scale) } // Is the path NOT a closed loop? - mOpen = ( (mParams.getEnd()*end_scale - mParams.getBegin() < 1.0f) || + mOpen = ( (params.getEnd()*end_scale - params.getBegin() < 1.0f) || (skew_mag > 0.001f) || (fabs(taper_x_end - taper_x_begin) > 0.001f) || (fabs(taper_y_end - taper_y_begin) > 0.001f) || @@ -1005,22 +1019,22 @@ void LLPath::genNGon(S32 sides, F32 startOff, F32 end_scale, F32 twist_scale) PathPt *pt; LLVector3 path_axis (1.f, 0.f, 0.f); //LLVector3 twist_axis(0.f, 0.f, 1.f); - F32 twist_begin = mParams.getTwistBegin() * twist_scale; - F32 twist_end = mParams.getTwist() * twist_scale; + F32 twist_begin = params.getTwistBegin() * twist_scale; + F32 twist_end = params.getTwist() * twist_scale; // We run through this once before the main loop, to make sure // the path begins at the correct cut. F32 step= 1.0f / sides; - F32 t = mParams.getBegin(); + F32 t = params.getBegin(); pt = vector_append(mPath, 1); ang = 2.0f*F_PI*revolutions * t; s = sin(ang)*lerp(radius_start, radius_end, t); c = cos(ang)*lerp(radius_start, radius_end, t); - pt->mPos.setVec(0 + lerp(0,mParams.getShear().mV[0],s) + pt->mPos.setVec(0 + lerp(0,params.getShear().mV[0],s) + lerp(-skew ,skew, t) * 0.5f, - c + lerp(0,mParams.getShear().mV[1],s), + c + lerp(0,params.getShear().mV[1],s), s); pt->mScale.mV[VX] = hole_x * lerp(taper_x_begin, taper_x_end, t); pt->mScale.mV[VY] = hole_y * lerp(taper_y_begin, taper_y_end, t); @@ -1039,7 +1053,7 @@ void LLPath::genNGon(S32 sides, F32 startOff, F32 end_scale, F32 twist_scale) t = ((S32)(t * sides)) / (F32)sides; // Run through the non-cut dependent points. - while (t < mParams.getEnd()) + while (t < params.getEnd()) { pt = vector_append(mPath, 1); @@ -1047,9 +1061,9 @@ void LLPath::genNGon(S32 sides, F32 startOff, F32 end_scale, F32 twist_scale) c = cos(ang)*lerp(radius_start, radius_end, t); s = sin(ang)*lerp(radius_start, radius_end, t); - pt->mPos.setVec(0 + lerp(0,mParams.getShear().mV[0],s) + pt->mPos.setVec(0 + lerp(0,params.getShear().mV[0],s) + lerp(-skew ,skew, t) * 0.5f, - c + lerp(0,mParams.getShear().mV[1],s), + c + lerp(0,params.getShear().mV[1],s), s); pt->mScale.mV[VX] = hole_x * lerp(taper_x_begin, taper_x_end, t); @@ -1066,15 +1080,15 @@ void LLPath::genNGon(S32 sides, F32 startOff, F32 end_scale, F32 twist_scale) } // Make one final pass for the end cut. - t = mParams.getEnd(); + t = params.getEnd(); pt = vector_append(mPath, 1); ang = 2.0f*F_PI*revolutions * t; c = cos(ang)*lerp(radius_start, radius_end, t); s = sin(ang)*lerp(radius_start, radius_end, t); - pt->mPos.setVec(0 + lerp(0,mParams.getShear().mV[0],s) + pt->mPos.setVec(0 + lerp(0,params.getShear().mV[0],s) + lerp(-skew ,skew, t) * 0.5f, - c + lerp(0,mParams.getShear().mV[1],s), + c + lerp(0,params.getShear().mV[1],s), s); pt->mScale.mV[VX] = hole_x * lerp(taper_x_begin, taper_x_end, t); pt->mScale.mV[VY] = hole_y * lerp(taper_y_begin, taper_y_end, t); @@ -1117,8 +1131,10 @@ const LLVector2 LLPathParams::getEndScale() const return end_scale; } -BOOL LLPath::generate(F32 detail, S32 split, BOOL is_sculpted) +BOOL LLPath::generate(const LLPathParams& params, F32 detail, S32 split, BOOL is_sculpted) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + if ((!mDirty) && (!is_sculpted)) { return FALSE; @@ -1137,13 +1153,13 @@ BOOL LLPath::generate(F32 detail, S32 split, BOOL is_sculpted) mOpen = TRUE; // Is this 0xf0 mask really necessary? DK 03/02/05 - switch (mParams.getCurveType() & 0xf0) + switch (params.getCurveType() & 0xf0) { default: case LL_PCODE_PATH_LINE: { // Take the begin/end twist into account for detail. - np = llfloor(fabs(mParams.getTwistBegin() - mParams.getTwist()) * 3.5f * (detail-0.5f)) + 2; + np = llfloor(fabs(params.getTwistBegin() - params.getTwist()) * 3.5f * (detail-0.5f)) + 2; if (np < split+2) { np = split+2; @@ -1153,16 +1169,16 @@ BOOL LLPath::generate(F32 detail, S32 split, BOOL is_sculpted) mPath.resize(np); - LLVector2 start_scale = mParams.getBeginScale(); - LLVector2 end_scale = mParams.getEndScale(); + LLVector2 start_scale = params.getBeginScale(); + LLVector2 end_scale = params.getEndScale(); for (S32 i=0;i<np;i++) { - F32 t = lerp(mParams.getBegin(),mParams.getEnd(),(F32)i * mStep); - mPath[i].mPos.setVec(lerp(0,mParams.getShear().mV[0],t), - lerp(0,mParams.getShear().mV[1],t), + F32 t = lerp(params.getBegin(),params.getEnd(),(F32)i * mStep); + mPath[i].mPos.setVec(lerp(0,params.getShear().mV[0],t), + lerp(0,params.getShear().mV[1],t), t - 0.5f); - mPath[i].mRot.setQuat(lerp(F_PI * mParams.getTwistBegin(),F_PI * mParams.getTwist(),t),0,0,1); + mPath[i].mRot.setQuat(lerp(F_PI * params.getTwistBegin(),F_PI * params.getTwist(),t),0,0,1); mPath[i].mScale.mV[0] = lerp(start_scale.mV[0],end_scale.mV[0],t); mPath[i].mScale.mV[1] = lerp(start_scale.mV[1],end_scale.mV[1],t); mPath[i].mTexT = t; @@ -1173,27 +1189,27 @@ BOOL LLPath::generate(F32 detail, S32 split, BOOL is_sculpted) case LL_PCODE_PATH_CIRCLE: { // Increase the detail as the revolutions and twist increase. - F32 twist_mag = fabs(mParams.getTwistBegin() - mParams.getTwist()); + F32 twist_mag = fabs(params.getTwistBegin() - params.getTwist()); - S32 sides = (S32)llfloor(llfloor((MIN_DETAIL_FACES * detail + twist_mag * 3.5f * (detail-0.5f))) * mParams.getRevolutions()); + S32 sides = (S32)llfloor(llfloor((MIN_DETAIL_FACES * detail + twist_mag * 3.5f * (detail-0.5f))) * params.getRevolutions()); if (is_sculpted) sides = sculpt_sides(detail); - genNGon(sides); + genNGon(params, sides); } break; case LL_PCODE_PATH_CIRCLE2: { - if (mParams.getEnd() - mParams.getBegin() >= 0.99f && - mParams.getScaleX() >= .99f) + if (params.getEnd() - params.getBegin() >= 0.99f && + params.getScaleX() >= .99f) { mOpen = FALSE; } - //genNGon(llfloor(MIN_DETAIL_FACES * detail), 4.f, 0.f); - genNGon(llfloor(MIN_DETAIL_FACES * detail)); + //genNGon(params, llfloor(MIN_DETAIL_FACES * detail), 4.f, 0.f); + genNGon(params, llfloor(MIN_DETAIL_FACES * detail)); F32 t = 0.f; F32 tStep = 1.0f / mPath.size(); @@ -1223,28 +1239,30 @@ BOOL LLPath::generate(F32 detail, S32 split, BOOL is_sculpted) { F32 t = (F32)i * mStep; mPath[i].mPos.setVec(0, - lerp(0, -sin(F_PI*mParams.getTwist()*t)*0.5f,t), - lerp(-0.5, cos(F_PI*mParams.getTwist()*t)*0.5f,t)); - mPath[i].mScale.mV[0] = lerp(1,mParams.getScale().mV[0],t); - mPath[i].mScale.mV[1] = lerp(1,mParams.getScale().mV[1],t); + lerp(0, -sin(F_PI*params.getTwist()*t)*0.5f,t), + lerp(-0.5, cos(F_PI*params.getTwist()*t)*0.5f,t)); + mPath[i].mScale.mV[0] = lerp(1,params.getScale().mV[0],t); + mPath[i].mScale.mV[1] = lerp(1,params.getScale().mV[1],t); mPath[i].mTexT = t; - mPath[i].mRot.setQuat(F_PI * mParams.getTwist() * t,1,0,0); + mPath[i].mRot.setQuat(F_PI * params.getTwist() * t,1,0,0); } break; }; - if (mParams.getTwist() != mParams.getTwistBegin()) mOpen = TRUE; + if (params.getTwist() != params.getTwistBegin()) mOpen = TRUE; - //if ((int(fabsf(mParams.getTwist() - mParams.getTwistBegin())*100))%100 != 0) { + //if ((int(fabsf(params.getTwist() - params.getTwistBegin())*100))%100 != 0) { // mOpen = TRUE; //} return TRUE; } -BOOL LLDynamicPath::generate(F32 detail, S32 split, BOOL is_sculpted) +BOOL LLDynamicPath::generate(const LLPathParams& params, F32 detail, S32 split, BOOL is_sculpted) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + mOpen = TRUE; // Draw end caps if (getPathLength() == 0) { @@ -1266,6 +1284,8 @@ BOOL LLDynamicPath::generate(F32 detail, S32 split, BOOL is_sculpted) BOOL LLPathParams::importFile(FILE *fp) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + const S32 BUFSIZE = 16384; char buffer[BUFSIZE]; /* Flawfinder: ignore */ // *NOTE: changing the size or type of these buffers will require @@ -1410,6 +1430,8 @@ BOOL LLPathParams::exportFile(FILE *fp) const BOOL LLPathParams::importLegacyStream(std::istream& input_stream) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + const S32 BUFSIZE = 16384; char buffer[BUFSIZE]; /* Flawfinder: ignore */ // *NOTE: changing the size or type of these buffers will require @@ -1610,8 +1632,11 @@ LLProfile::~LLProfile() S32 LLVolume::sNumMeshPoints = 0; -LLVolume::LLVolume(const LLVolumeParams ¶ms, const F32 detail, const BOOL generate_single_face, const BOOL is_unique) : mParams(params) +LLVolume::LLVolume(const LLVolumeParams ¶ms, const F32 detail, const BOOL generate_single_face, const BOOL is_unique) + : mParams(params) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + mUnique = is_unique; mFaceMask = 0x0; mDetail = detail; @@ -1620,16 +1645,14 @@ LLVolume::LLVolume(const LLVolumeParams ¶ms, const F32 detail, const BOOL ge // set defaults if (mParams.getPathParams().getCurveType() == LL_PCODE_PATH_FLEXIBLE) { - mPathp = new LLDynamicPath(mParams.getPathParams()); + mPathp = new LLDynamicPath(); } else { - mPathp = new LLPath(mParams.getPathParams()); + mPathp = new LLPath(); } - mProfilep = new LLProfile(mParams.getProfileParams()); + mProfilep = new LLProfile(); - mNumVolumeFaces = 0; - mVolumeFaces = NULL; mGenerateSingleFace = generate_single_face; generate(); @@ -1642,11 +1665,7 @@ LLVolume::LLVolume(const LLVolumeParams ¶ms, const F32 detail, const BOOL ge void LLVolume::resizePath(S32 length) { mPathp->resizePath(length); - if (mVolumeFaces != NULL) - { - delete[] mVolumeFaces; - mVolumeFaces = NULL; - } + mVolumeFaces.clear(); } void LLVolume::regen() @@ -1665,15 +1684,14 @@ LLVolume::~LLVolume() sNumMeshPoints -= mMesh.size(); delete mPathp; delete mProfilep; - delete[] mVolumeFaces; - mPathp = NULL; mProfilep = NULL; - mVolumeFaces = NULL; + mVolumeFaces.clear(); } BOOL LLVolume::generate() { + LLMemType m1(LLMemType::MTYPE_VOLUME); llassert_always(mProfilep); //Added 10.03.05 Dave Parks @@ -1682,13 +1700,13 @@ BOOL LLVolume::generate() // stretched due to twisting or scaling on the path. S32 split = (S32) ((mDetail)*0.66f); - if (mPathp->mParams.getCurveType() == LL_PCODE_PATH_LINE && - (mPathp->mParams.getScale().mV[0] != 1.0f || - mPathp->mParams.getScale().mV[1] != 1.0f) && - (mProfilep->mParams.getCurveType() == LL_PCODE_PROFILE_SQUARE || - mProfilep->mParams.getCurveType() == LL_PCODE_PROFILE_ISOTRI || - mProfilep->mParams.getCurveType() == LL_PCODE_PROFILE_EQUALTRI || - mProfilep->mParams.getCurveType() == LL_PCODE_PROFILE_RIGHTTRI)) + if (mParams.getPathParams().getCurveType() == LL_PCODE_PATH_LINE && + (mParams.getPathParams().getScale().mV[0] != 1.0f || + mParams.getPathParams().getScale().mV[1] != 1.0f) && + (mParams.getProfileParams().getCurveType() == LL_PCODE_PROFILE_SQUARE || + mParams.getProfileParams().getCurveType() == LL_PCODE_PROFILE_ISOTRI || + mParams.getProfileParams().getCurveType() == LL_PCODE_PROFILE_EQUALTRI || + mParams.getProfileParams().getCurveType() == LL_PCODE_PROFILE_RIGHTTRI)) { split = 0; } @@ -1698,8 +1716,8 @@ BOOL LLVolume::generate() F32 profile_detail = mDetail; F32 path_detail = mDetail; - U8 path_type = mPathp->mParams.getCurveType(); - U8 profile_type = mProfilep->mParams.getCurveType(); + U8 path_type = mParams.getPathParams().getCurveType(); + U8 profile_type = mParams.getProfileParams().getCurveType(); if (path_type == LL_PCODE_PATH_LINE && profile_type == LL_PCODE_PROFILE_CIRCLE) { //cylinders don't care about Z-Axis @@ -1710,8 +1728,8 @@ BOOL LLVolume::generate() mLODScaleBias.setVec(0.6f, 0.6f, 0.6f); } - BOOL regenPath = mPathp->generate(path_detail, split); - BOOL regenProf = mProfilep->generate(mPathp->isOpen(),profile_detail, split); + BOOL regenPath = mPathp->generate(mParams.getPathParams(), path_detail, split); + BOOL regenProf = mProfilep->generate(mParams.getProfileParams(), mPathp->isOpen(),profile_detail, split); if (regenPath || regenProf ) { @@ -1759,28 +1777,26 @@ BOOL LLVolume::generate() void LLVolume::createVolumeFaces() { - S32 i; + LLMemType m1(LLMemType::MTYPE_VOLUME); if (mGenerateSingleFace) { - mNumVolumeFaces = 0; + // do nothing } else { S32 num_faces = getNumFaces(); - mNumVolumeFaces = num_faces; BOOL partial_build = TRUE; - if (!mVolumeFaces) + if (num_faces != mVolumeFaces.size()) { partial_build = FALSE; - mVolumeFaces = new LLVolumeFace[num_faces]; + mVolumeFaces.resize(num_faces); } // Initialize volume faces with parameter data - for (i = 0; i < num_faces; i++) + for (S32 i = 0; i < (S32)mVolumeFaces.size(); i++) { - LLVolumeFace &vf = mVolumeFaces[i]; - LLProfile::Face &face = mProfilep->mFaces[i]; - vf.mVolumep = this; + LLVolumeFace& vf = mVolumeFaces[i]; + LLProfile::Face& face = mProfilep->mFaces[i]; vf.mBeginS = face.mIndex; vf.mNumS = face.mCount; vf.mBeginT = 0; @@ -1788,7 +1804,7 @@ void LLVolume::createVolumeFaces() vf.mID = i; // Set the type mask bits correctly - if (mProfilep->isHollow()) + if (mParams.getProfileParams().getHollow() > 0) { vf.mTypeMask |= LLVolumeFace::HOLLOW_MASK; } @@ -1835,9 +1851,10 @@ void LLVolume::createVolumeFaces() } } - for (i = 0; i < mNumVolumeFaces; i++) + for (face_list_t::iterator iter = mVolumeFaces.begin(); + iter != mVolumeFaces.end(); ++iter) { - mVolumeFaces[i].create(partial_build); + (*iter).create(this, partial_build); } } } @@ -1929,6 +1946,8 @@ F32 LLVolume::sculptGetSurfaceArea(U16 sculpt_width, U16 sculpt_height, S8 sculp // create placeholder shape void LLVolume::sculptGeneratePlaceholder() { + LLMemType m1(LLMemType::MTYPE_VOLUME); + S32 sizeS = mPathp->mPath.size(); S32 sizeT = mProfilep->mProfile.size(); @@ -1960,6 +1979,8 @@ void LLVolume::sculptGeneratePlaceholder() // create the vertices from the map void LLVolume::sculptGenerateMapVertices(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, const U8* sculpt_data, U8 sculpt_type) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + S32 sizeS = mPathp->mPath.size(); S32 sizeT = mProfilep->mProfile.size(); @@ -2029,18 +2050,19 @@ void LLVolume::sculptGenerateMapVertices(U16 sculpt_width, U16 sculpt_height, S8 // sculpt replaces generate() for sculpted surfaces void LLVolume::sculpt(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, const U8* sculpt_data, S32 sculpt_level) { + LLMemType m1(LLMemType::MTYPE_VOLUME); U8 sculpt_type = mParams.getSculptType(); BOOL data_is_empty = FALSE; - if (sculpt_width == 0 || sculpt_height == 0 || sculpt_components == 0 || sculpt_data == NULL) + if (sculpt_width == 0 || sculpt_height == 0 || sculpt_components < 3 || sculpt_data == NULL) { sculpt_level = -1; data_is_empty = TRUE; } - mPathp->generate(mDetail, 0, TRUE); - mProfilep->generate(mPathp->isOpen(), mDetail, 0, TRUE); + mPathp->generate(mParams.getPathParams(), mDetail, 0, TRUE); + mProfilep->generate(mParams.getProfileParams(), mPathp->isOpen(), mDetail, 0, TRUE); S32 sizeS = mPathp->mPath.size(); S32 sizeT = mProfilep->mProfile.size(); @@ -2055,7 +2077,7 @@ void LLVolume::sculpt(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, mMesh.resize(sizeS * sizeT); sNumMeshPoints += mMesh.size(); - if (sculptGetSurfaceArea(sculpt_width, sculpt_height, sculpt_components, sculpt_data) < SCULPT_MIN_AREA) + if (!data_is_empty && sculptGetSurfaceArea(sculpt_width, sculpt_height, sculpt_components, sculpt_data) < SCULPT_MIN_AREA) data_is_empty = TRUE; //generate vertex positions @@ -2076,11 +2098,7 @@ void LLVolume::sculpt(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, mSculptLevel = sculpt_level; // Delete any existing faces so that they get regenerated - if (mVolumeFaces) - { - delete[] mVolumeFaces; - mVolumeFaces = NULL; - } + mVolumeFaces.clear(); createVolumeFaces(); } @@ -2140,6 +2158,7 @@ bool LLVolumeParams::operator<(const LLVolumeParams ¶ms) const void LLVolumeParams::copyParams(const LLVolumeParams ¶ms) { + LLMemType m1(LLMemType::MTYPE_VOLUME); mProfileParams.copyParams(params.mProfileParams); mPathParams.copyParams(params.mPathParams); mSculptID = params.getSculptID(); @@ -2511,6 +2530,8 @@ bool LLVolumeParams::validate(U8 prof_curve, F32 prof_begin, F32 prof_end, F32 h S32 *LLVolume::getTriangleIndices(U32 &num_indices) const { + LLMemType m1(LLMemType::MTYPE_VOLUME); + S32 expected_num_triangle_indices = getNumTriangleIndices(); if (expected_num_triangle_indices > MAX_VOLUME_TRIANGLE_INDICES) { @@ -2527,7 +2548,7 @@ S32 *LLVolume::getTriangleIndices(U32 &num_indices) const // Counter-clockwise triangles are forward facing... BOOL open = getProfile().isOpen(); - BOOL hollow = getProfile().isHollow(); + BOOL hollow = (mParams.getProfileParams().getHollow() > 0); BOOL path_open = getPath().isOpen(); S32 size_s, size_s_out, size_t; S32 s, t, i; @@ -3133,7 +3154,7 @@ S32 *LLVolume::getTriangleIndices(U32 &num_indices) const S32 LLVolume::getNumTriangleIndices() const { BOOL profile_open = getProfile().isOpen(); - BOOL hollow = getProfile().isHollow(); + BOOL hollow = (mParams.getProfileParams().getHollow() > 0); BOOL path_open = getPath().isOpen(); S32 size_s, size_s_out, size_t; @@ -3197,13 +3218,17 @@ void LLVolume::generateSilhouetteVertices(std::vector<LLVector3> &vertices, const LLMatrix4& mat, const LLMatrix3& norm_mat) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + vertices.clear(); normals.clear(); segments.clear(); //for each face - for (S32 i = 0; i < getNumVolumeFaces(); i++) { - LLVolumeFace face = this->getVolumeFace(i); + for (face_list_t::iterator iter = mVolumeFaces.begin(); + iter != mVolumeFaces.end(); ++iter) + { + const LLVolumeFace& face = *iter; if (face.mTypeMask & (LLVolumeFace::CAP_MASK)) { @@ -3386,9 +3411,9 @@ S32 LLVolume::lineSegmentIntersect(const LLVector3& start, LLVector3& end) const LLVector3 vec = end - start; - for (U32 i = 0; i < (U32)getNumFaces(); i++) + for (S32 i = 0; i < getNumFaces(); i++) { - LLVolumeFace face = getVolumeFace(i); + const LLVolumeFace& face = getVolumeFace(i); for (U32 j = 0; j < face.mIndices.size()/3; j++) { @@ -3531,6 +3556,8 @@ BOOL LLVolume::cleanupTriangleData( const S32 num_input_vertices, S32 &num_output_triangles, S32 **output_triangles) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + /* Testing: avoid any cleanup static BOOL skip_cleanup = TRUE; if ( skip_cleanup ) @@ -3752,6 +3779,8 @@ BOOL LLVolume::cleanupTriangleData( const S32 num_input_vertices, BOOL LLVolumeParams::importFile(FILE *fp) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + //llinfos << "importing volume" << llendl; const S32 BUFSIZE = 16384; char buffer[BUFSIZE]; /* Flawfinder: ignore */ @@ -3806,6 +3835,8 @@ BOOL LLVolumeParams::exportFile(FILE *fp) const BOOL LLVolumeParams::importLegacyStream(std::istream& input_stream) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + //llinfos << "importing volume" << llendl; const S32 BUFSIZE = 16384; // *NOTE: changing the size or type of this buffer will require @@ -3845,6 +3876,8 @@ BOOL LLVolumeParams::importLegacyStream(std::istream& input_stream) BOOL LLVolumeParams::exportLegacyStream(std::ostream& output_stream) const { + LLMemType m1(LLMemType::MTYPE_VOLUME); + output_stream <<"\tshape 0\n"; output_stream <<"\t{\n"; mPathParams.exportLegacyStream(output_stream); @@ -3998,7 +4031,7 @@ LLFaceID LLVolume::generateFaceMask() { LLFaceID new_mask = 0x0000; - switch(mProfilep->mParams.getCurveType() & LL_PCODE_PROFILE_MASK) + switch(mParams.getProfileParams().getCurveType() & LL_PCODE_PROFILE_MASK) { case LL_PCODE_PROFILE_CIRCLE: case LL_PCODE_PROFILE_CIRCLE_HALF: @@ -4006,7 +4039,7 @@ LLFaceID LLVolume::generateFaceMask() break; case LL_PCODE_PROFILE_SQUARE: { - for(S32 side = (S32)(mProfilep->mParams.getBegin() * 4.f); side < llceil(mProfilep->mParams.getEnd() * 4.f); side++) + for(S32 side = (S32)(mParams.getProfileParams().getBegin() * 4.f); side < llceil(mParams.getProfileParams().getEnd() * 4.f); side++) { new_mask |= LL_FACE_OUTER_SIDE_0 << side; } @@ -4016,7 +4049,7 @@ LLFaceID LLVolume::generateFaceMask() case LL_PCODE_PROFILE_EQUALTRI: case LL_PCODE_PROFILE_RIGHTTRI: { - for(S32 side = (S32)(mProfilep->mParams.getBegin() * 3.f); side < llceil(mProfilep->mParams.getEnd() * 3.f); side++) + for(S32 side = (S32)(mParams.getProfileParams().getBegin() * 3.f); side < llceil(mParams.getProfileParams().getEnd() * 3.f); side++) { new_mask |= LL_FACE_OUTER_SIDE_0 << side; } @@ -4028,7 +4061,7 @@ LLFaceID LLVolume::generateFaceMask() } // handle hollow objects - if (mProfilep->isHollow()) + if (mParams.getProfileParams().getHollow() > 0) { new_mask |= LL_FACE_INNER_SIDE; } @@ -4130,7 +4163,7 @@ std::ostream& operator<<(std::ostream &s, const LLPath &path) std::ostream& operator<<(std::ostream &s, const LLVolume &volume) { - s << "{params = " << volume.mParams; + s << "{params = " << volume.getParams(); s << ", path = " << *volume.mPathp; s << ", profile = " << *volume.mProfilep; s << "}"; @@ -4140,7 +4173,7 @@ std::ostream& operator<<(std::ostream &s, const LLVolume &volume) std::ostream& operator<<(std::ostream &s, const LLVolume *volumep) { - s << "{params = " << volumep->mParams; + s << "{params = " << volumep->getParams(); s << ", path = " << *(volumep->mPathp); s << ", profile = " << *(volumep->mProfilep); s << "}"; @@ -4160,15 +4193,15 @@ LLVolumeFace::LLVolumeFace() } -BOOL LLVolumeFace::create(BOOL partial_build) +BOOL LLVolumeFace::create(LLVolume* volume, BOOL partial_build) { if (mTypeMask & CAP_MASK) { - return createCap(partial_build); + return createCap(volume, partial_build); } else if ((mTypeMask & END_MASK) || (mTypeMask & SIDE_MASK)) { - return createSide(partial_build); + return createSide(volume, partial_build); } else { @@ -4190,12 +4223,14 @@ void LerpPlanarVertex(LLVolumeFace::VertexData& v0, vout.mBinormal = v0.mBinormal; } -BOOL LLVolumeFace::createUnCutCubeCap(BOOL partial_build) +BOOL LLVolumeFace::createUnCutCubeCap(LLVolume* volume, BOOL partial_build) { - const std::vector<LLVolume::Point>& mesh = mVolumep->getMesh(); - const std::vector<LLVector3>& profile = mVolumep->getProfile().mProfile; - S32 max_s = mVolumep->getProfile().getTotal(); - S32 max_t = mVolumep->getPath().mPath.size(); + LLMemType m1(LLMemType::MTYPE_VOLUME); + + const std::vector<LLVolume::Point>& mesh = volume->getMesh(); + const std::vector<LLVector3>& profile = volume->getProfile().mProfile; + S32 max_s = volume->getProfile().getTotal(); + S32 max_t = volume->getPath().mPath.size(); // S32 i; S32 num_vertices = 0, num_indices = 0; @@ -4296,23 +4331,24 @@ BOOL LLVolumeFace::createUnCutCubeCap(BOOL partial_build) } -BOOL LLVolumeFace::createCap(BOOL partial_build) +BOOL LLVolumeFace::createCap(LLVolume* volume, BOOL partial_build) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + if (!(mTypeMask & HOLLOW_MASK) && !(mTypeMask & OPEN_MASK) && - ((this->mVolumep->getParams().getPathParams().getBegin()==0.0f)&& - (this->mVolumep->getParams().getPathParams().getEnd()==1.0f))&& - (mVolumep->getProfile().mParams.getCurveType()==LL_PCODE_PROFILE_SQUARE && - mVolumep->getPath().mParams.getCurveType()==LL_PCODE_PATH_LINE) + ((volume->getParams().getPathParams().getBegin()==0.0f)&& + (volume->getParams().getPathParams().getEnd()==1.0f))&& + (volume->getParams().getProfileParams().getCurveType()==LL_PCODE_PROFILE_SQUARE && + volume->getParams().getPathParams().getCurveType()==LL_PCODE_PATH_LINE) ){ - return createUnCutCubeCap(partial_build); + return createUnCutCubeCap(volume, partial_build); } - S32 i; S32 num_vertices = 0, num_indices = 0; - const std::vector<LLVolume::Point>& mesh = mVolumep->getMesh(); - const std::vector<LLVector3>& profile = mVolumep->getProfile().mProfile; + const std::vector<LLVolume::Point>& mesh = volume->getMesh(); + const std::vector<LLVector3>& profile = volume->getProfile().mProfile; // All types of caps have the same number of vertices and indices num_vertices = profile.size(); @@ -4325,8 +4361,8 @@ BOOL LLVolumeFace::createCap(BOOL partial_build) mIndices.resize(num_indices); } - S32 max_s = mVolumep->getProfile().getTotal(); - S32 max_t = mVolumep->getPath().mPath.size(); + S32 max_s = volume->getProfile().getTotal(); + S32 max_t = volume->getPath().mPath.size(); mCenter.clearVec(); @@ -4350,7 +4386,7 @@ BOOL LLVolumeFace::createCap(BOOL partial_build) LLVector3& max = mExtents[1]; // Copy the vertices into the array - for (i = 0; i < num_vertices; i++) + for (S32 i = 0; i < num_vertices; i++) { if (mTypeMask & TOP_MASK) { @@ -4414,7 +4450,7 @@ BOOL LLVolumeFace::createCap(BOOL partial_build) } - for (i = 0; i < num_vertices; i++) + for (S32 i = 0; i < num_vertices; i++) { mVertices[i].mBinormal = binormal; mVertices[i].mNormal = normal; @@ -4435,7 +4471,7 @@ BOOL LLVolumeFace::createCap(BOOL partial_build) // Does it matter if it's open or closed? - djs S32 pt1 = 0, pt2 = num_vertices - 1; - i = 0; + S32 i = 0; while (pt2 - pt1 > 1) { // Use the profile points instead of the mesh, since you want @@ -4538,7 +4574,7 @@ BOOL LLVolumeFace::createCap(BOOL partial_build) llassert(mTypeMask & BOTTOM_MASK); S32 pt1 = 0, pt2 = num_vertices - 1; - i = 0; + S32 i = 0; while (pt2 - pt1 > 1) { // Use the profile points instead of the mesh, since you want @@ -4645,7 +4681,7 @@ BOOL LLVolumeFace::createCap(BOOL partial_build) // SOLID OPEN TOP // Generate indices // This is a tri-fan, so we reuse the same first point for all triangles. - for (i = 0; i < (num_vertices - 2); i++) + for (S32 i = 0; i < (num_vertices - 2); i++) { mIndices[3*i] = num_vertices - 1; mIndices[3*i+1] = i; @@ -4655,7 +4691,7 @@ BOOL LLVolumeFace::createCap(BOOL partial_build) else { // SOLID CLOSED TOP - for (i = 0; i < (num_vertices - 2); i++) + for (S32 i = 0; i < (num_vertices - 2); i++) { //MSMSM fix these caps but only for the un-cut case mIndices[3*i] = num_vertices - 1; @@ -4671,7 +4707,7 @@ BOOL LLVolumeFace::createCap(BOOL partial_build) // SOLID OPEN BOTTOM // Generate indices // This is a tri-fan, so we reuse the same first point for all triangles. - for (i = 0; i < (num_vertices - 2); i++) + for (S32 i = 0; i < (num_vertices - 2); i++) { mIndices[3*i] = num_vertices - 1; mIndices[3*i+1] = i + 1; @@ -4681,7 +4717,7 @@ BOOL LLVolumeFace::createCap(BOOL partial_build) else { // SOLID CLOSED BOTTOM - for (i = 0; i < (num_vertices - 2); i++) + for (S32 i = 0; i < (num_vertices - 2); i++) { //MSMSM fix these caps but only for the un-cut case mIndices[3*i] = num_vertices - 1; @@ -4696,6 +4732,8 @@ BOOL LLVolumeFace::createCap(BOOL partial_build) void LLVolumeFace::createBinormals() { + LLMemType m1(LLMemType::MTYPE_VOLUME); + if (!mHasBinormals) { //generate binormals @@ -4737,16 +4775,18 @@ void LLVolumeFace::createBinormals() } } -BOOL LLVolumeFace::createSide(BOOL partial_build) +BOOL LLVolumeFace::createSide(LLVolume* volume, BOOL partial_build) { + LLMemType m1(LLMemType::MTYPE_VOLUME); + BOOL flat = mTypeMask & FLAT_MASK; S32 num_vertices, num_indices; - const std::vector<LLVolume::Point>& mesh = mVolumep->getMesh(); - const std::vector<LLVector3>& profile = mVolumep->getProfile().mProfile; - const std::vector<LLPath::PathPt>& path_data = mVolumep->getPath().mPath; + const std::vector<LLVolume::Point>& mesh = volume->getMesh(); + const std::vector<LLVector3>& profile = volume->getProfile().mProfile; + const std::vector<LLPath::PathPt>& path_data = volume->getPath().mPath; - S32 max_s = mVolumep->getProfile().getTotal(); + S32 max_s = volume->getProfile().getTotal(); S32 s, t, i; F32 ss, tt; @@ -4889,7 +4929,7 @@ BOOL LLVolumeFace::createSide(BOOL partial_build) if (t < mNumT-2) { //top right/top left neighbor face mEdge[cur_edge++] = (mNumS-1)*2*(t+1)+s*2+1; } - else if (mNumT <= 3 || mVolumep->getPath().isOpen() == TRUE) { //no neighbor + else if (mNumT <= 3 || volume->getPath().isOpen() == TRUE) { //no neighbor mEdge[cur_edge++] = -1; } else { //wrap on T @@ -4898,7 +4938,7 @@ BOOL LLVolumeFace::createSide(BOOL partial_build) if (s > 0) { //top left/bottom left neighbor face mEdge[cur_edge++] = (mNumS-1)*2*t+s*2-1; } - else if (flat_face || mVolumep->getProfile().isOpen() == TRUE) { //no neighbor + else if (flat_face || volume->getProfile().isOpen() == TRUE) { //no neighbor mEdge[cur_edge++] = -1; } else { //wrap on S @@ -4908,7 +4948,7 @@ BOOL LLVolumeFace::createSide(BOOL partial_build) if (t > 0) { //bottom left/bottom right neighbor face mEdge[cur_edge++] = (mNumS-1)*2*(t-1)+s*2; } - else if (mNumT <= 3 || mVolumep->getPath().isOpen() == TRUE) { //no neighbor + else if (mNumT <= 3 || volume->getPath().isOpen() == TRUE) { //no neighbor mEdge[cur_edge++] = -1; } else { //wrap on T @@ -4917,7 +4957,7 @@ BOOL LLVolumeFace::createSide(BOOL partial_build) if (s < mNumS-2) { //bottom right/top right neighbor face mEdge[cur_edge++] = (mNumS-1)*2*t+(s+1)*2; } - else if (flat_face || mVolumep->getProfile().isOpen() == TRUE) { //no neighbor + else if (flat_face || volume->getProfile().isOpen() == TRUE) { //no neighbor mEdge[cur_edge++] = -1; } else { //wrap on S @@ -4962,11 +5002,11 @@ BOOL LLVolumeFace::createSide(BOOL partial_build) BOOL s_bottom_converges = ((mVertices[0].mPosition - mVertices[mNumS*(mNumT-2)].mPosition).magVecSquared() < 0.000001f); BOOL s_top_converges = ((mVertices[mNumS-1].mPosition - mVertices[mNumS*(mNumT-2)+mNumS-1].mPosition).magVecSquared() < 0.000001f); - U8 sculpt_type = mVolumep->getParams().getSculptType(); + U8 sculpt_type = volume->getParams().getSculptType(); if (sculpt_type == LL_SCULPT_TYPE_NONE) // logic for non-sculpt volumes { - if (mVolumep->getPath().isOpen() == FALSE) + if (volume->getPath().isOpen() == FALSE) { //wrap normals on T for (S32 i = 0; i < mNumS; i++) { @@ -4976,7 +5016,7 @@ BOOL LLVolumeFace::createSide(BOOL partial_build) } } - if ((mVolumep->getProfile().isOpen() == FALSE) && !(s_bottom_converges)) + if ((volume->getProfile().isOpen() == FALSE) && !(s_bottom_converges)) { //wrap normals on S for (S32 i = 0; i < mNumT; i++) { @@ -4986,8 +5026,8 @@ BOOL LLVolumeFace::createSide(BOOL partial_build) } } - if (mVolumep->getPathType() == LL_PCODE_PATH_CIRCLE && - ((mVolumep->getProfileType() & LL_PCODE_PROFILE_MASK) == LL_PCODE_PROFILE_CIRCLE_HALF)) + if (volume->getPathType() == LL_PCODE_PATH_CIRCLE && + ((volume->getProfileType() & LL_PCODE_PROFILE_MASK) == LL_PCODE_PROFILE_CIRCLE_HALF)) { if (s_bottom_converges) { //all lower S have same normal @@ -5086,69 +5126,6 @@ BOOL LLVolumeFace::createSide(BOOL partial_build) return TRUE; } -// Static -BOOL LLVolumeFace::updateColors(LLColor4U *old_colors, const S32 num_old, const LLVolumeFace &old_vf, - LLStrider<LLColor4U> &new_colors, const S32 num_new, const LLVolumeFace &new_vf) -{ - if (new_vf.mTypeMask & CAP_MASK) - { - // These aren't interpolated correctly. Need to fix when shadows go in... - F32 ratio = (F32)num_old / (F32)num_new; - S32 v = 0; - for (v = 0; v < num_new; v++) - { - new_colors[v] = old_colors[(S32)(v*ratio)]; - } - return FALSE; - } - else if (new_vf.mTypeMask & END_MASK) - { - // These aren't interpolated correctly. Need to fix when shadows go in... - F32 ratio = (F32)num_old / (F32)num_new; - S32 v = 0; - for (v = 0; v < num_new; v++) - { - new_colors[v] = old_colors[(S32)(v*ratio)]; - } - return FALSE; - } - else if (new_vf.mTypeMask & SIDE_MASK) - { - S32 s, t; - F32 s_ratio = (F32)old_vf.mNumS / (F32)new_vf.mNumS; - F32 t_ratio = (F32)old_vf.mNumT / (F32)new_vf.mNumT; - - S32 v = 0; - for (t = 0; t < new_vf.mNumT; t++) - { - F32 t_frac = t * t_ratio; - S32 old_t = (S32)t_frac; - S32 t_target = llmin(old_t + 1, (old_vf.mNumT - 1)); - t_frac -= old_t; - for (s = 0; s < new_vf.mNumS; s++) - { - F32 s_frac = s * s_ratio; - S32 old_s = (S32)s_frac; - S32 s_target = llmin(old_s + 1, (old_vf.mNumS - 1)); - s_frac -= old_s; - - // Interpolate along s, then along t. - LLColor4U s_interp0 = old_colors[old_t * old_vf.mNumS + old_s].multAll(1.f - s_frac).addClampMax(old_colors[old_t * old_vf.mNumS + s_target].multAll(s_frac)); - LLColor4U s_interp1 = old_colors[t_target * old_vf.mNumS + old_s].multAll(1.f - s_frac).addClampMax(old_colors[t_target * old_vf.mNumS + s_target].multAll(s_frac)); - new_colors[v] = s_interp0.multAll(1.f - t_frac).addClampMax(s_interp1.multAll(t_frac)); - v++; - } - } - } - else - { - llerrs << "Unknown/uninitialized face type!" << llendl; - return FALSE; - } - return TRUE; -} - - // Finds binormal based on three vertices with texture coordinates. // Fills in dummy values if the triangle has degenerate texture coordinates. LLVector3 calc_binormal_from_triangle( diff --git a/indra/llmath/llvolume.h b/indra/llmath/llvolume.h index a1eba9de38..11a7c2f1c6 100644 --- a/indra/llmath/llvolume.h +++ b/indra/llmath/llvolume.h @@ -643,9 +643,8 @@ protected: class LLProfile { public: - LLProfile(const LLProfileParams ¶ms) - : mParams(params), - mOpen(FALSE), + LLProfile() + : mOpen(FALSE), mConcave(FALSE), mDirty(TRUE), mTotalOut(0), @@ -657,15 +656,12 @@ public: S32 getTotal() const { return mTotal; } S32 getTotalOut() const { return mTotalOut; } // Total number of outside points - BOOL isHollow() const { return (mParams.getHollow() > 0); } BOOL isFlat(S32 face) const { return (mFaces[face].mCount == 2); } BOOL isOpen() const { return mOpen; } void setDirty() { mDirty = TRUE; } - BOOL generate(BOOL path_open, F32 detail = 1.0f, S32 split = 0, BOOL is_sculpted = FALSE); + BOOL generate(const LLProfileParams& params, BOOL path_open, F32 detail = 1.0f, S32 split = 0, BOOL is_sculpted = FALSE); BOOL isConcave() const { return mConcave; } public: - const LLProfileParams &mParams; - struct Face { S32 mIndex; @@ -687,10 +683,10 @@ public: friend std::ostream& operator<<(std::ostream &s, const LLProfile &profile); protected: - void genNormals(); - void genNGon(S32 sides, F32 offset=0.0f, F32 bevel = 0.0f, F32 ang_scale = 1.f, S32 split = 0); + void genNormals(const LLProfileParams& params); + void genNGon(const LLProfileParams& params, S32 sides, F32 offset=0.0f, F32 bevel = 0.0f, F32 ang_scale = 1.f, S32 split = 0); - Face* addHole(BOOL flat, F32 sides, F32 offset, F32 box_hollow, F32 ang_scale, S32 split = 0); + Face* addHole(const LLProfileParams& params, BOOL flat, F32 sides, F32 offset, F32 box_hollow, F32 ang_scale, S32 split = 0); Face* addCap (S16 faceID); Face* addFace(S32 index, S32 count, F32 scaleU, S16 faceID, BOOL flat); @@ -720,9 +716,8 @@ public: }; public: - LLPath(const LLPathParams ¶ms) - : mParams(params), - mOpen(FALSE), + LLPath() + : mOpen(FALSE), mTotal(0), mDirty(TRUE), mStep(1) @@ -731,8 +726,8 @@ public: virtual ~LLPath(); - void genNGon(S32 sides, F32 offset=0.0f, F32 end_scale = 1.f, F32 twist_scale = 1.f); - virtual BOOL generate(F32 detail=1.0f, S32 split = 0, BOOL is_sculpted = FALSE); + void genNGon(const LLPathParams& params, S32 sides, F32 offset=0.0f, F32 end_scale = 1.f, F32 twist_scale = 1.f); + virtual BOOL generate(const LLPathParams& params, F32 detail=1.0f, S32 split = 0, BOOL is_sculpted = FALSE); BOOL isOpen() const { return mOpen; } F32 getStep() const { return mStep; } @@ -745,7 +740,6 @@ public: friend std::ostream& operator<<(std::ostream &s, const LLPath &path); public: - const LLPathParams &mParams; std::vector<PathPt> mPath; protected: @@ -758,8 +752,8 @@ protected: class LLDynamicPath : public LLPath { public: - LLDynamicPath(const LLPathParams ¶ms) : LLPath(params) { } - BOOL generate(F32 detail=1.0f, S32 split = 0, BOOL is_sculpted = FALSE); + LLDynamicPath() : LLPath() { } + /*virtual*/ BOOL generate(const LLPathParams& params, F32 detail=1.0f, S32 split = 0, BOOL is_sculpted = FALSE); }; // Yet another "face" class - caches volume-specific, but not instance-specific data for faces) @@ -767,7 +761,7 @@ class LLVolumeFace { public: LLVolumeFace(); - BOOL create(BOOL partial_build = FALSE); + BOOL create(LLVolume* volume, BOOL partial_build = FALSE); void createBinormals(); class VertexData @@ -811,16 +805,11 @@ public: std::vector<VertexData> mVertices; std::vector<U16> mIndices; std::vector<S32> mEdge; - LLVolume *mVolumep; // Deliberately NOT reference counted - djs 11/20/03 - otherwise would make an annoying circular reference - // Shouldn't need num_old and num_new, really - djs - static BOOL updateColors(LLColor4U *old_colors, const S32 num_old, const LLVolumeFace &old_face, - LLStrider<LLColor4U> &new_colors, const S32 num_new, const LLVolumeFace &new_face); - -protected: - BOOL createUnCutCubeCap(BOOL partial_build = FALSE); - BOOL createCap(BOOL partial_build = FALSE); - BOOL createSide(BOOL partial_build = FALSE); +private: + BOOL createUnCutCubeCap(LLVolume* volume, BOOL partial_build = FALSE); + BOOL createCap(LLVolume* volume, BOOL partial_build = FALSE); + BOOL createSide(LLVolume* volume, BOOL partial_build = FALSE); }; class LLVolume : public LLRefCount @@ -848,12 +837,12 @@ public: LLVolume(const LLVolumeParams ¶ms, const F32 detail, const BOOL generate_single_face = FALSE, const BOOL is_unique = FALSE); - U8 getProfileType() const { return mProfilep->mParams.getCurveType(); } - U8 getPathType() const { return mPathp->mParams.getCurveType(); } + U8 getProfileType() const { return mParams.getProfileParams().getCurveType(); } + U8 getPathType() const { return mParams.getPathParams().getCurveType(); } S32 getNumFaces() const { return (S32)mProfilep->mFaces.size(); } - S32 getNumVolumeFaces() const { return mNumVolumeFaces; } - F32 getDetail() const { return mDetail; } - const LLVolumeParams & getParams() const { return mParams; } + S32 getNumVolumeFaces() const { return mVolumeFaces.size(); } + F32 getDetail() const { return mDetail; } + const LLVolumeParams& getParams() const { return mParams; } LLVolumeParams getCopyOfParams() const { return mParams; } const LLProfile& getProfile() const { return *mProfilep; } LLPath& getPath() const { return *mPathp; } @@ -932,8 +921,8 @@ protected: std::vector<Point> mMesh; BOOL mGenerateSingleFace; - S32 mNumVolumeFaces; - LLVolumeFace *mVolumeFaces; + typedef std::vector<LLVolumeFace> face_list_t; + face_list_t mVolumeFaces; }; std::ostream& operator<<(std::ostream &s, const LLVolumeParams &volume_params); diff --git a/indra/llmath/llvolumemgr.cpp b/indra/llmath/llvolumemgr.cpp index f3a6b7d157..23ed0183b8 100644 --- a/indra/llmath/llvolumemgr.cpp +++ b/indra/llmath/llvolumemgr.cpp @@ -31,13 +31,10 @@ #include "linden_common.h" #include "llvolumemgr.h" +#include "llmemtype.h" #include "llvolume.h" -//#define DEBUG_VOLUME - -//LLVolumeMgr* gVolumeMgr = 0; - const F32 BASE_THRESHOLD = 0.03f; //static @@ -70,11 +67,6 @@ LLVolumeMgr::~LLVolumeMgr() BOOL LLVolumeMgr::cleanup() { - #ifdef DEBUG_VOLUME - { - lldebugs << "LLVolumeMgr::cleanup()" << llendl; - } - #endif BOOL no_refs = TRUE; if (mDataMutex) { @@ -85,14 +77,11 @@ BOOL LLVolumeMgr::cleanup() iter != end; iter++) { LLVolumeLODGroup *volgroupp = iter->second; - if (volgroupp->getNumRefs() != 1) + if (volgroupp->cleanupRefs() == false) { - llwarns << "Volume group " << volgroupp << " has " - << volgroupp->getNumRefs() << " remaining refs" << llendl; - llwarns << volgroupp->getParams() << llendl; no_refs = FALSE; } - volgroupp->unref();// this ); + delete volgroupp; } mVolumeLODGroups.clear(); if (mDataMutex) @@ -102,10 +91,11 @@ BOOL LLVolumeMgr::cleanup() return no_refs; } -// whatever calls getVolume() never owns the LLVolume* and -// cannot keep references for long since it may be deleted -// later. For best results hold it in an LLPointer<LLVolume>. -LLVolume *LLVolumeMgr::getVolume(const LLVolumeParams &volume_params, const S32 detail) +// Always only ever store the results of refVolume in a LLPointer +// Note however that LLVolumeLODGroup that contains the volume +// also holds a LLPointer so the volume will only go away after +// anything holding the volume and the LODGroup are destroyed +LLVolume* LLVolumeMgr::refVolume(const LLVolumeParams &volume_params, const S32 detail) { LLVolumeLODGroup* volgroupp; if (mDataMutex) @@ -121,17 +111,11 @@ LLVolume *LLVolumeMgr::getVolume(const LLVolumeParams &volume_params, const S32 { volgroupp = iter->second; } - volgroupp->ref(); if (mDataMutex) { mDataMutex->unlock(); } - #ifdef DEBUG_VOLUME - { - lldebugs << "LLVolumeMgr::getVolume() " << (*this) << llendl; - } - #endif - return volgroupp->getLOD(detail); + return volgroupp->getLODVolume(detail); } // virtual @@ -154,15 +138,14 @@ LLVolumeLODGroup* LLVolumeMgr::getGroup( const LLVolumeParams& volume_params ) c return volgroupp; } -// virtual -void LLVolumeMgr::cleanupVolume(LLVolume *volumep) +void LLVolumeMgr::unrefVolume(LLVolume *volumep) { if (volumep->isUnique()) { // TomY: Don't need to manage this volume. It is a unique instance. return; } - LLVolumeParams* params = (LLVolumeParams*) &(volumep->getParams()); + const LLVolumeParams* params = &(volumep->getParams()); if (mDataMutex) { mDataMutex->lock(); @@ -182,11 +165,10 @@ void LLVolumeMgr::cleanupVolume(LLVolume *volumep) LLVolumeLODGroup* volgroupp = iter->second; volgroupp->derefLOD(volumep); - volgroupp->unref();// this ); - if (volgroupp->getNumRefs() == 1) + if (volgroupp->getNumRefs() == 0) { mVolumeLODGroups.erase(params); - volgroupp->unref();// this ); + delete volgroupp; } } if (mDataMutex) @@ -194,40 +176,21 @@ void LLVolumeMgr::cleanupVolume(LLVolume *volumep) mDataMutex->unlock(); } - #ifdef DEBUG_VOLUME - { - lldebugs << "LLVolumeMgr::cleanupVolume() " << (*this) << llendl; - } - #endif -} - -#ifdef DEBUG_VOLUME -S32 LLVolumeMgr::getTotalRefCount() const -{ - S32 total_ref_count = 0; - for ( volume_lod_group_map_t::const_iterator iter = mVolumeLODGroups.begin(), - end = mVolumeLODGroups.end(); - iter != end; iter++) - { - total_ref_count += iter->second->getTotalVolumeRefCount(); - } - return total_ref_count; } -S32 LLVolumeMgr::getGroupCount() const +// protected +void LLVolumeMgr::insertGroup(LLVolumeLODGroup* volgroup) { - return mVolumeLODGroups.size(); + mVolumeLODGroups[volgroup->getVolumeParams()] = volgroup; } -#endif // protected LLVolumeLODGroup* LLVolumeMgr::createNewGroup(const LLVolumeParams& volume_params) { - LLVolumeLODGroup* group = new LLVolumeLODGroup(volume_params); - const LLVolumeParams* params = &(group->getParams()); - mVolumeLODGroups[params] = group; - group->ref(); // initial reference - return group; + LLMemType m1(LLMemType::MTYPE_VOLUME); + LLVolumeLODGroup* volgroup = new LLVolumeLODGroup(volume_params); + insertGroup(volgroup); + return volgroup; } // virtual @@ -272,9 +235,8 @@ std::ostream& operator<<(std::ostream& s, const LLVolumeMgr& volume_mgr) volume_mgr.mDataMutex->lock(); } - LLVolumeMgr::volume_lod_group_map_iter iter = volume_mgr.mVolumeLODGroups.begin(); - LLVolumeMgr::volume_lod_group_map_iter end = volume_mgr.mVolumeLODGroups.end(); - for ( ; iter != end; ++iter) + for (LLVolumeMgr::volume_lod_group_map_t::const_iterator iter = volume_mgr.mVolumeLODGroups.begin(); + iter != volume_mgr.mVolumeLODGroups.end(); ++iter) { LLVolumeLODGroup *volgroupp = iter->second; total_refs += volgroupp->getNumRefs(); @@ -291,72 +253,78 @@ std::ostream& operator<<(std::ostream& s, const LLVolumeMgr& volume_mgr) } LLVolumeLODGroup::LLVolumeLODGroup(const LLVolumeParams ¶ms) + : mVolumeParams(params), + mRefs(0) { - S32 i; - mParams = params; - - for (i = 0; i < NUM_LODS; i++) + for (S32 i = 0; i < NUM_LODS; i++) { mLODRefs[i] = 0; - // no need to initialize mVolumeLODs, they are smart pointers - //mVolumeLODs[i] = NULL; mAccessCount[i] = 0; } } -#ifdef DEBUG_VOLUME -S32 LLVolumeLODGroup::getTotalVolumeRefCount() const +LLVolumeLODGroup::~LLVolumeLODGroup() { - S32 total_ref_count = 0; for (S32 i = 0; i < NUM_LODS; i++) { - total_ref_count += mLODRefs[i]; + llassert_always(mLODRefs[i] == 0); } - return total_ref_count; -} -#endif - -// protected -LLVolumeLODGroup::~LLVolumeLODGroup() -{ - destroy(); } -// protected -void LLVolumeLODGroup::destroy() +// Called from LLVolumeMgr::cleanup +bool LLVolumeLODGroup::cleanupRefs() { - for (S32 i = 0; i < NUM_LODS; i++) + bool res = true; + if (mRefs != 0) { - // remember that mVolumeLODs are smart pointers! - mVolumeLODs[i] = NULL; + llwarns << "Volume group has remaining refs:" << getNumRefs() << llendl; + mRefs = 0; + for (S32 i = 0; i < NUM_LODS; i++) + { + if (mLODRefs[i] > 0) + { + llwarns << " LOD " << i << " refs = " << mLODRefs[i] << llendl; + mLODRefs[i] = 0; + mVolumeLODs[i] = NULL; + } + } + llwarns << *getVolumeParams() << llendl; + res = false; } + return res; } -LLVolume * LLVolumeLODGroup::getLOD(const S32 detail) +LLVolume* LLVolumeLODGroup::getLODVolume(const S32 detail) { llassert(detail >=0 && detail < NUM_LODS); mAccessCount[detail]++; - if (!mLODRefs[detail]) + mRefs++; + if (mVolumeLODs[detail].isNull()) { - mVolumeLODs[detail] = new LLVolume(mParams, mDetailScales[detail]); + LLMemType m1(LLMemType::MTYPE_VOLUME); + mVolumeLODs[detail] = new LLVolume(mVolumeParams, mDetailScales[detail]); } mLODRefs[detail]++; - return mVolumeLODs[detail].get(); + return mVolumeLODs[detail]; } BOOL LLVolumeLODGroup::derefLOD(LLVolume *volumep) { - S32 i; - for (i = 0; i < NUM_LODS; i++) + llassert_always(mRefs > 0); + mRefs--; + for (S32 i = 0; i < NUM_LODS; i++) { if (mVolumeLODs[i] == volumep) { + llassert_always(mLODRefs[i] > 0); mLODRefs[i]--; +#if 1 // SJB: Possible opt: keep other lods around if (!mLODRefs[i]) { mVolumeLODs[i] = NULL; } +#endif return TRUE; } } @@ -428,7 +396,7 @@ F32 LLVolumeLODGroup::dump() std::ostream& operator<<(std::ostream& s, const LLVolumeLODGroup& volgroup) { s << "{ numRefs=" << volgroup.getNumRefs(); - s << ", mParams=" << volgroup.mParams; + s << ", mParams=" << volgroup.getVolumeParams(); s << " }"; return s; diff --git a/indra/llmath/llvolumemgr.h b/indra/llmath/llvolumemgr.h index c28ffce631..fac194165b 100644 --- a/indra/llmath/llvolumemgr.h +++ b/indra/llmath/llvolumemgr.h @@ -41,8 +41,10 @@ class LLVolumeParams; class LLVolumeLODGroup; -class LLVolumeLODGroup : public LLThreadSafeRefCount +class LLVolumeLODGroup { + LOG_CLASS(LLVolumeLODGroup); + public: enum { @@ -50,29 +52,26 @@ public: }; LLVolumeLODGroup(const LLVolumeParams ¶ms); + ~LLVolumeLODGroup(); + bool cleanupRefs(); - BOOL derefLOD(LLVolume *volumep); static S32 getDetailFromTan(const F32 tan_angle); static void getDetailProximity(const F32 tan_angle, F32 &to_lower, F32& to_higher); static F32 getVolumeScaleFromDetail(const S32 detail); - LLVolume *getLOD(const S32 detail); - const LLVolumeParams& getParams() const { return mParams; }; + LLVolume* getLODVolume(const S32 detail); + BOOL derefLOD(LLVolume *volumep); + S32 getNumRefs() const { return mRefs; } + + const LLVolumeParams* getVolumeParams() const { return &mVolumeParams; }; F32 dump(); friend std::ostream& operator<<(std::ostream& s, const LLVolumeLODGroup& volgroup); -#ifdef DEBUG_VOLUME - S32 getTotalVolumeRefCount() const; -#endif - protected: - virtual ~LLVolumeLODGroup(); - void destroy(); - -protected: - LLVolumeParams mParams; + LLVolumeParams mVolumeParams; + S32 mRefs; S32 mLODRefs[NUM_LODS]; LLPointer<LLVolume> mVolumeLODs[NUM_LODS]; static F32 mDetailThresholds[NUM_LODS]; @@ -82,10 +81,6 @@ protected: class LLVolumeMgr { -//public: -// static void initClass(); -// static BOOL cleanupClass(); - public: LLVolumeMgr(); virtual ~LLVolumeMgr(); @@ -96,36 +91,26 @@ public: // whatever calls getVolume() never owns the LLVolume* and // cannot keep references for long since it may be deleted // later. For best results hold it in an LLPointer<LLVolume>. - LLVolume *getVolume(const LLVolumeParams &volume_params, const S32 detail); - - void cleanupVolume(LLVolume *volumep); + LLVolume *refVolume(const LLVolumeParams &volume_params, const S32 detail); + void unrefVolume(LLVolume *volumep); void dump(); // manually call this for mutex magic void useMutex(); -#ifdef DEBUG_VOLUME - S32 getTotalRefCount() const; - S32 getGroupCount() const; -#endif friend std::ostream& operator<<(std::ostream& s, const LLVolumeMgr& volume_mgr); protected: + void insertGroup(LLVolumeLODGroup* volgroup); + // Overridden in llphysics/abstract/utils/llphysicsvolumemanager.h virtual LLVolumeLODGroup* createNewGroup(const LLVolumeParams& volume_params); protected: typedef std::map<const LLVolumeParams*, LLVolumeLODGroup*, LLVolumeParams::compare> volume_lod_group_map_t; - typedef volume_lod_group_map_t::const_iterator volume_lod_group_map_iter; volume_lod_group_map_t mVolumeLODGroups; LLMutex* mDataMutex; - - // We need to be able to disable threadsafe checks to prevent - // some unit_tests from blocking on failure - bool mThreadSafe; }; -//extern LLVolumeMgr* gVolumeMgr; - #endif // LL_LLVOLUMEMGR_H diff --git a/indra/llprimitive/llprimitive.cpp b/indra/llprimitive/llprimitive.cpp index cc676f73f1..ff69cacf0f 100644 --- a/indra/llprimitive/llprimitive.cpp +++ b/indra/llprimitive/llprimitive.cpp @@ -32,6 +32,7 @@ #include "linden_common.h" #include "material_codes.h" +#include "llmemtype.h" #include "llerror.h" #include "message.h" #include "llprimitive.h" @@ -178,7 +179,7 @@ LLPrimitive::~LLPrimitive() // Cleanup handled by volume manager if (mVolumep) { - sVolumeManager->cleanupVolume(mVolumep); + sVolumeManager->unrefVolume(mVolumep); } mVolumep = NULL; } @@ -187,6 +188,7 @@ LLPrimitive::~LLPrimitive() // static LLPrimitive *LLPrimitive::createPrimitive(LLPCode p_code) { + LLMemType m1(LLMemType::MTYPE_PRIMITIVE); LLPrimitive *retval = new LLPrimitive(); if (retval) @@ -204,6 +206,7 @@ LLPrimitive *LLPrimitive::createPrimitive(LLPCode p_code) //=============================================================== void LLPrimitive::init_primitive(LLPCode p_code) { + LLMemType m1(LLMemType::MTYPE_PRIMITIVE); if (mNumTEs) { if (mTextureList) @@ -246,6 +249,7 @@ void LLPrimitive::setNumTEs(const U8 num_tes) // Right now, we don't try and preserve entries when the number of faces // changes. + LLMemType m1(LLMemType::MTYPE_PRIMITIVE); if (num_tes) { LLTextureEntry *new_tes; @@ -914,6 +918,7 @@ S32 face_index_from_id(LLFaceID face_ID, const std::vector<LLProfile::Face>& fac BOOL LLPrimitive::setVolume(const LLVolumeParams &volume_params, const S32 detail, bool unique_volume) { + LLMemType m1(LLMemType::MTYPE_VOLUME); LLVolume *volumep; if (unique_volume) { @@ -935,10 +940,10 @@ BOOL LLPrimitive::setVolume(const LLVolumeParams &volume_params, const S32 detai } } - volumep = sVolumeManager->getVolume(volume_params, detail); + volumep = sVolumeManager->refVolume(volume_params, detail); if (volumep == mVolumep) { - sVolumeManager->cleanupVolume( volumep ); // LLVolumeMgr::getVolume() creates a reference, but we don't need a second one. + sVolumeManager->unrefVolume( volumep ); // LLVolumeMgr::refVolume() creates a reference, but we don't need a second one. return TRUE; } } @@ -981,7 +986,7 @@ BOOL LLPrimitive::setVolume(const LLVolumeParams &volume_params, const S32 detai // build the new object - sVolumeManager->cleanupVolume(mVolumep); + sVolumeManager->unrefVolume(mVolumep); mVolumep = volumep; U32 new_face_mask = mVolumep->mFaceMask; diff --git a/indra/llrender/llimagegl.cpp b/indra/llrender/llimagegl.cpp index 2a8424a09b..d5ad38dff3 100644 --- a/indra/llrender/llimagegl.cpp +++ b/indra/llrender/llimagegl.cpp @@ -128,10 +128,16 @@ S32 LLImageGL::dataFormatComponents(S32 dataformat) void LLImageGL::bindExternalTexture(LLGLuint gl_name, S32 stage, LLGLenum bind_target ) { gGL.flush(); - glActiveTextureARB(GL_TEXTURE0_ARB + stage); - glClientActiveTextureARB(GL_TEXTURE0_ARB + stage); + if (stage > 0) + { + glActiveTextureARB(GL_TEXTURE0_ARB + stage); + } glBindTexture(bind_target, gl_name); sCurrentBoundTextures[stage] = gl_name; + if (stage > 0) + { + glActiveTextureARB(GL_TEXTURE0_ARB); + } } // static @@ -141,9 +147,16 @@ void LLImageGL::unbindTexture(S32 stage, LLGLenum bind_target) if (stage >= 0) { gGL.flush(); - glActiveTextureARB(GL_TEXTURE0_ARB + stage); - glClientActiveTextureARB(GL_TEXTURE0_ARB + stage); - glBindTexture(bind_target, 0); + if (stage > 0) + { + glActiveTextureARB(GL_TEXTURE0_ARB + stage); + glBindTexture(GL_TEXTURE_2D, 0); + glActiveTextureARB(GL_TEXTURE0_ARB); + } + else + { + glBindTexture(GL_TEXTURE_2D, 0); + } sCurrentBoundTextures[stage] = 0; } } @@ -151,15 +164,7 @@ void LLImageGL::unbindTexture(S32 stage, LLGLenum bind_target) // static (duplicated for speed and to avoid GL_TEXTURE_2D default argument which requires GL header dependency) void LLImageGL::unbindTexture(S32 stage) { - // LLGLSLShader can return -1 - if (stage >= 0) - { - gGL.flush(); - glActiveTextureARB(GL_TEXTURE0_ARB + stage); - glClientActiveTextureARB(GL_TEXTURE0_ARB + stage); - glBindTexture(GL_TEXTURE_2D, 0); - sCurrentBoundTextures[stage] = 0; - } + unbindTexture(stage, GL_TEXTURE_2D); } // static @@ -419,8 +424,6 @@ BOOL LLImageGL::bindTextureInternal(const S32 stage) const } - glActiveTextureARB(GL_TEXTURE0_ARB + stage); - if (sCurrentBoundTextures[stage] && sCurrentBoundTextures[stage] == mTexName) { // already set! @@ -434,10 +437,20 @@ BOOL LLImageGL::bindTextureInternal(const S32 stage) const #endif gGL.flush(); + if (stage > 0) + { + glActiveTextureARB(GL_TEXTURE0_ARB + stage); + } + glBindTexture(mBindTarget, mTexName); sCurrentBoundTextures[stage] = mTexName; sBindCount++; + if (stage > 0) + { + glActiveTextureARB(GL_TEXTURE0_ARB); + } + if (mLastBindTime != sLastFrameTime) { // we haven't accounted for this texture yet this frame @@ -451,7 +464,15 @@ BOOL LLImageGL::bindTextureInternal(const S32 stage) const else { gGL.flush(); + if (stage > 0) + { + glActiveTextureARB(GL_TEXTURE0_ARB+stage); + } glBindTexture(mBindTarget, 0); + if (stage > 0) + { + glActiveTextureARB(GL_TEXTURE0_ARB+stage); + } sCurrentBoundTextures[stage] = 0; return FALSE; } @@ -594,18 +615,25 @@ void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips) S32 w = width, h = height; const U8* prev_mip_data = 0; const U8* cur_mip_data = 0; + S32 prev_mip_size = 0; + S32 cur_mip_size = 0; for (int m=0; m<nummips; m++) { if (m==0) { cur_mip_data = data_in; + cur_mip_size = width * height * mComponents; } else { S32 bytes = w * h * mComponents; + llassert(prev_mip_data); + llassert(prev_mip_size == bytes); U8* new_data = new U8[bytes]; + llassert_always(new_data); LLImageBase::generateMip(prev_mip_data, new_data, w, h, mComponents); cur_mip_data = new_data; + cur_mip_size = bytes; } llassert(w > 0 && h > 0 && cur_mip_data); { @@ -630,12 +658,14 @@ void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips) delete[] prev_mip_data; } prev_mip_data = cur_mip_data; + prev_mip_size = cur_mip_size; w >>= 1; h >>= 1; } if (prev_mip_data && prev_mip_data != data_in) { delete[] prev_mip_data; + prev_mip_data = NULL; } } } @@ -985,6 +1015,21 @@ BOOL LLImageGL::setDiscardLevel(S32 discard_level) } } +BOOL LLImageGL::isValidForSculpt(S32 discard_level, S32 image_width, S32 image_height, S32 ncomponents) +{ + assert_glerror(); + S32 gl_discard = discard_level - mCurrentDiscardLevel; + LLGLint glwidth = 0; + glGetTexLevelParameteriv(mTarget, gl_discard, GL_TEXTURE_WIDTH, (GLint*)&glwidth); + LLGLint glheight = 0; + glGetTexLevelParameteriv(mTarget, gl_discard, GL_TEXTURE_HEIGHT, (GLint*)&glheight); + LLGLint glcomponents = 0 ; + glGetTexLevelParameteriv(mTarget, gl_discard, GL_TEXTURE_INTERNAL_FORMAT, (GLint*)&glcomponents); + assert_glerror(); + + return glwidth >= image_width && glheight >= image_height && (GL_RGB8 == glcomponents || GL_RGBA8 == glcomponents) ; +} + BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compressed_ok) { if (discard_level < 0) @@ -1022,6 +1067,7 @@ BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre llerrs << llformat("LLImageGL::readBackRaw: bogus params: %d x %d x %d",width,height,ncomponents) << llendl; } + BOOL return_result = TRUE ; LLGLint is_compressed = 0; if (compressed_ok) { @@ -1033,16 +1079,28 @@ BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre glGetTexLevelParameteriv(mTarget, gl_discard, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, (GLint*)&glbytes); imageraw->allocateDataSize(width, height, ncomponents, glbytes); glGetCompressedTexImageARB(mTarget, gl_discard, (GLvoid*)(imageraw->getData())); + if(glGetError() != GL_NO_ERROR) + { + llwarns << "Error happens when reading back the compressed texture image." << llendl ; + imageraw->deleteData() ; + return_result = FALSE ; + } stop_glerror(); } else { imageraw->allocateDataSize(width, height, ncomponents); glGetTexImage(GL_TEXTURE_2D, gl_discard, mFormatPrimary, mFormatType, (GLvoid*)(imageraw->getData())); + if(glGetError() != GL_NO_ERROR) + { + llwarns << "Error happens when reading back the texture image." << llendl ; + imageraw->deleteData() ; + return_result = FALSE ; + } stop_glerror(); } - return TRUE; + return return_result ; } void LLImageGL::destroyGLTexture() @@ -1057,7 +1115,6 @@ void LLImageGL::destroyGLTexture() { unbindTexture(i, GL_TEXTURE_2D); stop_glerror(); - glActiveTextureARB(GL_TEXTURE0_ARB); } } diff --git a/indra/llrender/llimagegl.h b/indra/llrender/llimagegl.h index 20cf4ae10f..82ea147d6e 100644 --- a/indra/llrender/llimagegl.h +++ b/indra/llrender/llimagegl.h @@ -131,6 +131,8 @@ public: BOOL getUseDiscard() const { return mUseMipMaps && !mDontDiscard; } BOOL getDontDiscard() const { return mDontDiscard; } + BOOL isValidForSculpt(S32 discard_level, S32 image_width, S32 image_height, S32 ncomponents) ; + protected: 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 diff --git a/indra/llrender/llrendertarget.h b/indra/llrender/llrendertarget.h index 7f9c611c69..27c40fcfcf 100644 --- a/indra/llrender/llrendertarget.h +++ b/indra/llrender/llrendertarget.h @@ -71,7 +71,7 @@ public: //allocate resources for rendering //must be called before use //multiple calls will release previously allocated resources - void allocate(U32 resx, U32 resy, U32 color_fmt, BOOL depth, U32 usage = GL_TEXTURE_2D, BOOL use_fbo = TRUE); + void allocate(U32 resx, U32 resy, U32 color_fmt, BOOL depth, U32 usage = GL_TEXTURE_2D, BOOL use_fbo = FALSE); //allocate a depth texture void allocateDepth(); diff --git a/indra/llrender/llvertexbuffer.cpp b/indra/llrender/llvertexbuffer.cpp index 9303e00228..b646a02cae 100644 --- a/indra/llrender/llvertexbuffer.cpp +++ b/indra/llrender/llvertexbuffer.cpp @@ -38,6 +38,7 @@ #include "llglheaders.h" #include "llmemory.h" #include "llmemtype.h" +#include "llglimmediate.h" //============================================================================ @@ -76,6 +77,141 @@ S32 LLVertexBuffer::sTypeOffsets[LLVertexBuffer::TYPE_MAX] = sizeof(LLVector4), // TYPE_CLOTHWEIGHT, }; +U32 LLVertexBuffer::sGLMode[LLVertexBuffer::NUM_MODES] = +{ + GL_TRIANGLES, + GL_TRIANGLE_STRIP, + GL_TRIANGLE_FAN, + GL_POINTS, + GL_LINES, + GL_LINE_STRIP +}; + +//static +void LLVertexBuffer::setupClientArrays(U32 data_mask) +{ + if (LLGLImmediate::sStarted) + { + llerrs << "Cannot use LLGLImmediate and LLVertexBuffer simultaneously!" << llendl; + } + + if (sLastMask != data_mask) + { + U32 mask[] = + { + MAP_VERTEX, + MAP_NORMAL, + MAP_TEXCOORD, + MAP_COLOR + }; + + GLenum array[] = + { + GL_VERTEX_ARRAY, + GL_NORMAL_ARRAY, + GL_TEXTURE_COORD_ARRAY, + GL_COLOR_ARRAY + }; + + for (U32 i = 0; i < 4; ++i) + { + if (sLastMask & mask[i]) + { //was enabled + if (!(data_mask & mask[i]) && i > 0) + { //needs to be disabled + glDisableClientState(array[i]); + } + else + { //needs to be enabled, make sure it was (DEBUG TEMPORARY) + if (i > 0 && !glIsEnabled(array[i])) + { + llerrs << "Bad client state! " << array[i] << " disabled." << llendl; + } + } + } + else + { //was disabled + if (data_mask & mask[i]) + { //needs to be enabled + glEnableClientState(array[i]); + } + else if (glIsEnabled(array[i])) + { //needs to be disabled, make sure it was (DEBUG TEMPORARY) + llerrs << "Bad client state! " << array[i] << " enabled." << llendl; + } + } + } + + if (sLastMask & MAP_TEXCOORD2) + { + if (!(data_mask & MAP_TEXCOORD2)) + { + glClientActiveTextureARB(GL_TEXTURE1_ARB); + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + glClientActiveTextureARB(GL_TEXTURE0_ARB); + } + } + else if (data_mask & MAP_TEXCOORD2) + { + glClientActiveTextureARB(GL_TEXTURE1_ARB); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + glClientActiveTextureARB(GL_TEXTURE0_ARB); + } + + sLastMask = data_mask; + } +} + +void LLVertexBuffer::drawRange(U32 mode, U32 start, U32 end, U32 count, U32 indices_offset) const +{ + if (start >= (U32) mRequestedNumVerts || + end >= (U32) mRequestedNumVerts) + { + llerrs << "Bad vertex buffer draw range: [" << start << ", " << end << "]" << llendl; + } + + if (indices_offset >= (U32) mRequestedNumIndices || + indices_offset + count > (U32) mRequestedNumIndices) + { + llerrs << "Bad index buffer draw range: [" << indices_offset << ", " << indices_offset+count << "]" << llendl; + } + + if (mGLIndices != sGLRenderIndices) + { + llerrs << "Wrong index buffer bound." << llendl; + } + + if (mGLBuffer != sGLRenderBuffer) + { + llerrs << "Wrong vertex buffer bound." << llendl; + } + + glDrawRangeElements(sGLMode[mode], start, end, count, GL_UNSIGNED_SHORT, + ((U16*) getIndicesPointer()) + indices_offset); +} + +void LLVertexBuffer::draw(U32 mode, U32 count, U32 indices_offset) const +{ + if (indices_offset >= (U32) mRequestedNumIndices || + indices_offset + count > (U32) mRequestedNumIndices) + { + llerrs << "Bad index buffer draw range: [" << indices_offset << ", " << indices_offset+count << "]" << llendl; + } + + if (mGLIndices != sGLRenderIndices) + { + llerrs << "Wrong index buffer bound." << llendl; + } + + if (mGLBuffer != sGLRenderBuffer) + { + llerrs << "Wrong vertex buffer bound." << llendl; + } + + glDrawElements(sGLMode[mode], count, GL_UNSIGNED_SHORT, + ((U16*) getIndicesPointer()) + indices_offset); +} + //static void LLVertexBuffer::initClass(bool use_vbo) { @@ -102,7 +238,8 @@ void LLVertexBuffer::unbind() sGLRenderBuffer = 0; sGLRenderIndices = 0; - sLastMask = 0; + + setupClientArrays(0); } //static @@ -118,22 +255,14 @@ void LLVertexBuffer::cleanupClass() void LLVertexBuffer::startRender() { LLMemType mt(LLMemType::MTYPE_VERTEX_DATA); - if (sEnableVBOs) - { - glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); - glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0); - sVBOActive = FALSE; - sIBOActive = FALSE; - } - + + unbind(); sRenderActive = TRUE; - sGLRenderBuffer = 0; - sGLRenderIndices = 0; - sLastMask = 0; } void LLVertexBuffer::stopRender() { + unbind(); sRenderActive = FALSE; } @@ -615,6 +744,16 @@ U8* LLVertexBuffer::mapBuffer(S32 access) llerrs << "Mapped two VBOs at the same time!" << llendl; } sMapped = TRUE;*/ + if (!mMappedData) + { + llerrs << "glMapBuffer returned NULL (no vertex data)" << llendl; + } + + if (!mMappedIndexData) + { + llerrs << "glMapBuffer returned NULL (no index data)" << llendl; + } + sMappedCount++; } @@ -666,7 +805,12 @@ template <class T,S32 type> struct VertexBufferStrider strider_t& strider, S32 index) { - vbo.mapBuffer(); + if (vbo.mapBuffer() == NULL) + { + llwarns << "mapBuffer failed!" << llendl; + return FALSE; + } + if (type == LLVertexBuffer::TYPE_INDEX) { S32 stride = sizeof(T); @@ -828,6 +972,8 @@ void LLVertexBuffer::setBuffer(U32 data_mask) sIBOActive = FALSE; } } + + setupClientArrays(data_mask); if (mGLIndices) { @@ -846,8 +992,6 @@ void LLVertexBuffer::setBuffer(U32 data_mask) sSetCount++; } } - - sLastMask = data_mask; } // virtual (default) @@ -871,10 +1015,10 @@ void LLVertexBuffer::setupVertexBuffer(U32 data_mask) const { glClientActiveTextureARB(GL_TEXTURE1_ARB); glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD2])); + glClientActiveTextureARB(GL_TEXTURE0_ARB); } if (data_mask & MAP_TEXCOORD) { - glClientActiveTextureARB(GL_TEXTURE0_ARB); glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD])); } if (data_mask & MAP_COLOR) diff --git a/indra/llrender/llvertexbuffer.h b/indra/llrender/llvertexbuffer.h index e2a4196b0e..50f79cfc9d 100644 --- a/indra/llrender/llvertexbuffer.h +++ b/indra/llrender/llvertexbuffer.h @@ -84,6 +84,7 @@ public: static void initClass(bool use_vbo); static void cleanupClass(); + static void setupClientArrays(U32 data_mask); static void startRender(); //between start and stop render, no client copies will occur static void stopRender(); //any buffer not copied to GL will be rendered from client memory static void clientCopy(F64 max_time = 0.005); //copy data from client to GL @@ -123,6 +124,15 @@ public: MAP_UNMAPPED = 0x8000 // Indicates that buffer has been logically un-mapped }; + enum { + TRIANGLES = 0, + TRIANGLE_STRIP, + TRIANGLE_FAN, + POINTS, + LINES, + LINE_STRIP, + NUM_MODES + }; protected: friend class LLGLImmediate; @@ -194,6 +204,9 @@ public: void markDirty(U32 vert_index, U32 vert_count, U32 indices_index, U32 indices_count); + void draw(U32 mode, U32 count, U32 indices_offset) const; + void drawRange(U32 mode, U32 start, U32 end, U32 count, U32 indices_offset) const; + protected: S32 mNumVerts; // Number of vertices allocated S32 mNumIndices; // Number of indices allocated @@ -241,6 +254,7 @@ public: static BOOL sEnableVBOs; static S32 sTypeOffsets[TYPE_MAX]; + static U32 sGLMode[NUM_MODES]; static U32 sGLRenderBuffer; static U32 sGLRenderIndices; static BOOL sVBOActive; diff --git a/indra/llui/llfloater.cpp b/indra/llui/llfloater.cpp index 4829d5b893..f80028656e 100644 --- a/indra/llui/llfloater.cpp +++ b/indra/llui/llfloater.cpp @@ -923,6 +923,7 @@ void LLFloater::setFocus( BOOL b ) } } +// virtual void LLFloater::setIsChrome(BOOL is_chrome) { // chrome floaters don't take focus at all @@ -941,6 +942,12 @@ void LLFloater::setIsChrome(BOOL is_chrome) LLPanel::setIsChrome(is_chrome); } +void LLFloater::setTitleVisible(bool visible) +{ + if (mDragHandle) + mDragHandle->setTitleVisible(visible); +} + // Change the draw style to account for the foreground state. void LLFloater::setForeground(BOOL front) { diff --git a/indra/llui/llfloater.h b/indra/llui/llfloater.h index 280789d64c..4e8b86d2de 100644 --- a/indra/llui/llfloater.h +++ b/indra/llui/llfloater.h @@ -146,6 +146,7 @@ public: const LLString& getTitle() const; void setShortTitle( const LLString& short_title ); LLString getShortTitle(); + void setTitleVisible(bool visible); virtual void setMinimized(BOOL b); void moveResizeHandlesToFront(); void addDependentFloater(LLFloater* dependent, BOOL reposition = TRUE); diff --git a/indra/llui/llscrollbar.cpp b/indra/llui/llscrollbar.cpp index 90659cdc70..2c4a5cbc58 100644 --- a/indra/llui/llscrollbar.cpp +++ b/indra/llui/llscrollbar.cpp @@ -501,6 +501,13 @@ void LLScrollbar::draw() } else { + // Background + rounded_rect_imagep->drawSolid(mOrientation == HORIZONTAL ? SCROLLBAR_SIZE : 0, + mOrientation == VERTICAL ? SCROLLBAR_SIZE : 0, + mOrientation == HORIZONTAL ? getRect().getWidth() - 2 * SCROLLBAR_SIZE : getRect().getWidth(), + mOrientation == VERTICAL ? getRect().getHeight() - 2 * SCROLLBAR_SIZE : getRect().getHeight(), + mTrackColor); + // Thumb LLRect outline_rect = mThumbRect; outline_rect.stretch(2); diff --git a/indra/llui/llscrollcontainer.cpp b/indra/llui/llscrollcontainer.cpp index d8df636abd..edad4c4d6b 100644 --- a/indra/llui/llscrollcontainer.cpp +++ b/indra/llui/llscrollcontainer.cpp @@ -430,7 +430,7 @@ void LLScrollableContainerView::draw() if( mIsOpaque ) { LLGLSNoTexture no_texture; - glColor4fv( mBackgroundColor.mV ); + gGL.color4fv( mBackgroundColor.mV ); gl_rect_2d( mInnerRect ); } diff --git a/indra/llui/llscrolllistctrl.cpp b/indra/llui/llscrolllistctrl.cpp index eb244a6f82..4e640eac2a 100644 --- a/indra/llui/llscrolllistctrl.cpp +++ b/indra/llui/llscrolllistctrl.cpp @@ -1759,7 +1759,7 @@ void LLScrollListCtrl::draw() if (mBackgroundVisible) { LLGLSNoTexture no_texture; - glColor4fv( getEnabled() ? mBgWriteableColor.mV : mBgReadOnlyColor.mV ); + gGL.color4fv( getEnabled() ? mBgWriteableColor.mV : mBgReadOnlyColor.mV ); gl_rect_2d(background); } diff --git a/indra/llwindow/llwindowwin32.cpp b/indra/llwindow/llwindowwin32.cpp index e6e999bac4..06b4fbde59 100644 --- a/indra/llwindow/llwindowwin32.cpp +++ b/indra/llwindow/llwindowwin32.cpp @@ -1326,8 +1326,9 @@ BOOL LLWindowWin32::switchContext(BOOL fullscreen, const LLCoordScreen &size, BO close(); OSMessageBox( "Second Life is unable to run because your video card drivers\n" - "are out of date or unsupported. Please make sure you have\n" - "the latest video card drivers installed.\n\n" + "did not install properly, are out of date, or are for unsupported\n" + "hardware. Please make sure you have the latest video card drivers\n" + "and even if you do have the latest, try reinstalling them.\n\n" "If you continue to receive this message, contact customer service.", "Error", OSMB_OK); @@ -1836,6 +1837,10 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_ break; } case WM_IME_SETCONTEXT: + if (gDebugWindowProc) + { + llinfos << "WM_IME_SETCONTEXT" << llendl; + } if (LLWinImm::isAvailable() && window_imp->mPreeditor) { l_param &= ~ISC_SHOWUICOMPOSITIONWINDOW; @@ -1844,6 +1849,10 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_ break; case WM_IME_STARTCOMPOSITION: + if (gDebugWindowProc) + { + llinfos << "WM_IME_STARTCOMPOSITION" << llendl; + } if (LLWinImm::isAvailable() && window_imp->mPreeditor) { window_imp->handleStartCompositionMessage(); @@ -1852,6 +1861,10 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_ break; case WM_IME_ENDCOMPOSITION: + if (gDebugWindowProc) + { + llinfos << "WM_IME_ENDCOMPOSITION" << llendl; + } if (LLWinImm::isAvailable() && window_imp->mPreeditor) { return 0; @@ -1859,6 +1872,10 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_ break; case WM_IME_COMPOSITION: + if (gDebugWindowProc) + { + llinfos << "WM_IME_COMPOSITION" << llendl; + } if (LLWinImm::isAvailable() && window_imp->mPreeditor) { window_imp->handleCompositionMessage(l_param); @@ -1867,6 +1884,10 @@ LRESULT CALLBACK LLWindowWin32::mainWindowProc(HWND h_wnd, UINT u_msg, WPARAM w_ break; case WM_IME_REQUEST: + if (gDebugWindowProc) + { + llinfos << "WM_IME_REQUEST" << llendl; + } if (LLWinImm::isAvailable() && window_imp->mPreeditor) { LRESULT result = 0; diff --git a/indra/llxml/llcontrol.cpp b/indra/llxml/llcontrol.cpp index a1d2620a6f..2c4fb3bccc 100644 --- a/indra/llxml/llcontrol.cpp +++ b/indra/llxml/llcontrol.cpp @@ -953,7 +953,7 @@ U32 LLControlGroup::saveToFile(const LLString& filename, BOOL nondefault_only) return num_saved; } -U32 LLControlGroup::loadFromFile(const LLString& filename, BOOL require_declaration, eControlType declare_as) +U32 LLControlGroup::loadFromFile(const LLString& filename) { LLString name; LLSD settings; @@ -965,24 +965,47 @@ U32 LLControlGroup::loadFromFile(const LLString& filename, BOOL require_declarat llwarns << "Cannot find file " << filename << " to load." << llendl; return 0; } + S32 ret = LLSDSerialize::fromXML(settings, infile); + if (ret <= 0) { infile.close(); llwarns << "Unable to open LLSD control file " << filename << ". Trying Legacy Method." << llendl; - return loadFromFileLegacy(filename, require_declaration, declare_as); + return loadFromFileLegacy(filename, TRUE, TYPE_STRING); } - U32 validitems = 0; + U32 validitems = 0; int persist = 1; for(LLSD::map_const_iterator itr = settings.beginMap(); itr != settings.endMap(); ++itr) { name = (*itr).first; control_map = (*itr).second; - if(control_map.has("Persist")) persist = control_map["Persist"].asInteger(); + if(control_map.has("Persist")) + { + persist = control_map["Persist"].asInteger(); + } - declareControl(name, typeStringToEnum(control_map["Type"].asString()), control_map["Value"], control_map["Comment"].asString(), persist); + // If the control exists just set the value from the input file. + LLControlVariable* existing_control = getControl(name); + if(existing_control) + { + // Check persistence. If not persisted, we shouldn't be loading. + if(existing_control->isPersisted()) + { + existing_control->setValue(control_map["Value"]); + } + } + else + { + declareControl(name, + typeStringToEnum(control_map["Type"].asString()), + control_map["Value"], + control_map["Comment"].asString(), + persist + ); + } ++validitems; } diff --git a/indra/llxml/llcontrol.h b/indra/llxml/llcontrol.h index 7a638a7b73..7287731cfa 100644 --- a/indra/llxml/llcontrol.h +++ b/indra/llxml/llcontrol.h @@ -213,7 +213,7 @@ public: // as the given type. U32 loadFromFileLegacy(const LLString& filename, BOOL require_declaration = TRUE, eControlType declare_as = TYPE_STRING); U32 saveToFile(const LLString& filename, BOOL nondefault_only); - U32 loadFromFile(const LLString& filename, BOOL require_declaration = TRUE, eControlType declare_as = TYPE_STRING); + U32 loadFromFile(const LLString& filename); void resetToDefaults(); diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml index 41566d68d0..73a832ead7 100644 --- a/indra/newview/app_settings/settings.xml +++ b/indra/newview/app_settings/settings.xml @@ -5829,7 +5829,7 @@ <key>RenderUseCleverUI</key> <map> <key>Comment</key> - <string>Turns on the \"clever\" UI rendering optimization. It's a known performace gain (and enabled by default) on apple.</string> + <string>Turns on the \"clever\" UI rendering optimization. It's a known performace gain on apple.</string> <key>Persist</key> <integer>1</integer> <key>Type</key> @@ -9825,17 +9825,6 @@ <integer>0</integer> </array> </map> - <key>AlertedUnsupportedHardware</key> - <map> - <key>Comment</key> - <string>Toggle that lets us tell the user he's on old hardware only once</string> - <key>Persist</key> - <integer>1</integer> - <key>Type</key> - <string>Boolean</string> - <key>Value</key> - <integer>0</integer> - </map> <key>RenderFastAlpha</key> <map> <key>Comment</key> diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp index 572927f918..ee471d21ac 100644 --- a/indra/newview/llappviewer.cpp +++ b/indra/newview/llappviewer.cpp @@ -64,6 +64,7 @@ #include "llurldispatcher.h" #include "llurlhistory.h" #include "llfirstuse.h" +#include "llglimmediate.h" #include "llweb.h" #include "llsecondlifeurls.h" @@ -416,10 +417,11 @@ static void settings_to_globals() static void settings_modify() { LLRenderTarget::sUseFBO = gSavedSettings.getBOOL("RenderUseFBO"); - LLVOAvatar::sUseImpostors = FALSE; //gSavedSettings.getBOOL("RenderUseImpostors"); + LLVOAvatar::sUseImpostors = gSavedSettings.getBOOL("RenderUseImpostors"); LLVOSurfacePatch::sLODFactor = gSavedSettings.getF32("RenderTerrainLODFactor"); LLVOSurfacePatch::sLODFactor *= LLVOSurfacePatch::sLODFactor; //sqaure lod factor to get exponential range of [1,4] - + gGL.setClever(gSavedSettings.getBOOL("RenderUseCleverUI")); + #if LL_VECTORIZE if (gSysCPU.hasAltivec()) { @@ -774,15 +776,6 @@ bool LLAppViewer::init() return 1; } -#if LL_DARWIN - // Display the release notes for the current version - if(!gHideLinks && gCurrentVersion != gLastRunVersion) - { - // Current version and last run version don't match exactly. Display the release notes. - DisplayReleaseNotes(); - } -#endif - // // Initialize the window // @@ -821,51 +814,55 @@ bool LLAppViewer::init() return 0; } - // alert the user if they are using unsupported hardware - if(!gSavedSettings.getBOOL("AlertedUnsupportedHardware")) - { - bool unsupported = false; - LLString::format_map_t args; - LLString minSpecs; + + bool unsupported = false; + LLString::format_map_t args; + LLString minSpecs; - // get cpu data from xml - std::stringstream minCPUString(LLAlertDialog::getTemplateMessage("UnsupportedCPUAmount")); - S32 minCPU = 0; - minCPUString >> minCPU; - - // get RAM data from XML - std::stringstream minRAMString(LLAlertDialog::getTemplateMessage("UnsupportedRAMAmount")); - U64 minRAM = 0; - minRAMString >> minRAM; - minRAM = minRAM * 1024 * 1024; - - if(!LLFeatureManager::getInstance()->isGPUSupported()) - { - minSpecs += LLAlertDialog::getTemplateMessage("UnsupportedGPU"); - minSpecs += "\n"; - unsupported = true; - } - if(gSysCPU.getMhz() < minCPU) - { - minSpecs += LLAlertDialog::getTemplateMessage("UnsupportedCPU"); - minSpecs += "\n"; - unsupported = true; - } - if(gSysMemory.getPhysicalMemoryClamped() < minRAM) - { - minSpecs += LLAlertDialog::getTemplateMessage("UnsupportedRAM"); - minSpecs += "\n"; - unsupported = true; - } + // get cpu data from xml + std::stringstream minCPUString(LLAlertDialog::getTemplateMessage("UnsupportedCPUAmount")); + S32 minCPU = 0; + minCPUString >> minCPU; + + // get RAM data from XML + std::stringstream minRAMString(LLAlertDialog::getTemplateMessage("UnsupportedRAMAmount")); + U64 minRAM = 0; + minRAMString >> minRAM; + minRAM = minRAM * 1024 * 1024; + + if(!LLFeatureManager::getInstance()->isGPUSupported() && LLFeatureManager::getInstance()->getGPUClass() != GPU_CLASS_UNKNOWN) + { + minSpecs += LLAlertDialog::getTemplateMessage("UnsupportedGPU"); + minSpecs += "\n"; + unsupported = true; + } + if(gSysCPU.getMhz() < minCPU) + { + minSpecs += LLAlertDialog::getTemplateMessage("UnsupportedCPU"); + minSpecs += "\n"; + unsupported = true; + } + if(gSysMemory.getPhysicalMemoryClamped() < minRAM) + { + minSpecs += LLAlertDialog::getTemplateMessage("UnsupportedRAM"); + minSpecs += "\n"; + unsupported = true; + } - if(unsupported) + if (LLFeatureManager::getInstance()->getGPUClass() == GPU_CLASS_UNKNOWN) + { + gViewerWindow->alertXml("UnknownGPU"); + } + + if(unsupported) + { + if(!gSavedSettings.controlExists("WarnUnsupportedHardware") + || gSavedSettings.getBOOL("WarnUnsupportedHardware")) { args["MINSPECS"] = minSpecs; gViewerWindow->alertXml("UnsupportedHardware", args ); - - // turn off flag - gSavedSettings.setBOOL("AlertedUnsupportedHardware", TRUE); } + } // Save the current version to the prefs file @@ -1452,10 +1449,13 @@ void LLAppViewer::loadSettingsFromDirectory(ELLPath path_index) LLString full_settings_path = gDirUtilp->getExpandedFilename(path_index, settings_file); - if(settings_name == sGlobalSettingsName) + if(settings_name == sGlobalSettingsName + && path_index == LL_PATH_USER_SETTINGS) { // The non-persistent setting, ClientSettingsFile, specifies a // custom name to use for the global settings file. + // Only apply this setting if this method is setting the 'Global' + // settings from the user_settings path. std::string custom_path; if(gSettings[sGlobalSettingsName]->controlExists("ClientSettingsFile")) { diff --git a/indra/newview/llcylinder.cpp b/indra/newview/llcylinder.cpp index 58a80c21e4..82db7788d6 100644 --- a/indra/newview/llcylinder.cpp +++ b/indra/newview/llcylinder.cpp @@ -255,7 +255,6 @@ void LLCone::render(S32 level_of_detail) // center object at 0 glTranslatef(0.f, 0.f, - height / 2.0f); - LLVertexBuffer::unbind(); drawSide(level_of_detail); drawBottom(level_of_detail); diff --git a/indra/newview/lldrawable.cpp b/indra/newview/lldrawable.cpp index 198c235a1e..06536660e2 100644 --- a/indra/newview/lldrawable.cpp +++ b/indra/newview/lldrawable.cpp @@ -1188,10 +1188,11 @@ void LLSpatialBridge::setVisible(LLCamera& camera_in, std::vector<LLDrawable*>* LLVector3 center = (mExtents[0] + mExtents[1]) * 0.5f; LLVector3 size = (mExtents[1]-mExtents[0]) * 0.5f; - if (camera_in.AABBInFrustumNoFarClip(center, size) && - AABBSphereIntersect(mExtents[0], mExtents[1], camera_in.getOrigin(), camera_in.mFrustumCornerDist)) + if (LLPipeline::sImpostorRender || + (camera_in.AABBInFrustumNoFarClip(center, size) && + AABBSphereIntersect(mExtents[0], mExtents[1], camera_in.getOrigin(), camera_in.mFrustumCornerDist))) { - if (LLPipeline::calcPixelArea(center, size, camera_in) < FORCE_INVISIBLE_AREA) + if (!LLPipeline::sImpostorRender && LLPipeline::calcPixelArea(center, size, camera_in) < FORCE_INVISIBLE_AREA) { return; } diff --git a/indra/newview/lldrawpool.cpp b/indra/newview/lldrawpool.cpp index c987f3e035..6cd2152a28 100644 --- a/indra/newview/lldrawpool.cpp +++ b/indra/newview/lldrawpool.cpp @@ -115,7 +115,6 @@ LLDrawPool::LLDrawPool(const U32 type) sNumDrawPools++; mId = sNumDrawPools; mVertexShaderLevel = 0; - mIndicesDrawn = 0; } LLDrawPool::~LLDrawPool() @@ -136,24 +135,6 @@ void LLDrawPool::beginRenderPass( S32 pass ) //virtual void LLDrawPool::endRenderPass( S32 pass ) { - glDisableClientState ( GL_TEXTURE_COORD_ARRAY ); - glDisableClientState ( GL_COLOR_ARRAY ); - glDisableClientState ( GL_NORMAL_ARRAY ); -} - -U32 LLDrawPool::getTrianglesDrawn() const -{ - return mIndicesDrawn / 3; -} - -void LLDrawPool::resetTrianglesDrawn() -{ - mIndicesDrawn = 0; -} - -void LLDrawPool::addIndicesDrawn(const U32 indices) -{ - mIndicesDrawn += indices; } //============================= @@ -224,7 +205,7 @@ void LLFacePool::drawLoop() { if (!mDrawFace.empty()) { - mIndicesDrawn += drawLoop(mDrawFace); + drawLoop(mDrawFace); } } @@ -382,10 +363,6 @@ void LLRenderPass::renderTexture(U32 type, U32 mask) void LLRenderPass::pushBatches(U32 type, U32 mask, BOOL texture) { -#if !LL_RELEASE_FOR_DOWNLOAD - LLGLState::checkClientArrays(mask); -#endif - for (LLCullResult::drawinfo_list_t::iterator i = gPipeline.beginRenderMap(type); i != gPipeline.endRenderMap(type); ++i) { LLDrawInfo* pparams = *i; @@ -436,9 +413,7 @@ void LLRenderPass::pushBatch(LLDrawInfo& params, U32 mask, BOOL texture) if (params.mVertexBuffer.notNull()) { params.mVertexBuffer->setBuffer(mask); - U16* indices_pointer = (U16*) params.mVertexBuffer->getIndicesPointer(); - glDrawRangeElements(GL_TRIANGLES, params.mStart, params.mEnd, params.mCount, - GL_UNSIGNED_SHORT, indices_pointer+params.mOffset); + params.mVertexBuffer->drawRange(LLVertexBuffer::TRIANGLES, params.mStart, params.mEnd, params.mCount, params.mOffset); gPipeline.addTrianglesDrawn(params.mCount/3); } diff --git a/indra/newview/lldrawpool.h b/indra/newview/lldrawpool.h index 30a16a24ba..3bd1f686d1 100644 --- a/indra/newview/lldrawpool.h +++ b/indra/newview/lldrawpool.h @@ -90,15 +90,10 @@ public: virtual BOOL isFacePool() { return FALSE; } virtual void resetDrawOrders() = 0; - U32 getTrianglesDrawn() const; - void resetTrianglesDrawn(); - void addIndicesDrawn(const U32 indices); - protected: S32 mVertexShaderLevel; S32 mId; U32 mType; // Type of draw pool - S32 mIndicesDrawn; }; class LLRenderPass : public LLDrawPool diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp index d22c459278..795f6bc396 100644 --- a/indra/newview/lldrawpoolalpha.cpp +++ b/indra/newview/lldrawpoolalpha.cpp @@ -77,9 +77,6 @@ void LLDrawPoolAlpha::prerender() void LLDrawPoolAlpha::beginRenderPass(S32 pass) { LLFastTimer t(LLFastTimer::FTM_RENDER_ALPHA); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); - glEnableClientState(GL_COLOR_ARRAY); if (LLPipeline::sUnderWaterRender) { @@ -128,8 +125,6 @@ void LLDrawPoolAlpha::render(S32 pass) { glUseProgramObjectARB(0); } - glDisableClientState(GL_NORMAL_ARRAY); - glDisableClientState(GL_COLOR_ARRAY); gPipeline.enableLightsFullbright(LLColor4(1,1,1,1)); glColor4f(1,0,0,1); LLViewerImage::sSmokeImagep->addTextureStats(1024.f*1024.f); @@ -141,10 +136,6 @@ void LLDrawPoolAlpha::render(S32 pass) void LLDrawPoolAlpha::renderAlpha(U32 mask) { -#if !LL_RELEASE_FOR_DOWNLOAD - LLGLState::checkClientArrays(mask); -#endif - for (LLCullResult::sg_list_t::iterator i = gPipeline.beginAlphaGroups(); i != gPipeline.endAlphaGroups(); ++i) { LLSpatialGroup* group = *i; @@ -182,9 +173,7 @@ void LLDrawPoolAlpha::renderAlphaHighlight(U32 mask) LLRenderPass::applyModelMatrix(params); params.mVertexBuffer->setBuffer(mask); - U16* indices_pointer = (U16*) params.mVertexBuffer->getIndicesPointer(); - glDrawRangeElements(GL_TRIANGLES, params.mStart, params.mEnd, params.mCount, - GL_UNSIGNED_SHORT, indices_pointer+params.mOffset); + params.mVertexBuffer->drawRange(LLVertexBuffer::TRIANGLES, params.mStart, params.mEnd, params.mCount, params.mOffset); gPipeline.addTrianglesDrawn(params.mCount/3); } } @@ -303,9 +292,7 @@ void LLDrawPoolAlpha::renderGroupAlpha(LLSpatialGroup* group, U32 type, U32 mask } params.mVertexBuffer->setBuffer(mask); - U16* indices_pointer = (U16*) params.mVertexBuffer->getIndicesPointer(); - glDrawRangeElements(GL_TRIANGLES, params.mStart, params.mEnd, params.mCount, - GL_UNSIGNED_SHORT, indices_pointer+params.mOffset); + params.mVertexBuffer->drawRange(LLVertexBuffer::TRIANGLES, params.mStart, params.mEnd, params.mCount, params.mOffset); gPipeline.addTrianglesDrawn(params.mCount/3); if (params.mTextureMatrix && texture && params.mTexture.notNull()) diff --git a/indra/newview/lldrawpoolavatar.cpp b/indra/newview/lldrawpoolavatar.cpp index 6db67fb269..99bb2049b5 100644 --- a/indra/newview/lldrawpoolavatar.cpp +++ b/indra/newview/lldrawpoolavatar.cpp @@ -216,13 +216,11 @@ void LLDrawPoolAvatar::beginFootShadow() } gPipeline.enableLightsFullbright(LLColor4(1,1,1,1)); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); } void LLDrawPoolAvatar::endFootShadow() { gPipeline.enableLightsDynamic(); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); } void LLDrawPoolAvatar::beginRigid() @@ -247,16 +245,11 @@ void LLDrawPoolAvatar::beginRigid() { sVertexProgram = NULL; } - - glEnableClientState(GL_NORMAL_ARRAY); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); } void LLDrawPoolAvatar::endRigid() { sShaderLevel = mVertexShaderLevel; - glDisableClientState(GL_NORMAL_ARRAY); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); if (sVertexProgram != NULL) { sVertexProgram->unbind(); @@ -265,9 +258,6 @@ void LLDrawPoolAvatar::endRigid() void LLDrawPoolAvatar::beginSkinned() { - glEnableClientState(GL_NORMAL_ARRAY); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - if (sShaderLevel > 0) { if (LLPipeline::sUnderWaterRender) @@ -295,8 +285,7 @@ void LLDrawPoolAvatar::beginSkinned() if (sShaderLevel > 0) // for hardware blending { sRenderingSkinned = TRUE; - glClientActiveTextureARB(GL_TEXTURE1_ARB); - + sVertexProgram->bind(); if (sShaderLevel >= SHADER_LEVEL_CLOTH) { @@ -331,7 +320,6 @@ void LLDrawPoolAvatar::endSkinned() sRenderingSkinned = FALSE; sVertexProgram->disableTexture(LLShaderMgr::BUMP_MAP); glActiveTextureARB(GL_TEXTURE0_ARB); - glClientActiveTextureARB(GL_TEXTURE0_ARB); disable_vertex_weighting(sVertexProgram->mAttribute[LLShaderMgr::AVATAR_WEIGHT]); if (sShaderLevel >= SHADER_LEVEL_BUMP) { @@ -356,10 +344,6 @@ void LLDrawPoolAvatar::endSkinned() } glActiveTextureARB(GL_TEXTURE0_ARB); - glClientActiveTextureARB(GL_TEXTURE0_ARB); - - glDisableClientState(GL_NORMAL_ARRAY); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); } @@ -438,7 +422,7 @@ void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass) } else if (gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_FOOT_SHADOWS)) { - mIndicesDrawn += avatarp->renderFootShadows(); + avatarp->renderFootShadows(); } return; } @@ -451,7 +435,7 @@ void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass) if (pass == 1) { // render rigid meshes (eyeballs) first - mIndicesDrawn += avatarp->renderRigid(); + avatarp->renderRigid(); return; } @@ -548,7 +532,7 @@ void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass) color.setColor(1.0f, 1.0f, 1.0f, 1.0f); } - mIndicesDrawn += avatarp->renderSkinned(AVATAR_RENDER_PASS_SINGLE); + avatarp->renderSkinned(AVATAR_RENDER_PASS_SINGLE); } } @@ -609,9 +593,6 @@ void LLDrawPoolAvatar::renderForSelect() return; } - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); sVertexProgram = &gAvatarPickProgram; if (sShaderLevel > 0) { @@ -624,13 +605,12 @@ void LLDrawPoolAvatar::renderForSelect() if ((sShaderLevel > 0) && !gUseGLPick) // for hardware blending { - glClientActiveTextureARB(GL_TEXTURE0_ARB); sRenderingSkinned = TRUE; sVertexProgram->bind(); enable_vertex_weighting(sVertexProgram->mAttribute[LLShaderMgr::AVATAR_WEIGHT]); } - mIndicesDrawn += avatarp->renderSkinned(AVATAR_RENDER_PASS_SINGLE); + avatarp->renderSkinned(AVATAR_RENDER_PASS_SINGLE); // if we're in software-blending, remember to set the fence _after_ we draw so we wait till this rendering is done if ((sShaderLevel > 0) && !gUseGLPick) @@ -645,8 +625,6 @@ void LLDrawPoolAvatar::renderForSelect() // restore texture mode glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); - glDisableClientState(GL_NORMAL_ARRAY); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); } //----------------------------------------------------------------------------- diff --git a/indra/newview/lldrawpoolbump.cpp b/indra/newview/lldrawpoolbump.cpp index b35ef81803..e5c9200cad 100644 --- a/indra/newview/lldrawpoolbump.cpp +++ b/indra/newview/lldrawpoolbump.cpp @@ -316,12 +316,8 @@ void LLDrawPoolBump::beginShiny(bool invisible) mShiny = TRUE; sVertexMask = VERTEX_MASK_SHINY; // Second pass: environment map - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); - glEnableClientState(GL_COLOR_ARRAY); if (!invisible && mVertexShaderLevel > 1) { - glEnableClientState(GL_TEXTURE_COORD_ARRAY); sVertexMask = VERTEX_MASK_SHINY | LLVertexBuffer::MAP_TEXCOORD; } @@ -456,13 +452,7 @@ void LLDrawPoolBump::endShiny(bool invisible) LLImageGL::unbindTexture(0, GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); - glDisableClientState(GL_NORMAL_ARRAY); - glDisableClientState(GL_COLOR_ARRAY); - if (!invisible && mVertexShaderLevel > 1) - { - glDisableClientState(GL_TEXTURE_COORD_ARRAY); - } - + diffuse_channel = -1; cube_channel = 0; mShiny = FALSE; @@ -479,10 +469,6 @@ void LLDrawPoolBump::beginFullbrightShiny() sVertexMask = VERTEX_MASK_SHINY | LLVertexBuffer::MAP_TEXCOORD; // Second pass: environment map - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); - glEnableClientState(GL_COLOR_ARRAY); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); if (LLPipeline::sUnderWaterRender) { @@ -564,9 +550,6 @@ void LLDrawPoolBump::endFullbrightShiny() LLImageGL::unbindTexture(0, GL_TEXTURE_2D); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); - glDisableClientState(GL_NORMAL_ARRAY); - glDisableClientState(GL_COLOR_ARRAY); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); diffuse_channel = -1; cube_channel = 0; @@ -607,9 +590,7 @@ void LLDrawPoolBump::renderGroup(LLSpatialGroup* group, U32 type, U32 mask, BOOL applyModelMatrix(params); params.mVertexBuffer->setBuffer(mask); - U16* indices_pointer = (U16*) params.mVertexBuffer->getIndicesPointer(); - glDrawRangeElements(GL_TRIANGLES, params.mStart, params.mEnd, params.mCount, - GL_UNSIGNED_SHORT, indices_pointer+params.mOffset); + params.mVertexBuffer->drawRange(LLVertexBuffer::TRIANGLES, params.mStart, params.mEnd, params.mCount, params.mOffset); gPipeline.addTrianglesDrawn(params.mCount/3); } } @@ -670,8 +651,6 @@ void LLDrawPoolBump::beginBump() // TEXTURE UNIT 0 // Output.rgb = texture at texture coord 0 glActiveTextureARB(GL_TEXTURE0_ARB); - glClientActiveTextureARB(GL_TEXTURE0_ARB); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE); @@ -686,8 +665,6 @@ void LLDrawPoolBump::beginBump() // TEXTURE UNIT 1 glActiveTextureARB(GL_TEXTURE1_ARB); - glClientActiveTextureARB(GL_TEXTURE1_ARB); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnable(GL_TEXTURE_2D); // Texture unit 1 @@ -752,15 +729,11 @@ void LLDrawPoolBump::endBump() // Disable texture unit 1 glActiveTextureARB(GL_TEXTURE1_ARB); - glClientActiveTextureARB(GL_TEXTURE1_ARB); glDisable(GL_TEXTURE_2D); // Texture unit 1 - glDisableClientState(GL_TEXTURE_COORD_ARRAY); glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); // Disable texture unit 0 glActiveTextureARB(GL_TEXTURE0_ARB); - glClientActiveTextureARB(GL_TEXTURE0_ARB); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); gGL.blendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); @@ -1091,10 +1064,6 @@ void LLBumpImageList::onSourceLoaded( BOOL success, LLViewerImage *src_vi, LLIma void LLDrawPoolBump::renderBump(U32 type, U32 mask) { -#if !LL_RELEASE_FOR_DOWNLOAD - LLGLState::checkClientArrays(mask); -#endif - LLCullResult::drawinfo_list_t::iterator begin = gPipeline.beginRenderMap(type); LLCullResult::drawinfo_list_t::iterator end = gPipeline.endRenderMap(type); @@ -1178,11 +1147,8 @@ void LLDrawPoolBump::pushBatch(LLDrawInfo& params, U32 mask, BOOL texture) } params.mVertexBuffer->setBuffer(mask); - U16* indices_pointer = (U16*) params.mVertexBuffer->getIndicesPointer(); - glDrawRangeElements(GL_TRIANGLES, params.mStart, params.mEnd, params.mCount, - GL_UNSIGNED_SHORT, indices_pointer+params.mOffset); + params.mVertexBuffer->drawRange(LLVertexBuffer::TRIANGLES, params.mStart, params.mEnd, params.mCount, params.mOffset); gPipeline.addTrianglesDrawn(params.mCount/3); - if (params.mTextureMatrix) { if (mShiny) diff --git a/indra/newview/lldrawpoolground.cpp b/indra/newview/lldrawpoolground.cpp index d71c6de9cd..3500d9471f 100644 --- a/indra/newview/lldrawpoolground.cpp +++ b/indra/newview/lldrawpoolground.cpp @@ -68,9 +68,6 @@ void LLDrawPoolGround::render(S32 pass) return; } - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - glEnableClientState(GL_VERTEX_ARRAY); - LLGLSPipelineSkyBox gls_skybox; LLImageGL::unbindTexture(0, GL_TEXTURE_2D); LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE); diff --git a/indra/newview/lldrawpoolsimple.cpp b/indra/newview/lldrawpoolsimple.cpp index 174a9ac427..a2a82eada5 100644 --- a/indra/newview/lldrawpoolsimple.cpp +++ b/indra/newview/lldrawpoolsimple.cpp @@ -65,13 +65,10 @@ void LLDrawPoolGlow::render(S32 pass) gPipeline.enableLightsFullbright(LLColor4(1,1,1,1)); } - glEnableClientState(GL_TEXTURE_COORD_ARRAY); LLGLDepthTest depth(GL_TRUE, GL_FALSE); glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE); renderTexture(LLRenderPass::PASS_GLOW, getVertexDataMask()); - - glDisableClientState(GL_TEXTURE_COORD_ARRAY); - + glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE); gGL.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); @@ -101,10 +98,6 @@ void LLDrawPoolSimple::prerender() void LLDrawPoolSimple::beginRenderPass(S32 pass) { LLFastTimer t(LLFastTimer::FTM_RENDER_SIMPLE); - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); - glEnableClientState(GL_COLOR_ARRAY); if (LLPipeline::sUnderWaterRender) { @@ -136,7 +129,6 @@ void LLDrawPoolSimple::endRenderPass(S32 pass) { LLFastTimer t(LLFastTimer::FTM_RENDER_SIMPLE); LLRenderPass::endRenderPass(pass); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); if (mVertexShaderLevel > 0){ @@ -177,7 +169,6 @@ void LLDrawPoolSimple::render(S32 pass) } LLFastTimer t(LLFastTimer::FTM_RENDER_FULLBRIGHT); U32 fullbright_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD | LLVertexBuffer::MAP_COLOR; - glDisableClientState(GL_NORMAL_ARRAY); renderTexture(LLRenderPass::PASS_FULLBRIGHT, fullbright_mask); } diff --git a/indra/newview/lldrawpoolsky.cpp b/indra/newview/lldrawpoolsky.cpp index d3273f2eeb..828c9b0848 100644 --- a/indra/newview/lldrawpoolsky.cpp +++ b/indra/newview/lldrawpoolsky.cpp @@ -113,10 +113,6 @@ void LLDrawPoolSky::render(S32 pass) LLVector3 origin = LLViewerCamera::getInstance()->getOrigin(); glTranslatef(origin.mV[0], origin.mV[1], origin.mV[2]); - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - glDisableClientState(GL_NORMAL_ARRAY); - S32 face_count = (S32)mDrawFace.size(); for (S32 i = 0; i < llmin(6, face_count); ++i) @@ -160,8 +156,6 @@ void LLDrawPoolSky::render(S32 pass) // renderHeavenlyBody(1, hbfaces[1]); } - glDisableClientState(GL_TEXTURE_COORD_ARRAY); - glPopMatrix(); } @@ -184,8 +178,6 @@ void LLDrawPoolSky::renderSkyCubeFace(U8 side) glColor4f(1, 1, 1, LLSkyTex::getInterpVal()); // lighting is disabled face.renderIndexed(); } - - mIndicesDrawn += face.getIndicesCount(); } void LLDrawPoolSky::renderHeavenlyBody(U8 hb, LLFace* face) @@ -198,7 +190,6 @@ void LLDrawPoolSky::renderHeavenlyBody(U8 hb, LLFace* face) LLColor4 color(mHB[hb]->getInterpColor()); LLOverrideFaceColor override(this, color); face->renderIndexed(); - mIndicesDrawn += face->getIndicesCount(); } @@ -215,7 +206,6 @@ void LLDrawPoolSky::renderSunHalo(LLFace* face) LLOverrideFaceColor override(this, color); face->renderIndexed(); - mIndicesDrawn += face->getIndicesCount(); } diff --git a/indra/newview/lldrawpoolterrain.cpp b/indra/newview/lldrawpoolterrain.cpp index 634b502057..4747043c78 100644 --- a/indra/newview/lldrawpoolterrain.cpp +++ b/indra/newview/lldrawpoolterrain.cpp @@ -217,14 +217,6 @@ void LLDrawPoolTerrain::render(S32 pass) void LLDrawPoolTerrain::renderFullShader() { - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); - - if (gPipeline.getLightingDetail() >= 2) - { - glEnableClientState(GL_COLOR_ARRAY); - } - // Hack! Get the region that this draw pool is rendering from! LLViewerRegion *regionp = mDrawFace[0]->getDrawable()->getVObj()->getRegion(); LLVLComposition *compp = regionp->getComposition(); @@ -247,10 +239,8 @@ void LLDrawPoolTerrain::renderFullShader() // S32 detail0 = sShader->enableTexture(LLShaderMgr::TERRAIN_DETAIL0); LLViewerImage::bindTexture(detail_texture0p,detail0); - glClientActiveTextureARB(GL_TEXTURE0_ARB); glActiveTextureARB(GL_TEXTURE0_ARB); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); @@ -269,9 +259,7 @@ void LLDrawPoolTerrain::renderFullShader() LLViewerImage::bindTexture(detail_texture1p,detail1); /// ALPHA TEXTURE COORDS 0: - glClientActiveTextureARB(GL_TEXTURE1_ARB); glActiveTextureARB(GL_TEXTURE1_ARB); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); glMatrixMode(GL_TEXTURE); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); @@ -283,9 +271,7 @@ void LLDrawPoolTerrain::renderFullShader() glEnable(GL_TEXTURE_2D); /// ALPHA TEXTURE COORDS 1: - glClientActiveTextureARB(GL_TEXTURE2_ARB); glActiveTextureARB(GL_TEXTURE2_ARB); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); glMatrixMode(GL_TEXTURE); glLoadIdentity(); glTranslatef(-2.f, 0.f, 0.f); @@ -298,9 +284,7 @@ void LLDrawPoolTerrain::renderFullShader() LLViewerImage::bindTexture(detail_texture3p,detail3); /// ALPHA TEXTURE COORDS 2: - glClientActiveTextureARB(GL_TEXTURE3_ARB); glActiveTextureARB(GL_TEXTURE3_ARB); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); glMatrixMode(GL_TEXTURE); glLoadIdentity(); glTranslatef(-1.f, 0.f, 0.f); @@ -323,7 +307,6 @@ void LLDrawPoolTerrain::renderFullShader() sShader->disableTexture(LLShaderMgr::TERRAIN_DETAIL3); LLImageGL::unbindTexture(alpha_ramp, GL_TEXTURE_2D); - glClientActiveTextureARB(GL_TEXTURE4_ARB); glActiveTextureARB(GL_TEXTURE4_ARB); glDisable(GL_TEXTURE_2D); // Texture unit 4 glDisable(GL_TEXTURE_GEN_S); @@ -333,10 +316,8 @@ void LLDrawPoolTerrain::renderFullShader() glMatrixMode(GL_MODELVIEW); LLImageGL::unbindTexture(detail3, GL_TEXTURE_2D); - glClientActiveTextureARB(GL_TEXTURE3_ARB); glActiveTextureARB(GL_TEXTURE3_ARB); glDisable(GL_TEXTURE_2D); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glMatrixMode(GL_TEXTURE); @@ -344,10 +325,8 @@ void LLDrawPoolTerrain::renderFullShader() glMatrixMode(GL_MODELVIEW); LLImageGL::unbindTexture(detail2, GL_TEXTURE_2D); - glClientActiveTextureARB(GL_TEXTURE2_ARB); glActiveTextureARB(GL_TEXTURE2_ARB); glDisable(GL_TEXTURE_2D); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glMatrixMode(GL_TEXTURE); @@ -355,10 +334,8 @@ void LLDrawPoolTerrain::renderFullShader() glMatrixMode(GL_MODELVIEW); LLImageGL::unbindTexture(detail1, GL_TEXTURE_2D); - glClientActiveTextureARB(GL_TEXTURE1_ARB); glActiveTextureARB(GL_TEXTURE1_ARB); glDisable(GL_TEXTURE_2D); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); glMatrixMode(GL_TEXTURE); @@ -369,7 +346,6 @@ void LLDrawPoolTerrain::renderFullShader() // Restore Texture Unit 0 defaults LLImageGL::unbindTexture(detail0, GL_TEXTURE_2D); - glClientActiveTextureARB(GL_TEXTURE0_ARB); glActiveTextureARB(GL_TEXTURE0_ARB); glEnable(GL_TEXTURE_2D); glDisable(GL_TEXTURE_GEN_S); @@ -377,14 +353,11 @@ void LLDrawPoolTerrain::renderFullShader() glMatrixMode(GL_TEXTURE); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); - - // Restore non Texture Unit specific defaults - glDisableClientState(GL_NORMAL_ARRAY); } void LLDrawPoolTerrain::renderFull4TU() { - glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); // Hack! Get the region that this draw pool is rendering from! @@ -434,9 +407,8 @@ void LLDrawPoolTerrain::renderFull4TU() // // Stage 1: Generate alpha ramp for detail0/detail1 transition // - glActiveTextureARB(GL_TEXTURE1_ARB); LLViewerImage::bindTexture(m2DAlphaRampImagep,1); - + glActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_2D); // Texture unit 1 glClientActiveTextureARB(GL_TEXTURE1_ARB); glEnableClientState(GL_TEXTURE_COORD_ARRAY); @@ -454,8 +426,8 @@ void LLDrawPoolTerrain::renderFull4TU() // // Stage 2: Interpolate detail1 with existing based on ramp // - glActiveTextureARB(GL_TEXTURE2_ARB); LLViewerImage::bindTexture(detail_texture1p,2); + glActiveTextureARB(GL_TEXTURE2_ARB); glEnable(GL_TEXTURE_2D); // Texture unit 2 glClientActiveTextureARB(GL_TEXTURE2_ARB); @@ -480,8 +452,8 @@ void LLDrawPoolTerrain::renderFull4TU() // // Stage 3: Modulate with primary (vertex) color for lighting // - glActiveTextureARB(GL_TEXTURE3_ARB); LLViewerImage::bindTexture(detail_texture1p,3); // bind any texture + glActiveTextureARB(GL_TEXTURE3_ARB); glEnable(GL_TEXTURE_2D); // Texture unit 3 glClientActiveTextureARB(GL_TEXTURE3_ARB); @@ -494,6 +466,7 @@ void LLDrawPoolTerrain::renderFull4TU() glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PRIMARY_COLOR_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR); + glActiveTextureARB(GL_TEXTURE0_ARB); // GL_BLEND disabled by default drawLoop(); @@ -524,9 +497,8 @@ void LLDrawPoolTerrain::renderFull4TU() // // Stage 1: Generate alpha ramp for detail2/detail3 transition // - glActiveTextureARB(GL_TEXTURE1_ARB); LLViewerImage::bindTexture(m2DAlphaRampImagep,1); - + glActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_2D); // Texture unit 1 glClientActiveTextureARB(GL_TEXTURE1_ARB); @@ -551,8 +523,8 @@ void LLDrawPoolTerrain::renderFull4TU() // // Stage 2: Interpolate detail2 with existing based on ramp // - glActiveTextureARB(GL_TEXTURE2_ARB); LLViewerImage::bindTexture(detail_texture2p,2); + glActiveTextureARB(GL_TEXTURE2_ARB); glEnable(GL_TEXTURE_2D); // Texture unit 2 glClientActiveTextureARB(GL_TEXTURE2_ARB); @@ -578,9 +550,9 @@ void LLDrawPoolTerrain::renderFull4TU() // // Stage 3: Generate alpha ramp for detail1/detail2 transition // - glActiveTextureARB(GL_TEXTURE3_ARB); LLViewerImage::bindTexture(m2DAlphaRampImagep,3); - + glActiveTextureARB(GL_TEXTURE3_ARB); + glEnable(GL_TEXTURE_2D); // Texture unit 3 glClientActiveTextureARB(GL_TEXTURE3_ARB); @@ -603,7 +575,7 @@ void LLDrawPoolTerrain::renderFull4TU() glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); - + glActiveTextureARB(GL_TEXTURE0_ARB); { LLGLEnable blend(GL_BLEND); drawLoop(); @@ -611,6 +583,7 @@ void LLDrawPoolTerrain::renderFull4TU() // Disable multitexture LLImageGL::unbindTexture(3, GL_TEXTURE_2D); + glActiveTextureARB(GL_TEXTURE3_ARB); glClientActiveTextureARB(GL_TEXTURE3_ARB); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisable(GL_TEXTURE_2D); // Texture unit 3 @@ -619,6 +592,7 @@ void LLDrawPoolTerrain::renderFull4TU() glMatrixMode(GL_MODELVIEW); LLImageGL::unbindTexture(2, GL_TEXTURE_2D); + glActiveTextureARB(GL_TEXTURE2_ARB); glClientActiveTextureARB(GL_TEXTURE2_ARB); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisable(GL_TEXTURE_2D); // Texture unit 2 @@ -629,6 +603,7 @@ void LLDrawPoolTerrain::renderFull4TU() glMatrixMode(GL_MODELVIEW); LLImageGL::unbindTexture(1, GL_TEXTURE_2D); + glActiveTextureARB(GL_TEXTURE1_ARB); glClientActiveTextureARB(GL_TEXTURE1_ARB); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisable(GL_TEXTURE_2D); // Texture unit 1 @@ -642,6 +617,7 @@ void LLDrawPoolTerrain::renderFull4TU() //---------------------------------------------------------------------------- // Restore Texture Unit 0 defaults + glActiveTextureARB(GL_TEXTURE0_ARB); LLImageGL::unbindTexture(0, GL_TEXTURE_2D); glClientActiveTextureARB(GL_TEXTURE0_ARB); glActiveTextureARB(GL_TEXTURE0_ARB); @@ -658,9 +634,6 @@ void LLDrawPoolTerrain::renderFull4TU() void LLDrawPoolTerrain::renderFull2TU() { - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); - // Hack! Get the region that this draw pool is rendering from! LLViewerRegion *regionp = mDrawFace[0]->getDrawable()->getVObj()->getRegion(); LLVLComposition *compp = regionp->getComposition(); @@ -687,9 +660,6 @@ void LLDrawPoolTerrain::renderFull2TU() // Stage 0: Render detail 0 into base // LLViewerImage::bindTexture(detail_texture0p,0); - glClientActiveTextureARB(GL_TEXTURE0_ARB); - - glDisableClientState(GL_TEXTURE_COORD_ARRAY); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); @@ -715,12 +685,10 @@ void LLDrawPoolTerrain::renderFull2TU() // Stage 0: Generate alpha ramp for detail0/detail1 transition // LLViewerImage::bindTexture(m2DAlphaRampImagep,0); - glClientActiveTextureARB(GL_TEXTURE0_ARB); - + glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - + // Care about alpha only glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE); @@ -736,10 +704,8 @@ void LLDrawPoolTerrain::renderFull2TU() // Stage 1: Write detail1 // LLViewerImage::bindTexture(detail_texture1p,1); // Texture unit 1 + glActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_2D); // Texture unit 1 - glClientActiveTextureARB(GL_TEXTURE1_ARB); - - glDisableClientState(GL_TEXTURE_COORD_ARRAY); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); @@ -758,6 +724,7 @@ void LLDrawPoolTerrain::renderFull2TU() glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); + glActiveTextureARB(GL_TEXTURE0_ARB); { LLGLEnable blend(GL_BLEND); drawLoop(); @@ -769,14 +736,11 @@ void LLDrawPoolTerrain::renderFull2TU() // Stage 0: Generate alpha ramp for detail1/detail2 transition // LLViewerImage::bindTexture(m2DAlphaRampImagep,0); - glClientActiveTextureARB(GL_TEXTURE0_ARB); // Set the texture matrix glMatrixMode(GL_TEXTURE); glLoadIdentity(); glTranslatef(-1.f, 0.f, 0.f); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - // Care about alpha only glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE); @@ -793,9 +757,7 @@ void LLDrawPoolTerrain::renderFull2TU() LLViewerImage::bindTexture(detail_texture2p,1); glEnable(GL_TEXTURE_2D); // Texture unit 1 - glClientActiveTextureARB(GL_TEXTURE1_ARB); - - glDisableClientState(GL_TEXTURE_COORD_ARRAY); + glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); @@ -826,14 +788,11 @@ void LLDrawPoolTerrain::renderFull2TU() // Stage 0: Generate alpha ramp for detail2/detail3 transition // LLViewerImage::bindTexture(m2DAlphaRampImagep,0); - glClientActiveTextureARB(GL_TEXTURE0_ARB); // Set the texture matrix glMatrixMode(GL_TEXTURE); glLoadIdentity(); glTranslatef(-2.f, 0.f, 0.f); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - // Care about alpha only glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE); @@ -847,10 +806,8 @@ void LLDrawPoolTerrain::renderFull2TU() // Stage 1: Write detail3 LLViewerImage::bindTexture(detail_texture3p,1); + glActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_2D); // Texture unit 1 - glClientActiveTextureARB(GL_TEXTURE1_ARB); - - glDisableClientState(GL_TEXTURE_COORD_ARRAY); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); @@ -869,6 +826,7 @@ void LLDrawPoolTerrain::renderFull2TU() glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); + glActiveTextureARB(GL_TEXTURE0_ARB); { LLGLEnable blend(GL_BLEND); drawLoop(); @@ -879,8 +837,7 @@ void LLDrawPoolTerrain::renderFull2TU() // Disable multitexture LLImageGL::unbindTexture(1, GL_TEXTURE_2D); - glClientActiveTextureARB(GL_TEXTURE1_ARB); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); + glActiveTextureARB(GL_TEXTURE1_ARB); glDisable(GL_TEXTURE_2D); // Texture unit 1 glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); @@ -891,9 +848,9 @@ void LLDrawPoolTerrain::renderFull2TU() //---------------------------------------------------------------------------- // Restore Texture Unit 0 defaults + glActiveTextureARB(GL_TEXTURE0_ARB); LLImageGL::unbindTexture(0, GL_TEXTURE_2D); - glClientActiveTextureARB(GL_TEXTURE0_ARB); glActiveTextureARB(GL_TEXTURE0_ARB); glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); @@ -902,16 +859,12 @@ void LLDrawPoolTerrain::renderFull2TU() glMatrixMode(GL_MODELVIEW); // Restore non Texture Unit specific defaults - glDisableClientState(GL_NORMAL_ARRAY); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); } void LLDrawPoolTerrain::renderSimple() { - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); - LLVector4 tp0, tp1; //---------------------------------------------------------------------------- @@ -923,14 +876,12 @@ void LLDrawPoolTerrain::renderSimple() glActiveTextureARB(GL_TEXTURE0_ARB); glEnable(GL_TEXTURE_2D); // Texture unit 2 - glClientActiveTextureARB(GL_TEXTURE0_ARB); - + LLVector3 origin_agent = mDrawFace[0]->getDrawable()->getVObj()->getRegion()->getOriginAgent(); F32 tscale = 1.f/256.f; tp0.setVec(tscale, 0.f, 0.0f, -1.f*(origin_agent.mV[0]/256.f)); tp1.setVec(0.f, tscale, 0.0f, -1.f*(origin_agent.mV[1]/256.f)); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); glEnable(GL_TEXTURE_GEN_S); glEnable(GL_TEXTURE_GEN_T); glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR); @@ -952,7 +903,6 @@ void LLDrawPoolTerrain::renderSimple() // Restore Texture Unit 0 defaults LLImageGL::unbindTexture(0, GL_TEXTURE_2D); - glClientActiveTextureARB(GL_TEXTURE0_ARB); glActiveTextureARB(GL_TEXTURE0_ARB); glDisable(GL_TEXTURE_GEN_S); glDisable(GL_TEXTURE_GEN_T); @@ -961,7 +911,6 @@ void LLDrawPoolTerrain::renderSimple() glMatrixMode(GL_MODELVIEW); // Restore non Texture Unit specific defaults - glDisableClientState(GL_NORMAL_ARRAY); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); } @@ -986,14 +935,8 @@ void LLDrawPoolTerrain::renderOwnership() LLViewerParcelOverlay *overlayp = regionp->getParcelOverlay(); LLImageGL *texturep = overlayp->getTexture(); - glEnableClientState(GL_VERTEX_ARRAY); - glDisableClientState(GL_NORMAL_ARRAY); - LLViewerImage::bindTexture(texturep); - glClientActiveTextureARB(GL_TEXTURE0_ARB); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - // *NOTE: Because the region is 256 meters wide, but has 257 pixels, the // texture coordinates for pixel 256x256 is not 1,1. This makes the // ownership map not line up with the selection. We address this with @@ -1014,9 +957,6 @@ void LLDrawPoolTerrain::renderOwnership() glMatrixMode(GL_TEXTURE); glPopMatrix(); glMatrixMode(GL_MODELVIEW); - - // Restore non Texture Unit specific defaults - glDisableClientState(GL_NORMAL_ARRAY); } diff --git a/indra/newview/lldrawpooltree.cpp b/indra/newview/lldrawpooltree.cpp index f70904eba4..eabc0f1268 100644 --- a/indra/newview/lldrawpooltree.cpp +++ b/indra/newview/lldrawpooltree.cpp @@ -67,9 +67,6 @@ void LLDrawPoolTree::prerender() void LLDrawPoolTree::beginRenderPass(S32 pass) { LLFastTimer t(LLFastTimer::FTM_RENDER_TREES); - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); glAlphaFunc(GL_GREATER, 0.5f); if (LLPipeline::sUnderWaterRender) @@ -110,9 +107,7 @@ void LLDrawPoolTree::endRenderPass(S32 pass) { LLFastTimer t(LLFastTimer::FTM_RENDER_TREES); glAlphaFunc(GL_GREATER, 0.01f); - glDisableClientState(GL_NORMAL_ARRAY); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); - + if (gPipeline.canUseWindLightShadersOnObjects()) { shader->unbind(); @@ -126,9 +121,6 @@ void LLDrawPoolTree::renderForSelect() return; } - glEnableClientState (GL_VERTEX_ARRAY); - glEnableClientState (GL_TEXTURE_COORD_ARRAY); - LLOverrideFaceColor color(this, 1.f, 1.f, 1.f, 1.f); LLGLSObjectSelectAlpha gls_alpha; @@ -155,7 +147,6 @@ void LLDrawPoolTree::renderForSelect() gGL.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); - glDisableClientState (GL_TEXTURE_COORD_ARRAY); } void LLDrawPoolTree::renderTree(BOOL selecting) @@ -278,8 +269,6 @@ void LLDrawPoolTree::renderTree(BOOL selecting) //glPopMatrix(); } } - - addIndicesDrawn(indices_drawn); } BOOL LLDrawPoolTree::verify() const diff --git a/indra/newview/lldrawpoolwater.cpp b/indra/newview/lldrawpoolwater.cpp index f4e22a57f6..9ffa552895 100644 --- a/indra/newview/lldrawpoolwater.cpp +++ b/indra/newview/lldrawpoolwater.cpp @@ -163,17 +163,11 @@ void LLDrawPoolWater::render(S32 pass) LLGLDisable cullFace(GL_CULL_FACE); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); - // Set up second pass first - glActiveTextureARB(GL_TEXTURE1_ARB); mWaterImagep->addTextureStats(1024.f*1024.f); mWaterImagep->bind(1); - - glClientActiveTextureARB(GL_TEXTURE1_ARB); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); + glActiveTextureARB(GL_TEXTURE1_ARB); + glEnable(GL_TEXTURE_2D); // Texture unit 1 LLVector3 camera_up = LLViewerCamera::getInstance()->getUpAxis(); @@ -215,7 +209,6 @@ void LLDrawPoolWater::render(S32 pass) glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB); glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA); - glClientActiveTextureARB(GL_TEXTURE0_ARB); glActiveTextureARB(GL_TEXTURE0_ARB); glClearStencil(1); @@ -234,11 +227,9 @@ void LLDrawPoolWater::render(S32 pass) } face->bindTexture(); face->renderIndexed(); - mIndicesDrawn += face->getIndicesCount(); } // Now, disable texture coord generation on texture state 1 - glClientActiveTextureARB(GL_TEXTURE1_ARB); glActiveTextureARB(GL_TEXTURE1_ARB); glDisable(GL_TEXTURE_2D); // Texture unit 1 glDisable(GL_TEXTURE_GEN_S); //texture unit 1 @@ -246,11 +237,9 @@ void LLDrawPoolWater::render(S32 pass) LLImageGL::unbindTexture(1, GL_TEXTURE_2D); // Disable texture coordinate and color arrays - glClientActiveTextureARB(GL_TEXTURE0_ARB); glActiveTextureARB(GL_TEXTURE0_ARB); LLImageGL::unbindTexture(0, GL_TEXTURE_2D); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); stop_glerror(); if (gSky.mVOSkyp->getCubeMap()) @@ -284,7 +273,6 @@ void LLDrawPoolWater::render(S32 pass) if (face->getGeomCount() > 0) { face->renderIndexed(); - mIndicesDrawn += face->getIndicesCount(); } } @@ -310,9 +298,6 @@ void LLDrawPoolWater::render(S32 pass) renderReflection(refl_face); } - glDisableClientState(GL_TEXTURE_COORD_ARRAY); - glDisableClientState(GL_NORMAL_ARRAY); - glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); } @@ -338,16 +323,10 @@ void LLDrawPoolWater::renderReflection(LLFace* face) LLGLSNoFog noFog; - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - LLViewerImage::bindTexture(mHBTex[dr]); LLOverrideFaceColor override(this, face->getFaceColor().mV); face->renderIndexed(); - mIndicesDrawn += face->getIndicesCount(); - - glDisableClientState(GL_TEXTURE_COORD_ARRAY); } void LLDrawPoolWater::shade() @@ -361,10 +340,6 @@ void LLDrawPoolWater::shade() return; } - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); - LLGLDisable blend(GL_BLEND); LLColor3 light_diffuse(0,0,0); @@ -562,8 +537,6 @@ void LLDrawPoolWater::shade() face->renderIndexed(); } } - - mIndicesDrawn += face->getIndicesCount(); } } @@ -576,8 +549,6 @@ void LLDrawPoolWater::shade() shader->unbind(); glActiveTextureARB(GL_TEXTURE0_ARB); - glClientActiveTextureARB(GL_TEXTURE0_ARB); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); glEnable(GL_TEXTURE_2D); glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_FALSE); diff --git a/indra/newview/lldrawpoolwlsky.cpp b/indra/newview/lldrawpoolwlsky.cpp index 63d13d61d9..e2d0c6088a 100644 --- a/indra/newview/lldrawpoolwlsky.cpp +++ b/indra/newview/lldrawpoolwlsky.cpp @@ -159,9 +159,7 @@ void LLDrawPoolWLSky::renderStars(void) const // combiners blending below requires something to be bound // and we might as well only bind once. //LLGLEnable gl_texture_2d(GL_TEXTURE_2D); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); - glDisableClientState(GL_NORMAL_ARRAY); - + gPipeline.disableLights(); if (!LLPipeline::sReflectionRender) @@ -224,9 +222,6 @@ void LLDrawPoolWLSky::renderSkyClouds(F32 camHeightLocal) const void LLDrawPoolWLSky::renderHeavenlyBodies() { - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - glDisableClientState(GL_NORMAL_ARRAY); LLGLSPipelineSkyBox gls_skybox; LLGLEnable blend_on(GL_BLEND); gPipeline.disableLights(); @@ -240,7 +235,6 @@ void LLDrawPoolWLSky::renderHeavenlyBodies() LLColor4 color(gSky.mVOSkyp->getSun().getInterpColor()); LLFacePool::LLOverrideFaceColor color_override(this, color); face->renderIndexed(); - mIndicesDrawn += face->getIndicesCount(); } #endif @@ -264,10 +258,7 @@ void LLDrawPoolWLSky::renderHeavenlyBodies() LLFacePool::LLOverrideFaceColor color_override(this, color); face->renderIndexed(); - mIndicesDrawn += face->getIndicesCount(); } - - glDisableClientState(GL_TEXTURE_COORD_ARRAY); } void LLDrawPoolWLSky::render(S32 pass) diff --git a/indra/newview/lldynamictexture.cpp b/indra/newview/lldynamictexture.cpp index 24ee701ff2..cdb7531341 100644 --- a/indra/newview/lldynamictexture.cpp +++ b/indra/newview/lldynamictexture.cpp @@ -223,17 +223,15 @@ BOOL LLDynamicTexture::updateAllInstances() glClear(GL_DEPTH_BUFFER_BIT); gDisplaySwapBuffers = FALSE; - LLVertexBuffer::startRender(); - gGL.start(); - dynamicTexture->preRender(); // Must be called outside of startRender() + LLVertexBuffer::startRender(); + if (dynamicTexture->render()) { result = TRUE; sNumRenders++; } - gGL.stop(); LLVertexBuffer::stopRender(); dynamicTexture->postRender(result); diff --git a/indra/newview/llface.cpp b/indra/newview/llface.cpp index 2157b50eb5..5a683c4c2e 100644 --- a/indra/newview/llface.cpp +++ b/indra/newview/llface.cpp @@ -263,8 +263,14 @@ void LLFace::setDrawable(LLDrawable *drawable) void LLFace::setSize(const S32 num_vertices, const S32 num_indices) { - mGeomCount = num_vertices; - mIndicesCount = num_indices; + if (mGeomCount != num_vertices || + mIndicesCount != num_indices) + { + mGeomCount = num_vertices; + mIndicesCount = num_indices; + mVertexBuffer = NULL; + mLastVertexBuffer = NULL; + } } //============================================================================ @@ -368,8 +374,6 @@ void LLFace::renderForSelect(U32 data_mask) #if !LL_RELEASE_FOR_DOWNLOAD LLGLState::checkClientArrays(data_mask); #endif - U16* indicesp = (U16*) mVertexBuffer->getIndicesPointer() + mIndicesIndex; - if (gPickFaces && mTEOffset != -1) { // mask off high 4 bits (16 total possible faces) @@ -386,40 +390,26 @@ void LLFace::renderForSelect(U32 data_mask) { glPushMatrix(); glMultMatrixf((float*) mDrawablep->getRegion()->mRenderMatrix.mMatrix); - glDrawElements(GL_TRIANGLES, mIndicesCount, GL_UNSIGNED_SHORT, indicesp); + mVertexBuffer->draw(LLVertexBuffer::TRIANGLES, mIndicesCount, mIndicesIndex); glPopMatrix(); } else { - glDrawElements(GL_TRIANGLES, mIndicesCount, GL_UNSIGNED_SHORT, indicesp); + mVertexBuffer->draw(LLVertexBuffer::TRIANGLES, mIndicesCount, mIndicesIndex); } } else { glPushMatrix(); glMultMatrixf((float*)getRenderMatrix().mMatrix); - glDrawElements(GL_TRIANGLES, mIndicesCount, GL_UNSIGNED_SHORT, indicesp); - glPopMatrix(); - } - } - else if (mGeomCount > 0) - { - if (isState(GLOBAL)) - { - glDrawArrays(GL_TRIANGLES, mGeomIndex, mGeomCount); - } - else - { - glPushMatrix(); - glMultMatrixf((float*)getRenderMatrix().mMatrix); - glDrawArrays(GL_TRIANGLES, mGeomIndex, mGeomCount); + mVertexBuffer->draw(LLVertexBuffer::TRIANGLES, mIndicesCount, mIndicesIndex); glPopMatrix(); } } } } -void LLFace::renderSelected(LLImageGL *imagep, const LLColor4& color, const S32 offset, const S32 count) +void LLFace::renderSelected(LLImageGL *imagep, const LLColor4& color) { if(mDrawablep.isNull() || mVertexBuffer.isNull()) { @@ -443,27 +433,12 @@ void LLFace::renderSelected(LLImageGL *imagep, const LLColor4& color, const S32 glMultMatrixf((GLfloat*)mDrawablep->getRegion()->mRenderMatrix.mMatrix); } - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); - mVertexBuffer->setBuffer(LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_NORMAL | LLVertexBuffer::MAP_TEXCOORD); #if !LL_RELEASE_FOR_DOWNLOAD LLGLState::checkClientArrays(LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_NORMAL | LLVertexBuffer::MAP_TEXCOORD); #endif - U16* indicesp = ((U16*) mVertexBuffer->getIndicesPointer()) + mIndicesIndex; - - if (count) - { - glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, indicesp + offset); - } - else - { - glDrawElements(GL_TRIANGLES, mIndicesCount, GL_UNSIGNED_SHORT, indicesp); - } - glDisableClientState(GL_TEXTURE_COORD_ARRAY); - glDisableClientState(GL_NORMAL_ARRAY); - + mVertexBuffer->draw(LLVertexBuffer::TRIANGLES, mIndicesCount, mIndicesIndex); + glPopMatrix(); } } @@ -542,8 +517,6 @@ void LLFace::renderSelectedUV(const S32 offset, const S32 count) } else { - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - glEnableClientState(GL_VERTEX_ARRAY); llassert(mGeomIndex >= 0); if (count) { @@ -568,7 +541,6 @@ void LLFace::renderSelectedUV(const S32 offset, const S32 count) glDrawArrays(GL_TRIANGLES, mGeomIndex, mGeomCount); } } - glDisableClientState(GL_TEXTURE_COORD_ARRAY); } glDisable(GL_POLYGON_OFFSET_FILL); @@ -1251,16 +1223,7 @@ S32 LLFace::pushVertices(const U16* index_array) const { if (mIndicesCount) { - if (mGeomCount <= gGLManager.mGLMaxVertexRange && - mIndicesCount <= (U32) gGLManager.mGLMaxIndexRange) - { - glDrawRangeElements(GL_TRIANGLES, mGeomIndex, mGeomIndex + mGeomCount-1, mIndicesCount, - GL_UNSIGNED_SHORT, index_array + mIndicesIndex); - } - else - { - glDrawElements(GL_TRIANGLES, mIndicesCount, GL_UNSIGNED_SHORT, index_array+mIndicesIndex); - } + mVertexBuffer->drawRange(LLVertexBuffer::TRIANGLES, mGeomIndex, mGeomIndex+mGeomCount-1, mIndicesCount, mIndicesIndex); gPipeline.addTrianglesDrawn(mIndicesCount/3); } diff --git a/indra/newview/llface.h b/indra/newview/llface.h index 6142ba6672..070283ecd2 100644 --- a/indra/newview/llface.h +++ b/indra/newview/llface.h @@ -167,7 +167,7 @@ public: void renderSelectedUV(const S32 offset = 0, const S32 count = 0); void renderForSelect(U32 data_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD); - void renderSelected(LLImageGL *image, const LLColor4 &color, const S32 offset = 0, const S32 count = 0); + void renderSelected(LLImageGL *image, const LLColor4 &color); F32 getKey() const { return mDistance; } diff --git a/indra/newview/llflexibleobject.cpp b/indra/newview/llflexibleobject.cpp index c18dc069a4..248e680c1b 100644 --- a/indra/newview/llflexibleobject.cpp +++ b/indra/newview/llflexibleobject.cpp @@ -195,7 +195,7 @@ void LLVolumeImplFlexible::remapSections(LLFlexibleObjectSection *source, S32 so //----------------------------------------------------------------------------- -void LLVolumeImplFlexible::setAttributesOfAllSections() +void LLVolumeImplFlexible::setAttributesOfAllSections(LLVector3* inScale) { LLVector2 bottom_scale, top_scale; F32 begin_rot = 0, end_rot = 0; @@ -215,8 +215,16 @@ void LLVolumeImplFlexible::setAttributesOfAllSections() S32 num_sections = 1 << mSimulateRes; - LLVector3 scale = mVO->mDrawable->getScale(); - + LLVector3 scale; + if (inScale == (LLVector3*)NULL) + { + scale = mVO->mDrawable->getScale(); + } + else + { + scale = *inScale; + } + mSection[0].mPosition = getAnchorPosition(); mSection[0].mDirection = LLVector3::z_axis * getFrameRotation(); mSection[0].mdPosition = mSection[0].mDirection; @@ -297,7 +305,7 @@ BOOL LLVolumeImplFlexible::doIdleUpdate(LLAgent &agent, LLWorld &world, const F6 new_res = mRenderRes; } - if (!mInitialized || (mSimulateRes != new_res)) + if (!mInitialized) { mSimulateRes = new_res; setAttributesOfAllSections(); @@ -644,7 +652,7 @@ void LLVolumeImplFlexible::doFlexibleRebuild() void LLVolumeImplFlexible::onSetScale(const LLVector3& scale, BOOL damped) { - setAttributesOfAllSections(); + setAttributesOfAllSections((LLVector3*) &scale); } BOOL LLVolumeImplFlexible::doUpdateGeometry(LLDrawable *drawable) diff --git a/indra/newview/llflexibleobject.h b/indra/newview/llflexibleobject.h index d4b79fb536..f711d0a57d 100644 --- a/indra/newview/llflexibleobject.h +++ b/indra/newview/llflexibleobject.h @@ -138,7 +138,7 @@ class LLVolumeImplFlexible : public LLVolumeInterface //-------------------------------------- // private methods //-------------------------------------- - void setAttributesOfAllSections (); + void setAttributesOfAllSections (LLVector3* inScale = NULL); void remapSections(LLFlexibleObjectSection *source, S32 source_sections, LLFlexibleObjectSection *dest, S32 dest_sections); diff --git a/indra/newview/llfloateranimpreview.cpp b/indra/newview/llfloateranimpreview.cpp index afa3fcddbe..aba92791e0 100644 --- a/indra/newview/llfloateranimpreview.cpp +++ b/indra/newview/llfloateranimpreview.cpp @@ -293,7 +293,6 @@ BOOL LLFloaterAnimPreview::postBuild() mAnimPreview = NULL; mMotionID.setNull(); childSetValue("bad_animation_text", getString("failed_to_initialize")); - setEnabled(FALSE); } } else @@ -1039,6 +1038,8 @@ BOOL LLPreviewAnimation::render() { mNeedsUpdate = FALSE; LLVOAvatar* avatarp = mDummyAvatar; + + gGL.start(); glMatrixMode(GL_PROJECTION); gGL.pushMatrix(); @@ -1109,7 +1110,6 @@ BOOL LLPreviewAnimation::render() avatarPoolp->renderAvatars(avatarp); // renders only one avatar } - gGL.start(); return TRUE; } diff --git a/indra/newview/llfloaterauction.cpp b/indra/newview/llfloaterauction.cpp index 25b275c8cb..2e971a8324 100644 --- a/indra/newview/llfloaterauction.cpp +++ b/indra/newview/llfloaterauction.cpp @@ -53,6 +53,7 @@ #include "llviewerdisplay.h" #include "llviewercontrol.h" #include "llui.h" +#include "llglimmediate.h" ///---------------------------------------------------------------------------- /// Local function declarations, constants, enums, and typedefs @@ -153,7 +154,7 @@ void LLFloaterAuction::draw() } { LLGLSUIDefault gls_ui; - glColor3f(1.f, 1.f, 1.f); + gGL.color3f(1.f, 1.f, 1.f); gl_draw_scaled_image(rect.mLeft, rect.mBottom, rect.getWidth(), diff --git a/indra/newview/llfloaterhud.cpp b/indra/newview/llfloaterhud.cpp index 7f311be9fd..12b1f0b4f1 100644 --- a/indra/newview/llfloaterhud.cpp +++ b/indra/newview/llfloaterhud.cpp @@ -29,16 +29,20 @@ LLFloaterHUD::LLFloaterHUD() : LLFloater("floater_hud"), mWebBrowser(0) { + // Create floater from its XML definition + LLUICtrlFactory::getInstance()->buildFloater(this, "floater_hud.xml"); + // Don't grab the focus as it will impede performing in-world actions // while using the HUD - setAutoFocus(FALSE); + setIsChrome(TRUE); + + // Chrome doesn't show the window title by default, but here we + // want to show it. + setTitleVisible(true); // Opaque background since we never get the focus setBackgroundOpaque(TRUE); - // Create floater from its XML definition - LLUICtrlFactory::getInstance()->buildFloater(this, "floater_hud.xml"); - // Position floater based on saved location LLRect saved_position_rect = gSavedSettings.getRect("FloaterHUDRect"); reshape(saved_position_rect.getWidth(), saved_position_rect.getHeight(), FALSE); @@ -47,12 +51,14 @@ LLFloaterHUD::LLFloaterHUD() mWebBrowser = getChild<LLWebBrowserCtrl>("floater_hud_browser" ); if (mWebBrowser) { - // Always refresh the browser - mWebBrowser->setAlwaysRefresh(true); - // Open links in internal browser mWebBrowser->setOpenInExternalBrowser(false); + // This is a "chrome" floater, so we don't want anything to + // take focus (as the user needs to be able to walk with + // arrow keys during tutorial). + mWebBrowser->setTakeFocusOnClick(false); + LLString language(gSavedSettings.getString("Language")); if(language == "default") { @@ -110,9 +116,3 @@ void LLFloaterHUD::close() { if (sInstance) sInstance->close(); } - -void LLFloaterHUD::onFocusReceived() -{ - // Never get the focus - setFocus(FALSE); -} diff --git a/indra/newview/llfloaterhud.h b/indra/newview/llfloaterhud.h index 9c1140986e..06da9fb44e 100644 --- a/indra/newview/llfloaterhud.h +++ b/indra/newview/llfloaterhud.h @@ -36,7 +36,7 @@ protected: LLWebBrowserCtrl* mWebBrowser; ///< the actual web browser control LLFloaterHUD(); ///< default constructor - virtual void onFocusReceived(); ///< called when we get the focus + private: static LLFloaterHUD* sInstance; }; diff --git a/indra/newview/llfloaterimagepreview.cpp b/indra/newview/llfloaterimagepreview.cpp index 51e67dcf2b..67f9ebe6b4 100644 --- a/indra/newview/llfloaterimagepreview.cpp +++ b/indra/newview/llfloaterimagepreview.cpp @@ -667,6 +667,8 @@ void LLImagePreviewAvatar::setPreviewTarget(const char* joint_name, const char* //----------------------------------------------------------------------------- BOOL LLImagePreviewAvatar::render() { + gGL.start(); + mNeedsUpdate = FALSE; LLVOAvatar* avatarp = mDummyAvatar; @@ -723,8 +725,6 @@ BOOL LLImagePreviewAvatar::render() avatarPoolp->renderAvatars(avatarp); // renders only one avatar } - gGL.start(); - return TRUE; } @@ -823,6 +823,8 @@ void LLImagePreviewSculpted::setPreviewTarget(LLImageRaw* imagep, F32 distance) //----------------------------------------------------------------------------- BOOL LLImagePreviewSculpted::render() { + gGL.start(); + mNeedsUpdate = FALSE; LLGLSUIDefault def; @@ -917,6 +919,8 @@ BOOL LLImagePreviewSculpted::render() delete [] normals; } + gGL.stop(); + return TRUE; } diff --git a/indra/newview/llglsandbox.cpp b/indra/newview/llglsandbox.cpp index 493b69f99e..f6d9ee9761 100644 --- a/indra/newview/llglsandbox.cpp +++ b/indra/newview/llglsandbox.cpp @@ -1006,17 +1006,17 @@ void LLViewerObjectList::renderObjectBeacons() return; } - S32 i; //const LLFontGL *font = LLResMgr::getInstance()->getRes(LLFONT_SANSSERIF); LLGLSUIDefault gls_ui; - S32 last_line_width = -1; - { LLGLSNoTexture gls_ui_no_texture; - gGL.begin(GL_LINES); - for (i = 0; i < mDebugBeacons.count(); i++) + + S32 last_line_width = -1; + // gGL.begin(GL_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; @@ -1024,8 +1024,11 @@ void LLViewerObjectList::renderObjectBeacons() S32 line_width = debug_beacon.mLineWidth; if (line_width != last_line_width) { - gGL.end(); - gGL.flush(); + if (i > 0) + { + gGL.end(); + gGL.flush(); + } glLineWidth( (F32)line_width ); last_line_width = line_width; gGL.begin(GL_LINES); @@ -1049,17 +1052,21 @@ void LLViewerObjectList::renderObjectBeacons() LLGLSNoTexture gls_ui_no_texture; LLGLDepthTest gls_depth(GL_TRUE); - gGL.begin(GL_LINES); - last_line_width = -1; - for (i = 0; i < mDebugBeacons.count(); i++) + S32 last_line_width = -1; + // gGL.begin(GL_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) { - gGL.end(); - gGL.flush(); + if (i > 0) + { + gGL.end(); + gGL.flush(); + } glLineWidth( (F32)line_width ); last_line_width = line_width; gGL.begin(GL_LINES); @@ -1076,12 +1083,12 @@ void LLViewerObjectList::renderObjectBeacons() draw_line_cube(0.10f, thisline); } + gGL.end(); - gGL.flush(); glLineWidth(1.f); - for (i = 0; i < mDebugBeacons.count(); i++) + for (S32 i = 0; i < mDebugBeacons.count(); i++) { LLDebugBeacon &debug_beacon = mDebugBeacons[i]; if (debug_beacon.mString == "") diff --git a/indra/newview/llimpanel.cpp b/indra/newview/llimpanel.cpp index 7eac7eb598..35cf36bd07 100644 --- a/indra/newview/llimpanel.cpp +++ b/indra/newview/llimpanel.cpp @@ -1061,7 +1061,7 @@ LLFloaterIMPanel::LLFloaterIMPanel( mSessionUUID(session_id), mVoiceChannel(NULL), mSessionInitialized(FALSE), - + mSessionStartMsgPos(0), mOtherParticipantUUID(other_participant_id), mDialog(dialog), mTyping(FALSE), @@ -1090,6 +1090,7 @@ LLFloaterIMPanel::LLFloaterIMPanel( mSessionUUID(session_id), mVoiceChannel(NULL), mSessionInitialized(FALSE), + mSessionStartMsgPos(0), mOtherParticipantUUID(other_participant_id), mDialog(dialog), mTyping(FALSE), @@ -1182,6 +1183,7 @@ void LLFloaterIMPanel::init(const LLString& session_label) //we don't need to need to wait for any responses //so we're already initialized mSessionInitialized = TRUE; + mSessionStartMsgPos = 0; } else { diff --git a/indra/newview/llmemoryview.cpp b/indra/newview/llmemoryview.cpp index 4b4b0a36dc..e124af1427 100644 --- a/indra/newview/llmemoryview.cpp +++ b/indra/newview/llmemoryview.cpp @@ -121,6 +121,8 @@ static const struct mtv_display_info mtv_display_table[] = { LLMemType::MTYPE_VERTEX_DATA, "Vertex Buffer", &LLColor4::blue3 }, { LLMemType::MTYPE_AVATAR, "Avatar", &LLColor4::purple1 }, { LLMemType::MTYPE_REGIONS, "Regions", &LLColor4::blue1 }, + { LLMemType::MTYPE_VOLUME, "Volume", &LLColor4::pink1 }, + { LLMemType::MTYPE_PRIMITIVE, "Profile", &LLColor4::pink2 }, { LLMemType::MTYPE_TEMP1, "Temp1", &LLColor4::red1 }, { LLMemType::MTYPE_TEMP2, "Temp2", &LLColor4::magenta1 }, { LLMemType::MTYPE_TEMP3, "Temp3", &LLColor4::red2 }, diff --git a/indra/newview/llpanellogin.cpp b/indra/newview/llpanellogin.cpp index b6805f42fa..a94fcf7bc2 100644 --- a/indra/newview/llpanellogin.cpp +++ b/indra/newview/llpanellogin.cpp @@ -951,6 +951,7 @@ void LLPanelLogin::loadLoginPage() { LLAppViewer::instance()->resetURIs(); gGridChoice = (EGridInfo)grid_index; + gSavedSettings.setString("GridChoice", gGridInfo[gGridChoice].mLabel); gViewerWindow->setMenuBackgroundColor(false, !LLAppViewer::instance()->isInProductionGrid()); gLoginMenuBarView->setBackgroundColor(gMenuBarView->getBackgroundColor()); diff --git a/indra/newview/llspatialpartition.cpp b/indra/newview/llspatialpartition.cpp index 331505166e..59fa2c4bcc 100644 --- a/indra/newview/llspatialpartition.cpp +++ b/indra/newview/llspatialpartition.cpp @@ -1906,9 +1906,8 @@ void pushVerts(LLDrawInfo* params, U32 mask) { LLRenderPass::applyModelMatrix(*params); params->mVertexBuffer->setBuffer(mask); - U16* indicesp = (U16*) params->mVertexBuffer->getIndicesPointer(); - glDrawRangeElements(params->mParticle ? GL_POINTS : GL_TRIANGLES, params->mStart, params->mEnd, params->mCount, - GL_UNSIGNED_SHORT, indicesp+params->mOffset); + params->mVertexBuffer->drawRange(params->mParticle ? LLVertexBuffer::POINTS : LLVertexBuffer::TRIANGLES, + params->mStart, params->mEnd, params->mCount, params->mOffset); } void pushVerts(LLSpatialGroup* group, U32 mask) @@ -1932,13 +1931,11 @@ void pushVerts(LLFace* face, U32 mask) if (buffer) { buffer->setBuffer(mask); - U16* indicesp = (U16*) buffer->getIndicesPointer(); U16 start = face->getGeomStart(); U16 end = start + face->getGeomCount()-1; U32 count = face->getIndicesCount(); U16 offset = face->getIndicesStart(); - - glDrawRangeElements(GL_TRIANGLES, start, end, count, GL_UNSIGNED_SHORT, indicesp + offset); + buffer->drawRange(LLVertexBuffer::TRIANGLES, start, end, count, offset); } } @@ -1948,9 +1945,7 @@ void pushBufferVerts(LLVertexBuffer* buffer, U32 mask) if (buffer) { buffer->setBuffer(mask); - U16* indicesp = (U16*) buffer->getIndicesPointer(); - glDrawRangeElements(GL_TRIANGLES, 0, buffer->getRequestedVerts(), buffer->getRequestedIndices(), - GL_UNSIGNED_SHORT, indicesp); + buffer->drawRange(LLVertexBuffer::TRIANGLES, 0, buffer->getRequestedVerts()-1, buffer->getRequestedIndices(), 0); } } @@ -1999,9 +1994,8 @@ void pushVertsColorCoded(LLSpatialGroup* group, U32 mask) LLRenderPass::applyModelMatrix(*params); glColor4f(colors[col].mV[0], colors[col].mV[1], colors[col].mV[2], 0.5f); params->mVertexBuffer->setBuffer(mask); - U16* indicesp = (U16*) params->mVertexBuffer->getIndicesPointer(); - glDrawRangeElements(params->mParticle ? GL_POINTS : GL_TRIANGLES, params->mStart, params->mEnd, params->mCount, - GL_UNSIGNED_SHORT, indicesp+params->mOffset); + params->mVertexBuffer->drawRange(params->mParticle ? LLVertexBuffer::POINTS : LLVertexBuffer::TRIANGLES, + params->mStart, params->mEnd, params->mCount, params->mOffset); col = (col+1)%col_count; } } @@ -2070,8 +2064,7 @@ void renderOctree(LLSpatialGroup* group) face->mVertexBuffer->setBuffer(LLVertexBuffer::MAP_VERTEX); //drawBox((face->mExtents[0] + face->mExtents[1])*0.5f, // (face->mExtents[1]-face->mExtents[0])*0.5f); - glDrawElements(GL_TRIANGLES, face->getIndicesCount(), GL_UNSIGNED_SHORT, - ((U16*) face->mVertexBuffer->getIndicesPointer())+face->getIndicesStart()); + face->mVertexBuffer->draw(LLVertexBuffer::TRIANGLES, face->getIndicesCount(), face->getIndicesStart()); } } diff --git a/indra/newview/lltexlayer.cpp b/indra/newview/lltexlayer.cpp index 7a2d232de6..f8931cb18b 100644 --- a/indra/newview/lltexlayer.cpp +++ b/indra/newview/lltexlayer.cpp @@ -244,6 +244,8 @@ BOOL LLTexLayerSetBuffer::render() BOOL upload_now = (gAgent.mNumPendingQueries == 0 && mNeedsUpload && mTexLayerSet->isLocalTextureDataFinal()); BOOL success = TRUE; + gGL.start(); + // Composite bump if( mBumpTexName ) { @@ -295,6 +297,8 @@ BOOL LLTexLayerSetBuffer::render() glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE ); gGL.blendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + gGL.stop(); + // we have valid texture data now mInitialized = TRUE; mNeedsUpdate = FALSE; diff --git a/indra/newview/lltoolmorph.cpp b/indra/newview/lltoolmorph.cpp index 265d1082d1..85ea204645 100644 --- a/indra/newview/lltoolmorph.cpp +++ b/indra/newview/lltoolmorph.cpp @@ -163,6 +163,8 @@ void LLVisualParamHint::preRender(BOOL clear_depth) //----------------------------------------------------------------------------- BOOL LLVisualParamHint::render() { + gGL.start(); + LLVisualParamReset::sDirty = TRUE; LLVOAvatar* avatarp = gAgent.getAvatarObject(); @@ -223,6 +225,7 @@ BOOL LLVisualParamHint::render() LLVector3 camera_pos = target_joint_pos + (camera_snapshot_offset * avatar_rotation); gGL.stop(); + LLViewerCamera::getInstance()->setAspect((F32)mWidth / (F32)mHeight); LLViewerCamera::getInstance()->setOriginAndLookAt( camera_pos, // camera @@ -238,7 +241,7 @@ BOOL LLVisualParamHint::render() avatarPoolp->renderAvatars(avatarp); // renders only one avatar } avatarp->setVisualParamWeight(mVisualParam, mLastParamWeight); - gGL.start(); + return TRUE; } diff --git a/indra/newview/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp index 3d0daa73a2..583139298f 100644 --- a/indra/newview/llviewerdisplay.cpp +++ b/indra/newview/llviewerdisplay.cpp @@ -886,6 +886,11 @@ void render_ui_and_swap() LLGLState::checkStates(); #endif + glPushMatrix(); + glLoadMatrixd(gGLLastModelView); + glh::matrix4f saved_view = glh_get_current_modelview(); + glh_set_current_modelview(glh_copy_matrix(gGLLastModelView)); + { BOOL to_texture = gPipeline.canUseVertexShaders() && LLPipeline::sRenderGlow && @@ -936,6 +941,9 @@ void render_ui_and_swap() LLVertexBuffer::stopRender(); } + + glh_set_current_modelview(saved_view); + glPopMatrix(); } void render_ui_and_swap_if_needed() @@ -1030,11 +1038,6 @@ void render_ui_3d() // so 3d elements requiring Z buffer are moved to LLDrawPoolHUD // - // Render selections - //glDisableClientState(GL_COLOR_ARRAY); - //glDisableClientState(GL_TEXTURE_COORD_ARRAY); - //glDisableClientState(GL_NORMAL_ARRAY); - ///////////////////////////////////////////////////////////// // // Render 2.5D elements (2D elements in the world) diff --git a/indra/newview/llviewerjointmesh.cpp b/indra/newview/llviewerjointmesh.cpp index fe00c25c63..ce23efe2f0 100644 --- a/indra/newview/llviewerjointmesh.cpp +++ b/indra/newview/llviewerjointmesh.cpp @@ -501,21 +501,6 @@ int compare_int(const void *a, const void *b) else return 0; } -void llDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) -{ - if (end-start+1 > (U32) gGLManager.mGLMaxVertexRange || - count > gGLManager.mGLMaxIndexRange) - { - glDrawElements(mode,count,type,indices); - } - else - { - glDrawRangeElements(mode,start,end,count,type,indices); - } - - gPipeline.addTrianglesDrawn(count/3); -} - //-------------------------------------------------------------------- // LLViewerJointMesh::drawShape() //-------------------------------------------------------------------- @@ -626,7 +611,7 @@ U32 LLViewerJointMesh::drawShape( F32 pixelArea, BOOL first_pass) U32 start = mMesh->mFaceVertexOffset; U32 end = start + mMesh->mFaceVertexCount - 1; U32 count = mMesh->mFaceIndexCount; - U16* indicesp = ((U16*) mFace->mVertexBuffer->getIndicesPointer()) + mMesh->mFaceIndexOffset; + U32 offset = mMesh->mFaceIndexOffset; if (mMesh->hasWeights()) { @@ -636,23 +621,21 @@ U32 LLViewerJointMesh::drawShape( F32 pixelArea, BOOL first_pass) { uploadJointMatrices(); } - llDrawRangeElements(GL_TRIANGLES, start, end, count, GL_UNSIGNED_SHORT, indicesp); - } - else - { - llDrawRangeElements(GL_TRIANGLES, start, end, count, GL_UNSIGNED_SHORT, indicesp); } + + mFace->mVertexBuffer->drawRange(LLVertexBuffer::TRIANGLES, start, end, count, offset); } else { glPushMatrix(); LLMatrix4 jointToWorld = getWorldMatrix(); glMultMatrixf((GLfloat*)jointToWorld.mMatrix); - llDrawRangeElements(GL_TRIANGLES, start, end, count, GL_UNSIGNED_SHORT, indicesp); + mFace->mVertexBuffer->drawRange(LLVertexBuffer::TRIANGLES, start, end, count, offset); glPopMatrix(); } + gPipeline.addTrianglesDrawn(count/3); - triangle_count += mMesh->mFaceIndexCount; + triangle_count += count; if (mTestImageName) { diff --git a/indra/newview/llviewerkeyboard.cpp b/indra/newview/llviewerkeyboard.cpp index bea4b910b6..e21c14637b 100644 --- a/indra/newview/llviewerkeyboard.cpp +++ b/indra/newview/llviewerkeyboard.cpp @@ -88,8 +88,6 @@ static void agent_handle_doubletap_run(EKeystate s, LLAgent::EDoubleTapRunMode m { if (KEYSTATE_UP == s) { - // Releasing a walk-key resets the double-tap timer - gAgent.mDoubleTapRunTimer.reset(); if (gAgent.mDoubleTapRunMode == mode && gAgent.getRunning() && !gAgent.getAlwaysRun()) @@ -98,17 +96,23 @@ static void agent_handle_doubletap_run(EKeystate s, LLAgent::EDoubleTapRunMode m gAgent.clearRunning(); gAgent.sendWalkRun(gAgent.getRunning()); } - gAgent.mDoubleTapRunMode = mode; } else if (gAllowTapTapHoldRun && KEYSTATE_DOWN == s && - gAgent.mDoubleTapRunMode == mode && - gAgent.mDoubleTapRunTimer.getElapsedTimeF32() < NUDGE_TIME) + !gAgent.getRunning()) { - // Same walk-key was pushed again quickly; this is a double-tap - // so engage temporary running. - gAgent.setRunning(); - gAgent.sendWalkRun(gAgent.getRunning()); + if (gAgent.mDoubleTapRunMode == mode && + gAgent.mDoubleTapRunTimer.getElapsedTimeF32() < NUDGE_TIME) + { + // Same walk-key was pushed again quickly; this is a + // double-tap so engage temporary running. + gAgent.setRunning(); + gAgent.sendWalkRun(gAgent.getRunning()); + } + + // Pressing any walk-key resets the double-tap timer + gAgent.mDoubleTapRunTimer.reset(); + gAgent.mDoubleTapRunMode = mode; } } diff --git a/indra/newview/llviewermenu.cpp b/indra/newview/llviewermenu.cpp index cfcd446b55..2cb60785d3 100644 --- a/indra/newview/llviewermenu.cpp +++ b/indra/newview/llviewermenu.cpp @@ -4897,12 +4897,12 @@ BOOL menu_check_build_tool( void* user_data ) void handle_reload_settings(void*) { gSavedSettings.resetToDefaults(); - gSavedSettings.loadFromFile(gSavedSettings.getString("ClientSettingsFile"), TRUE); + gSavedSettings.loadFromFile(gSavedSettings.getString("ClientSettingsFile")); llinfos << "Loading colors from colors.xml" << llendl; std::string color_file = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"colors.xml"); gColors.resetToDefaults(); - gColors.loadFromFile(color_file, FALSE, TYPE_COL4U); + gColors.loadFromFileLegacy(color_file, FALSE, TYPE_COL4U); } class LLWorldSetHomeLocation : public view_listener_t diff --git a/indra/newview/llviewermessage.cpp b/indra/newview/llviewermessage.cpp index 99f1af61e5..8afb0879a3 100644 --- a/indra/newview/llviewermessage.cpp +++ b/indra/newview/llviewermessage.cpp @@ -5063,7 +5063,7 @@ void callback_load_url(S32 option, void* data) if (0 == option) { - LLWeb::loadURL(infop->mUrl); + LLWeb::loadURLExternal(infop->mUrl); } delete infop; diff --git a/indra/newview/llvotree.cpp b/indra/newview/llvotree.cpp index 16555fdc9a..5f83dd4b06 100644 --- a/indra/newview/llvotree.cpp +++ b/indra/newview/llvotree.cpp @@ -821,7 +821,7 @@ U32 LLVOTree::drawBranchPipeline(LLMatrix4& matrix, U16* indicesp, S32 trunk_LOD glLoadMatrixf((F32*) scale_mat.mMatrix); glDrawElements(GL_TRIANGLES, sLODIndexCount[trunk_LOD], GL_UNSIGNED_SHORT, indicesp + sLODIndexOffset[trunk_LOD]); - + gPipeline.addTrianglesDrawn(LEAF_INDICES/3); stop_glerror(); ret += sLODIndexCount[trunk_LOD]; } @@ -871,7 +871,7 @@ U32 LLVOTree::drawBranchPipeline(LLMatrix4& matrix, U16* indicesp, S32 trunk_LOD glLoadMatrixf((F32*) scale_mat.mMatrix); glDrawElements(GL_TRIANGLES, LEAF_INDICES, GL_UNSIGNED_SHORT, indicesp); - + gPipeline.addTrianglesDrawn(LEAF_INDICES/3); stop_glerror(); ret += LEAF_INDICES; } @@ -896,7 +896,7 @@ U32 LLVOTree::drawBranchPipeline(LLMatrix4& matrix, U16* indicesp, S32 trunk_LOD glLoadMatrixf((F32*) scale_mat.mMatrix); glDrawElements(GL_TRIANGLES, LEAF_INDICES, GL_UNSIGNED_SHORT, indicesp); - + gPipeline.addTrianglesDrawn(LEAF_INDICES/3); stop_glerror(); ret += LEAF_INDICES; diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp index e7dbf0bfb8..a440ae2957 100644 --- a/indra/newview/llvovolume.cpp +++ b/indra/newview/llvovolume.cpp @@ -762,16 +762,30 @@ void LLVOVolume::sculpt() return; LLPointer<LLImageRaw> raw_image = new LLImageRaw(); - mSculptTexture->readBackRaw(discard_level, raw_image, FALSE); + BOOL is_valid = mSculptTexture->readBackRaw(discard_level, raw_image, FALSE); sculpt_height = raw_image->getHeight(); sculpt_width = raw_image->getWidth(); + sculpt_components = raw_image->getComponents(); - sculpt_components = raw_image->getComponents(); - sculpt_data = raw_image->getData(); - - llassert_always(raw_image->getDataSize() >= sculpt_height * sculpt_width * sculpt_components); - + if(is_valid) + { + is_valid = mSculptTexture->isValidForSculpt(discard_level, sculpt_width, sculpt_height, sculpt_components) ; + } + if(!is_valid) + { + sculpt_width = 0; + sculpt_height = 0; + sculpt_data = NULL ; + } + else + { + if (raw_image->getDataSize() < sculpt_height * sculpt_width * sculpt_components) + llerrs << "Sculpt: image data size = " << raw_image->getDataSize() + << " < " << sculpt_height << " x " << sculpt_width << " x " <<sculpt_components << llendl; + + sculpt_data = raw_image->getData(); + } getVolume()->sculpt(sculpt_width, sculpt_height, sculpt_components, sculpt_data, discard_level); } } diff --git a/indra/newview/llvowlsky.cpp b/indra/newview/llvowlsky.cpp index ca9f328e48..18c03d870f 100644 --- a/indra/newview/llvowlsky.cpp +++ b/indra/newview/llvowlsky.cpp @@ -484,17 +484,12 @@ BOOL LLVOWLSky::updateGeometry(LLDrawable * drawable) void LLVOWLSky::drawStars(void) { - glEnableClientState(GL_COLOR_ARRAY); - // render the stars as a sphere centered at viewer camera if (mStarsVerts.notNull()) { mStarsVerts->setBuffer(LLDrawPoolWLSky::STAR_VERTEX_DATA_MASK); - U16* indicesp = (U16*) mStarsVerts->getIndicesPointer(); - glDrawElements(GL_POINTS, getStarsNumIndices(), GL_UNSIGNED_SHORT, indicesp); + mStarsVerts->draw(LLVertexBuffer::POINTS, getStarsNumIndices(), 0); } - - glDisableClientState(GL_COLOR_ARRAY); } void LLVOWLSky::drawDome(void) @@ -507,19 +502,8 @@ void LLVOWLSky::drawDome(void) LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE); const U32 data_mask = LLDrawPoolWLSky::SKY_VERTEX_DATA_MASK; - - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - + #if DOME_SLICES - //mFanVerts->setBuffer(data_mask); - //glDrawRangeElements( - // GL_TRIANGLES, - // 0, getFanNumVerts()-1, getFanNumIndices(), - // GL_UNSIGNED_SHORT, - // mFanVerts->getIndicesPointer()); - - //gPipeline.addTrianglesDrawn(getFanNumIndices()/3); - std::vector< LLPointer<LLVertexBuffer> >::const_iterator strips_vbo_iter, end_strips; end_strips = mStripsVerts.end(); for(strips_vbo_iter = mStripsVerts.begin(); strips_vbo_iter != end_strips; ++strips_vbo_iter) @@ -528,13 +512,10 @@ void LLVOWLSky::drawDome(void) strips_segment->setBuffer(data_mask); - glDrawRangeElements( - //GL_TRIANGLES, - GL_TRIANGLE_STRIP, - 0, strips_segment->getRequestedVerts()-1, strips_segment->getRequestedIndices(), - GL_UNSIGNED_SHORT, - strips_segment->getIndicesPointer()); - + strips_segment->drawRange( + LLVertexBuffer::TRIANGLE_STRIP, + 0, strips_segment->getRequestedVerts()-1, strips_segment->getRequestedIndices(), + 0); gPipeline.addTrianglesDrawn(strips_segment->getRequestedIndices() - 2); } @@ -547,8 +528,6 @@ void LLVOWLSky::drawDome(void) mStripsVerts->getIndicesPointer()); #endif - glDisableClientState(GL_TEXTURE_COORD_ARRAY); - LLVertexBuffer::unbind(); } diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp index 4e679d28d5..69f2a4c4b7 100644 --- a/indra/newview/pipeline.cpp +++ b/indra/newview/pipeline.cpp @@ -168,7 +168,7 @@ glh::matrix4f glh_get_current_projection() return glh_copy_matrix(gGLProjection); } -void glh_copy_matrix(glh::matrix4f& src, GLdouble* dst) +void glh_copy_matrix(const glh::matrix4f& src, GLdouble* dst) { for (U32 i = 0; i < 16; i++) { @@ -176,7 +176,7 @@ void glh_copy_matrix(glh::matrix4f& src, GLdouble* dst) } } -void glh_set_current_modelview(glh::matrix4f& mat) +void glh_set_current_modelview(const glh::matrix4f& mat) { glh_copy_matrix(mat, gGLModelView); } @@ -2144,9 +2144,9 @@ void render_hud_elements() LLViewerParcelMgr::getInstance()->renderParcelCollision(); // Render debugging beacons. - gObjectList.renderObjectBeacons(); - LLHUDObject::renderAll(); - gObjectList.resetObjectBeacons(); + //gObjectList.renderObjectBeacons(); + //LLHUDObject::renderAll(); + //gObjectList.resetObjectBeacons(); } else if (gForceRenderLandFence) { @@ -2253,11 +2253,11 @@ void LLPipeline::renderGeom(LLCamera& camera, BOOL forceVBOUpdate) // // - glEnableClientState(GL_VERTEX_ARRAY); - stop_glerror(); gFrameStats.start(LLFrameStats::RENDER_SYNC); + glEnableClientState(GL_VERTEX_ARRAY); + // Do verification of GL state #ifndef LL_RELEASE_FOR_DOWNLOAD LLGLState::checkStates(); @@ -2377,10 +2377,10 @@ void LLPipeline::renderGeom(LLCamera& camera, BOOL forceVBOUpdate) break; } - p->resetTrianglesDrawn(); p->render(i); } poolp->endRenderPass(i); + LLVertexBuffer::unbind(); #ifndef LL_RELEASE_FOR_DOWNLOAD # if LL_DEBUG_GL GLint depth; @@ -2413,6 +2413,7 @@ void LLPipeline::renderGeom(LLCamera& camera, BOOL forceVBOUpdate) } } + LLVertexBuffer::unbind(); #ifndef LL_RELEASE_FOR_DOWNLOAD LLGLState::checkStates(); LLGLState::checkTextureChannels(); @@ -2452,6 +2453,15 @@ void LLPipeline::renderGeom(LLCamera& camera, BOOL forceVBOUpdate) LLVertexBuffer::stopRender(); LLVertexBuffer::unbind(); + if (!LLPipeline::sReflectionRender && gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_UI)) + { + gGL.start(); + // Render debugging beacons. + gObjectList.renderObjectBeacons(); + LLHUDObject::renderAll(); + gObjectList.resetObjectBeacons(); + gGL.stop(); + } //HACK: preserve/restore matrices around HUD render if (gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_HUD)) @@ -2472,15 +2482,9 @@ void LLPipeline::renderGeom(LLCamera& camera, BOOL forceVBOUpdate) void LLPipeline::renderGeomDeferred() { - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - glEnableClientState(GL_NORMAL_ARRAY); - glEnableClientState(GL_COLOR_ARRAY); gDeferredDiffuseProgram.bind(); gPipeline.renderObjects(LLRenderPass::PASS_SIMPLE, LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_NORMAL, TRUE); gDeferredDiffuseProgram.unbind(); - glDisableClientState(GL_COLOR_ARRAY); - glDisableClientState(GL_NORMAL_ARRAY); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); } void LLPipeline::addTrianglesDrawn(S32 count) @@ -2506,11 +2510,6 @@ void LLPipeline::renderDebug() gGL.start(); - // Disable all client state - //glDisableClientState(GL_TEXTURE_COORD_ARRAY); - //glDisableClientState(GL_NORMAL_ARRAY); - //glDisableClientState(GL_COLOR_ARRAY); - gGLLastMatrix = NULL; glLoadMatrixd(gGLModelView); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE); @@ -2603,8 +2602,6 @@ void LLPipeline::renderForSelect(std::set<LLViewerObject*>& objects) LLGLDepthTest gls_depth(GL_TRUE,GL_TRUE); disableLights(); - glEnableClientState ( GL_VERTEX_ARRAY ); - //for each drawpool #ifndef LL_RELEASE_FOR_DOWNLOAD LLGLState::checkStates(); @@ -2619,7 +2616,7 @@ void LLPipeline::renderForSelect(std::set<LLViewerObject*>& objects) { LLFacePool* face_pool = (LLFacePool*) poolp; face_pool->renderForSelect(); - + LLVertexBuffer::unbind(); gGLLastMatrix = NULL; glLoadMatrixd(gGLModelView); @@ -2635,7 +2632,6 @@ void LLPipeline::renderForSelect(std::set<LLViewerObject*>& objects) } } - glEnableClientState(GL_TEXTURE_COORD_ARRAY); LLGLEnable alpha_test(GL_ALPHA_TEST); if (gPickTransparent) { @@ -2759,10 +2755,10 @@ void LLPipeline::renderForSelect(std::set<LLViewerObject*>& objects) } glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); - glDisableClientState( GL_TEXTURE_COORD_ARRAY ); + LLVertexBuffer::unbind(); LLVertexBuffer::stopRender(); - + glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); } @@ -4866,6 +4862,12 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in) { if (LLPipeline::sWaterReflections && assertInitialized() && LLDrawPoolWater::sNeedsReflectionUpdate) { +#ifndef LL_RELEASE_FOR_DOWNLOAD + LLGLState::checkStates(); + LLGLState::checkTextureChannels(); + LLGLState::checkClientArrays(); +#endif + LLCamera camera = camera_in; camera.setFar(camera.getFar()*0.87654321f); LLPipeline::sReflectionRender = TRUE; @@ -5052,6 +5054,12 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in) LLDrawPoolWater::sNeedsDistortionUpdate = FALSE; LLViewerCamera::getInstance()->setUserClipPlane(LLPlane(-pnorm, -pd)); LLPipeline::sUseOcclusion = occlusion; + +#ifndef LL_RELEASE_FOR_DOWNLOAD + LLGLState::checkStates(); + LLGLState::checkTextureChannels(); + LLGLState::checkClientArrays(); +#endif } } diff --git a/indra/newview/pipeline.h b/indra/newview/pipeline.h index 6e02b55daf..7e38628d87 100644 --- a/indra/newview/pipeline.h +++ b/indra/newview/pipeline.h @@ -67,8 +67,9 @@ BOOL compute_min_max(LLMatrix4& box, LLVector2& min, LLVector2& max); // Shouldn bool LLRayAABB(const LLVector3 ¢er, const LLVector3 &size, const LLVector3& origin, const LLVector3& dir, LLVector3 &coord, F32 epsilon = 0); BOOL LLLineSegmentAABB(const LLVector3& start, const LLVector3& end, const LLVector3& center, const LLVector3& size); BOOL setup_hud_matrices(BOOL for_select); +glh::matrix4f glh_copy_matrix(GLdouble* src); glh::matrix4f glh_get_current_modelview(); -void glh_set_current_modelview(glh::matrix4f& mat); +void glh_set_current_modelview(const glh::matrix4f& mat); glh::matrix4f glh_get_current_projection(); void glh_set_current_projection(glh::matrix4f& mat); glh::matrix4f gl_ortho(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat znear, GLfloat zfar); |