summaryrefslogtreecommitdiff
path: root/indra/newview/llvotree.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'indra/newview/llvotree.cpp')
-rw-r--r--indra/newview/llvotree.cpp1139
1 files changed, 761 insertions, 378 deletions
diff --git a/indra/newview/llvotree.cpp b/indra/newview/llvotree.cpp
index 2f81ae84ba..37a974be28 100644
--- a/indra/newview/llvotree.cpp
+++ b/indra/newview/llvotree.cpp
@@ -2,30 +2,25 @@
* @file llvotree.cpp
* @brief LLVOTree class implementation
*
- * $LicenseInfo:firstyear=2002&license=viewergpl$
- *
- * Copyright (c) 2002-2007, Linden Research, Inc.
- *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
* Second Life Viewer Source Code
- * The source code in this file ("Source Code") is provided by Linden Lab
- * to you under the terms of the GNU General Public License, version 2.0
- * ("GPL"), unless you have obtained a separate licensing agreement
- * ("Other License"), formally executed by you and Linden Lab. Terms of
- * the GPL can be found in doc/GPL-license.txt in this distribution, or
- * online at http://secondlife.com/developers/opensource/gplv2
+ * Copyright (C) 2010, Linden Research, Inc.
*
- * There are special exceptions to the terms and conditions of the GPL as
- * it is applied to this Source Code. View the full text of the exception
- * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at http://secondlife.com/developers/opensource/flossexception
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
*
- * By copying, modifying or distributing this software, you acknowledge
- * that you have read and understood your obligations described above,
- * and agree to abide by those obligations.
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
*
- * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
- * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
- * COMPLETENESS OR PERFORMANCE.
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
@@ -43,18 +38,18 @@
#include "material_codes.h"
#include "object_flags.h"
-#include "llagent.h"
+#include "llagentcamera.h"
#include "lldrawable.h"
#include "llface.h"
#include "llviewercamera.h"
-#include "llviewerimagelist.h"
+#include "llviewertexturelist.h"
#include "llviewerobjectlist.h"
#include "llviewerregion.h"
#include "llworld.h"
#include "noise.h"
#include "pipeline.h"
#include "llspatialpartition.h"
-#include "llviewerwindow.h"
+#include "llnotificationsutil.h"
extern LLPipeline gPipeline;
@@ -65,12 +60,14 @@ const F32 LEAF_TOP = 1.0f;
const F32 LEAF_BOTTOM = 0.52f;
const F32 LEAF_WIDTH = 1.f;
-S32 LLVOTree::sLODVertexOffset[4];
-S32 LLVOTree::sLODVertexCount[4];
-S32 LLVOTree::sLODIndexOffset[4];
-S32 LLVOTree::sLODIndexCount[4];
-S32 LLVOTree::sLODSlices[4] = {10, 5, 4, 3};
-F32 LLVOTree::sLODAngles[4] = {30.f, 20.f, 15.f, 0.f};
+const S32 LLVOTree::sMAX_NUM_TREE_LOD_LEVELS = 4 ;
+
+S32 LLVOTree::sLODVertexOffset[sMAX_NUM_TREE_LOD_LEVELS];
+S32 LLVOTree::sLODVertexCount[sMAX_NUM_TREE_LOD_LEVELS];
+S32 LLVOTree::sLODIndexOffset[sMAX_NUM_TREE_LOD_LEVELS];
+S32 LLVOTree::sLODIndexCount[sMAX_NUM_TREE_LOD_LEVELS];
+S32 LLVOTree::sLODSlices[sMAX_NUM_TREE_LOD_LEVELS] = {10, 5, 4, 3};
+F32 LLVOTree::sLODAngles[sMAX_NUM_TREE_LOD_LEVELS] = {30.f, 20.f, 15.f, F_ALMOST_ZERO};
F32 LLVOTree::sTreeFactor = 1.f;
@@ -85,6 +82,7 @@ LLVOTree::LLVOTree(const LLUUID &id, const LLPCode pcode, LLViewerRegion *region
mSpecies = 0;
mFrameCount = 0;
mWind = mRegionp->mWind.getVelocity(getPositionRegion());
+ mTrunkLOD = 0;
}
@@ -97,6 +95,12 @@ LLVOTree::~LLVOTree()
}
}
+//static
+bool LLVOTree::isTreeRenderingStopped()
+{
+ return LLVOTree::sTreeFactor < LLVOTree::sLODAngles[sMAX_NUM_TREE_LOD_LEVELS - 1] ;
+}
+
// static
void LLVOTree::initClass()
{
@@ -232,7 +236,7 @@ void LLVOTree::initClass()
if (!success)
{
- LLString name;
+ std::string name;
static LLStdStringHandle name_string = LLXmlTree::addAttributeString("name");
tree_def->getFastAttributeString(name_string, name);
llwarns << "Incomplete definition of tree " << name << llendl;
@@ -240,24 +244,22 @@ void LLVOTree::initClass()
}
BOOL have_all_trees = TRUE;
- LLString err;
- char buffer[10]; /* Flawfinder: ignore */
+ std::string err;
for (S32 i=0;i<sMaxTreeSpecies;++i)
{
if (!sSpeciesTable.count(i))
{
- snprintf(buffer,10," %d",i); /* Flawfinder: ignore */
- err.append(buffer);
+ err.append(llformat(" %d",i));
have_all_trees = FALSE;
}
}
if (!have_all_trees)
{
- LLStringBase<char>::format_map_t args;
- args["[SPECIES]"] = err;
- gViewerWindow->alertXml("ErrorUndefinedTrees", args );
+ LLSD args;
+ args["SPECIES"] = err;
+ LLNotificationsUtil::add("ErrorUndefinedTrees", args);
}
};
@@ -275,9 +277,9 @@ U32 LLVOTree::processUpdateMessage(LLMessageSystem *mesgsys,
// Do base class updates...
U32 retval = LLViewerObject::processUpdateMessage(mesgsys, user_data, block_num, update_type, dp);
- if ( (getVelocity().magVecSquared() > 0.f)
- ||(getAcceleration().magVecSquared() > 0.f)
- ||(getAngularVelocity().magVecSquared() > 0.f))
+ if ( (getVelocity().lengthSquared() > 0.f)
+ ||(getAcceleration().lengthSquared() > 0.f)
+ ||(getAngularVelocity().lengthSquared() > 0.f))
{
llinfos << "ACK! Moving tree!" << llendl;
setVelocity(LLVector3::zero);
@@ -311,11 +313,10 @@ U32 LLVOTree::processUpdateMessage(LLMessageSystem *mesgsys,
//
// Load Species-Specific data
//
- mTreeImagep = gImageList.getImage(sSpeciesTable[mSpecies]->mTextureID);
- if (mTreeImagep)
- {
- mTreeImagep->bindTexture(0);
- }
+ static const S32 MAX_TREE_TEXTURE_VIRTURE_SIZE_RESET_INTERVAL = 32 ; //frames.
+ mTreeImagep = LLViewerTextureManager::getFetchedTexture(sSpeciesTable[mSpecies]->mTextureID, TRUE, LLViewerTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
+ mTreeImagep->setMaxVirtualSizeResetInterval(MAX_TREE_TEXTURE_VIRTURE_SIZE_RESET_INTERVAL); //allow to wait for at most 16 frames to reset virtual size.
+
mBranchLength = sSpeciesTable[mSpecies]->mBranchLength;
mTrunkLength = sSpeciesTable[mSpecies]->mTrunkLength;
mLeafScale = sSpeciesTable[mSpecies]->mLeafScale;
@@ -329,6 +330,9 @@ U32 LLVOTree::processUpdateMessage(LLMessageSystem *mesgsys,
mBillboardRatio = sSpeciesTable[mSpecies]->mBillboardRatio;
mTrunkAspect = sSpeciesTable[mSpecies]->mTrunkAspect;
mBranchAspect = sSpeciesTable[mSpecies]->mBranchAspect;
+
+ // position change not caused by us, etc. make sure to rebuild.
+ gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL);
return retval;
}
@@ -344,41 +348,93 @@ BOOL LLVOTree::idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
return TRUE;
}
- F32 mass_inv;
-
- // For all tree objects, update the trunk bending with the current wind
- // Walk sprite list in order away from viewer
- if (!(mFrameCount % FRAMES_PER_WIND_UPDATE))
+ if (gSavedSettings.getBOOL("RenderAnimateTrees"))
{
- // If needed, Get latest wind for this tree
- mWind = mRegionp->mWind.getVelocity(getPositionRegion());
+ F32 mass_inv;
+
+ // For all tree objects, update the trunk bending with the current wind
+ // Walk sprite list in order away from viewer
+ if (!(mFrameCount % FRAMES_PER_WIND_UPDATE))
+ {
+ // If needed, Get latest wind for this tree
+ mWind = mRegionp->mWind.getVelocity(getPositionRegion());
+ }
+ mFrameCount++;
+
+ mass_inv = 1.f/(5.f + mDepth*mBranches*0.2f);
+ mTrunkVel += (mWind * mass_inv * TREE_WIND_SENSITIVITY); // Pull in direction of wind
+ mTrunkVel -= (mTrunkBend * mass_inv * TREE_TRUNK_STIFFNESS); // Restoring force in direction of trunk
+ mTrunkBend += mTrunkVel;
+ mTrunkVel *= 0.99f; // Add damping
+
+ if (mTrunkBend.length() > 1.f)
+ {
+ mTrunkBend.normalize();
+ }
+
+ if (mTrunkVel.length() > 1.f)
+ {
+ mTrunkVel.normalize();
+ }
}
- mFrameCount++;
- mass_inv = 1.f/(5.f + mDepth*mBranches*0.2f);
- mTrunkVel += (mWind * mass_inv * TREE_WIND_SENSITIVITY); // Pull in direction of wind
- mTrunkVel -= (mTrunkBend * mass_inv * TREE_TRUNK_STIFFNESS); // Restoring force in direction of trunk
- mTrunkBend += mTrunkVel;
- mTrunkVel *= 0.99f; // Add damping
+ S32 trunk_LOD = sMAX_NUM_TREE_LOD_LEVELS ;
+ F32 app_angle = getAppAngle()*LLVOTree::sTreeFactor;
- if (mTrunkBend.magVec() > 1.f)
+ for (S32 j = 0; j < sMAX_NUM_TREE_LOD_LEVELS; j++)
{
- mTrunkBend.normVec();
- }
+ if (app_angle > LLVOTree::sLODAngles[j])
+ {
+ trunk_LOD = j;
+ break;
+ }
+ }
- if (mTrunkVel.magVec() > 1.f)
+ if (!gSavedSettings.getBOOL("RenderAnimateTrees"))
{
- mTrunkVel.normVec();
+ if (mReferenceBuffer.isNull())
+ {
+ gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL, TRUE);
+ }
+ else if (trunk_LOD != mTrunkLOD)
+ {
+ gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL, FALSE);
+ }
+ else
+ {
+ // we're not animating but we may *still* need to
+ // regenerate the mesh if we moved, since position
+ // and rotation are baked into the mesh.
+ // *TODO: I don't know what's so special about trees
+ // that they don't get REBUILD_POSITION automatically
+ // at a higher level.
+ const LLVector3 &this_position = getPositionAgent();
+ if (this_position != mLastPosition)
+ {
+ gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_POSITION);
+ mLastPosition = this_position;
+ }
+ else
+ {
+ const LLQuaternion &this_rotation = getRotation();
+
+ if (this_rotation != mLastRotation)
+ {
+ gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_POSITION);
+ mLastRotation = this_rotation;
+ }
+ }
+ }
}
+ mTrunkLOD = trunk_LOD;
+
return TRUE;
}
-
const F32 TREE_BLEND_MIN = 1.f;
const F32 TREE_BLEND_RANGE = 1.f;
-
void LLVOTree::render(LLAgent &agent)
{
}
@@ -386,23 +442,35 @@ void LLVOTree::render(LLAgent &agent)
void LLVOTree::setPixelAreaAndAngle(LLAgent &agent)
{
- // First calculate values as for any other object (for mAppAngle)
- LLViewerObject::setPixelAreaAndAngle(agent);
-
- // Re-calculate mPixelArea accurately
+ LLVector3 center = getPositionAgent();//center of tree.
+ LLVector3 viewer_pos_agent = gAgentCamera.getCameraPositionAgent();
+ LLVector3 lookAt = center - viewer_pos_agent;
+ F32 dist = lookAt.normVec() ;
+ F32 cos_angle_to_view_dir = lookAt * LLViewerCamera::getInstance()->getXAxis() ;
- // This should be the camera's center, as soon as we move to all region-local.
- LLVector3 relative_position = getPositionAgent() - agent.getCameraPositionAgent();
- F32 range = relative_position.magVec(); // ugh, square root
+ F32 range = dist - getMinScale()/2;
+ if (range < F_ALMOST_ZERO || isHUDAttachment()) // range == zero
+ {
+ mAppAngle = 180.f;
+ }
+ else
+ {
+ mAppAngle = (F32) atan2( getMaxScale(), range) * RAD_TO_DEG;
+ }
F32 max_scale = mBillboardScale * getMaxScale();
F32 area = max_scale * (max_scale*mBillboardRatio);
-
// Compute pixels per meter at the given range
- F32 pixels_per_meter = gCamera->getViewHeightInPixels() /
- (tan(gCamera->getView()) * range);
+ F32 pixels_per_meter = LLViewerCamera::getInstance()->getViewHeightInPixels() / (tan(LLViewerCamera::getInstance()->getView()) * dist);
+ mPixelArea = pixels_per_meter * pixels_per_meter * area ;
+
+ F32 importance = LLFace::calcImportanceToCamera(cos_angle_to_view_dir, dist) ;
+ mPixelArea = LLFace::adjustPixelArea(importance, mPixelArea) ;
+ if (mPixelArea > LLViewerCamera::getInstance()->getScreenPixelArea())
+ {
+ mAppAngle = 180.f;
+ }
- mPixelArea = (pixels_per_meter) * (pixels_per_meter) * area;
#if 0
// mAppAngle is a bit of voodoo;
// use the one calculated LLViewerObject::setPixelAreaAndAngle above
@@ -411,7 +479,7 @@ void LLVOTree::setPixelAreaAndAngle(LLAgent &agent)
#endif
}
-void LLVOTree::updateTextures(LLAgent &agent)
+void LLVOTree::updateTextures()
{
if (mTreeImagep)
{
@@ -448,341 +516,615 @@ LLDrawable* LLVOTree::createDrawable(LLPipeline *pipeline)
const S32 LEAF_INDICES = 24;
const S32 LEAF_VERTICES = 16;
+static LLFastTimer::DeclareTimer FTM_UPDATE_TREE("Update Tree");
+
BOOL LLVOTree::updateGeometry(LLDrawable *drawable)
{
- LLFastTimer ftm(LLFastTimer::FTM_UPDATE_TREE);
- const F32 SRR3 = 0.577350269f; // sqrt(1/3)
- const F32 SRR2 = 0.707106781f; // sqrt(1/2)
- U32 i, j;
+ LLFastTimer ftm(FTM_UPDATE_TREE);
+
+ if(mTrunkLOD >= sMAX_NUM_TREE_LOD_LEVELS) //do not display the tree.
+ {
+ mReferenceBuffer = NULL ;
+ mDrawable->getFace(0)->mVertexBuffer = NULL ;
+ return TRUE ;
+ }
+
+ if (mReferenceBuffer.isNull() || mDrawable->getFace(0)->mVertexBuffer.isNull())
+ {
+ const F32 SRR3 = 0.577350269f; // sqrt(1/3)
+ const F32 SRR2 = 0.707106781f; // sqrt(1/2)
+ U32 i, j;
+
+ U32 slices = MAX_SLICES;
+
+ S32 max_indices = LEAF_INDICES;
+ S32 max_vertices = LEAF_VERTICES;
+ S32 lod;
+
+ LLFace *face = drawable->getFace(0);
- U32 slices = MAX_SLICES;
+ face->mCenterAgent = getPositionAgent();
+ face->mCenterLocal = face->mCenterAgent;
- S32 max_indices = LEAF_INDICES;
- S32 max_vertices = LEAF_VERTICES;
- S32 lod;
+ for (lod = 0; lod < sMAX_NUM_TREE_LOD_LEVELS; lod++)
+ {
+ slices = sLODSlices[lod];
+ sLODVertexOffset[lod] = max_vertices;
+ sLODVertexCount[lod] = slices*slices;
+ sLODIndexOffset[lod] = max_indices;
+ sLODIndexCount[lod] = (slices-1)*(slices-1)*6;
+ max_indices += sLODIndexCount[lod];
+ max_vertices += sLODVertexCount[lod];
+ }
+
+ mReferenceBuffer = new LLVertexBuffer(LLDrawPoolTree::VERTEX_DATA_MASK, gSavedSettings.getBOOL("RenderAnimateTrees") ? GL_STATIC_DRAW_ARB : 0);
+ mReferenceBuffer->allocateBuffer(max_vertices, max_indices, TRUE);
+
+ LLStrider<LLVector3> vertices;
+ LLStrider<LLVector3> normals;
+ LLStrider<LLVector2> tex_coords;
+ LLStrider<U16> indicesp;
+
+ mReferenceBuffer->getVertexStrider(vertices);
+ mReferenceBuffer->getNormalStrider(normals);
+ mReferenceBuffer->getTexCoord0Strider(tex_coords);
+ mReferenceBuffer->getIndexStrider(indicesp);
+
+ S32 vertex_count = 0;
+ S32 index_count = 0;
+
+ // First leaf
+ *(normals++) = LLVector3(-SRR2, -SRR2, 0.f);
+ *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_BOTTOM);
+ *(vertices++) = LLVector3(-0.5f*LEAF_WIDTH, 0.f, 0.f);
+ vertex_count++;
+
+ *(normals++) = LLVector3(SRR3, -SRR3, SRR3);
+ *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_TOP);
+ *(vertices++) = LLVector3(0.5f*LEAF_WIDTH, 0.f, 1.f);
+ vertex_count++;
+
+ *(normals++) = LLVector3(-SRR3, -SRR3, SRR3);
+ *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_TOP);
+ *(vertices++) = LLVector3(-0.5f*LEAF_WIDTH, 0.f, 1.f);
+ vertex_count++;
+
+ *(normals++) = LLVector3(SRR2, -SRR2, 0.f);
+ *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_BOTTOM);
+ *(vertices++) = LLVector3(0.5f*LEAF_WIDTH, 0.f, 0.f);
+ vertex_count++;
+
+
+ *(indicesp++) = 0;
+ index_count++;
+ *(indicesp++) = 1;
+ index_count++;
+ *(indicesp++) = 2;
+ index_count++;
+
+ *(indicesp++) = 0;
+ index_count++;
+ *(indicesp++) = 3;
+ index_count++;
+ *(indicesp++) = 1;
+ index_count++;
+
+ // Same leaf, inverse winding/normals
+ *(normals++) = LLVector3(-SRR2, SRR2, 0.f);
+ *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_BOTTOM);
+ *(vertices++) = LLVector3(-0.5f*LEAF_WIDTH, 0.f, 0.f);
+ vertex_count++;
+
+ *(normals++) = LLVector3(SRR3, SRR3, SRR3);
+ *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_TOP);
+ *(vertices++) = LLVector3(0.5f*LEAF_WIDTH, 0.f, 1.f);
+ vertex_count++;
+
+ *(normals++) = LLVector3(-SRR3, SRR3, SRR3);
+ *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_TOP);
+ *(vertices++) = LLVector3(-0.5f*LEAF_WIDTH, 0.f, 1.f);
+ vertex_count++;
+
+ *(normals++) = LLVector3(SRR2, SRR2, 0.f);
+ *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_BOTTOM);
+ *(vertices++) = LLVector3(0.5f*LEAF_WIDTH, 0.f, 0.f);
+ vertex_count++;
+
+ *(indicesp++) = 4;
+ index_count++;
+ *(indicesp++) = 6;
+ index_count++;
+ *(indicesp++) = 5;
+ index_count++;
+
+ *(indicesp++) = 4;
+ index_count++;
+ *(indicesp++) = 5;
+ index_count++;
+ *(indicesp++) = 7;
+ index_count++;
+
+
+ // next leaf
+ *(normals++) = LLVector3(SRR2, -SRR2, 0.f);
+ *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_BOTTOM);
+ *(vertices++) = LLVector3(0.f, -0.5f*LEAF_WIDTH, 0.f);
+ vertex_count++;
+
+ *(normals++) = LLVector3(SRR3, SRR3, SRR3);
+ *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_TOP);
+ *(vertices++) = LLVector3(0.f, 0.5f*LEAF_WIDTH, 1.f);
+ vertex_count++;
+
+ *(normals++) = LLVector3(SRR3, -SRR3, SRR3);
+ *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_TOP);
+ *(vertices++) = LLVector3(0.f, -0.5f*LEAF_WIDTH, 1.f);
+ vertex_count++;
+
+ *(normals++) = LLVector3(SRR2, SRR2, 0.f);
+ *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_BOTTOM);
+ *(vertices++) = LLVector3(0.f, 0.5f*LEAF_WIDTH, 0.f);
+ vertex_count++;
+
+ *(indicesp++) = 8;
+ index_count++;
+ *(indicesp++) = 9;
+ index_count++;
+ *(indicesp++) = 10;
+ index_count++;
+
+ *(indicesp++) = 8;
+ index_count++;
+ *(indicesp++) = 11;
+ index_count++;
+ *(indicesp++) = 9;
+ index_count++;
+
+
+ // other side of same leaf
+ *(normals++) = LLVector3(-SRR2, -SRR2, 0.f);
+ *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_BOTTOM);
+ *(vertices++) = LLVector3(0.f, -0.5f*LEAF_WIDTH, 0.f);
+ vertex_count++;
+
+ *(normals++) = LLVector3(-SRR3, SRR3, SRR3);
+ *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_TOP);
+ *(vertices++) = LLVector3(0.f, 0.5f*LEAF_WIDTH, 1.f);
+ vertex_count++;
+
+ *(normals++) = LLVector3(-SRR3, -SRR3, SRR3);
+ *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_TOP);
+ *(vertices++) = LLVector3(0.f, -0.5f*LEAF_WIDTH, 1.f);
+ vertex_count++;
+
+ *(normals++) = LLVector3(-SRR2, SRR2, 0.f);
+ *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_BOTTOM);
+ *(vertices++) = LLVector3(0.f, 0.5f*LEAF_WIDTH, 0.f);
+ vertex_count++;
+
+ *(indicesp++) = 12;
+ index_count++;
+ *(indicesp++) = 14;
+ index_count++;
+ *(indicesp++) = 13;
+ index_count++;
+
+ *(indicesp++) = 12;
+ index_count++;
+ *(indicesp++) = 13;
+ index_count++;
+ *(indicesp++) = 15;
+ index_count++;
+
+ // Generate geometry for the cylinders
+
+ // Different LOD's
+
+ // Generate the vertices
+ // Generate the indices
+
+ for (lod = 0; lod < sMAX_NUM_TREE_LOD_LEVELS; lod++)
+ {
+ slices = sLODSlices[lod];
+ F32 base_radius = 0.65f;
+ F32 top_radius = base_radius * sSpeciesTable[mSpecies]->mTaper;
+ //llinfos << "Species " << ((U32) mSpecies) << ", taper = " << sSpeciesTable[mSpecies].mTaper << llendl;
+ //llinfos << "Droop " << mDroop << ", branchlength: " << mBranchLength << llendl;
+ F32 angle = 0;
+ F32 angle_inc = 360.f/(slices-1);
+ F32 z = 0.f;
+ F32 z_inc = 1.f;
+ if (slices > 3)
+ {
+ z_inc = 1.f/(slices - 3);
+ }
+ F32 radius = base_radius;
+
+ F32 x1,y1;
+ F32 noise_scale = sSpeciesTable[mSpecies]->mNoiseMag;
+ LLVector3 nvec;
+
+ const F32 cap_nudge = 0.1f; // Height to 'peak' the caps on top/bottom of branch
- LLFace *face = drawable->getFace(0);
+ const S32 fractal_depth = 5;
+ F32 nvec_scale = 1.f * sSpeciesTable[mSpecies]->mNoiseScale;
+ F32 nvec_scalez = 4.f * sSpeciesTable[mSpecies]->mNoiseScale;
+
+ F32 tex_z_repeat = sSpeciesTable[mSpecies]->mRepeatTrunkZ;
+
+ F32 start_radius;
+ F32 nangle = 0;
+ F32 height = 1.f;
+ F32 r0;
+
+ for (i = 0; i < slices; i++)
+ {
+ if (i == 0)
+ {
+ z = - cap_nudge;
+ r0 = 0.0;
+ }
+ else if (i == (slices - 1))
+ {
+ z = 1.f + cap_nudge;//((i - 2) * z_inc) + cap_nudge;
+ r0 = 0.0;
+ }
+ else
+ {
+ z = (i - 1) * z_inc;
+ r0 = base_radius + (top_radius - base_radius)*z;
+ }
- face->mCenterAgent = getPositionAgent();
- face->mCenterLocal = face->mCenterAgent;
+ for (j = 0; j < slices; j++)
+ {
+ if (slices - 1 == j)
+ {
+ angle = 0.f;
+ }
+ else
+ {
+ angle = j*angle_inc;
+ }
+
+ nangle = angle;
+
+ x1 = cos(angle * DEG_TO_RAD);
+ y1 = sin(angle * DEG_TO_RAD);
+ LLVector2 tc;
+ // This isn't totally accurate. Should compute based on slope as well.
+ start_radius = r0 * (1.f + 1.2f*fabs(z - 0.66f*height)/height);
+ nvec.set( cos(nangle * DEG_TO_RAD)*start_radius*nvec_scale,
+ sin(nangle * DEG_TO_RAD)*start_radius*nvec_scale,
+ z*nvec_scalez);
+ // First and last slice at 0 radius (to bring in top/bottom of structure)
+ radius = start_radius + turbulence3((F32*)&nvec.mV, (F32)fractal_depth)*noise_scale;
+
+ if (slices - 1 == j)
+ {
+ // Not 0.5 for slight slop factor to avoid edges on leaves
+ tc = LLVector2(0.490f, (1.f - z/2.f)*tex_z_repeat);
+ }
+ else
+ {
+ tc = LLVector2((angle/360.f)*0.5f, (1.f - z/2.f)*tex_z_repeat);
+ }
+
+ *(vertices++) = LLVector3(x1*radius, y1*radius, z);
+ *(normals++) = LLVector3(x1, y1, 0.f);
+ *(tex_coords++) = tc;
+ vertex_count++;
+ }
+ }
- for (lod = 0; lod < 4; lod++)
+ for (i = 0; i < (slices - 1); i++)
+ {
+ for (j = 0; j < (slices - 1); j++)
+ {
+ S32 x1_offset = j+1;
+ if ((j+1) == slices)
+ {
+ x1_offset = 0;
+ }
+ // Generate the matching quads
+ *(indicesp) = j + (i*slices) + sLODVertexOffset[lod];
+ llassert(*(indicesp) < (U32)max_vertices);
+ indicesp++;
+ index_count++;
+ *(indicesp) = x1_offset + ((i+1)*slices) + sLODVertexOffset[lod];
+ llassert(*(indicesp) < (U32)max_vertices);
+ indicesp++;
+ index_count++;
+ *(indicesp) = j + ((i+1)*slices) + sLODVertexOffset[lod];
+ llassert(*(indicesp) < (U32)max_vertices);
+ indicesp++;
+ index_count++;
+
+ *(indicesp) = j + (i*slices) + sLODVertexOffset[lod];
+ llassert(*(indicesp) < (U32)max_vertices);
+ indicesp++;
+ index_count++;
+ *(indicesp) = x1_offset + (i*slices) + sLODVertexOffset[lod];
+ llassert(*(indicesp) < (U32)max_vertices);
+ indicesp++;
+ index_count++;
+ *(indicesp) = x1_offset + ((i+1)*slices) + sLODVertexOffset[lod];
+ llassert(*(indicesp) < (U32)max_vertices);
+ indicesp++;
+ index_count++;
+ }
+ }
+ slices /= 2;
+ }
+
+ mReferenceBuffer->setBuffer(0);
+ llassert(vertex_count == max_vertices);
+ llassert(index_count == max_indices);
+ }
+
+ if (gSavedSettings.getBOOL("RenderAnimateTrees"))
+ {
+ mDrawable->getFace(0)->mVertexBuffer = mReferenceBuffer;
+ }
+ else
{
- slices = sLODSlices[lod];
- sLODVertexOffset[lod] = max_vertices;
- sLODVertexCount[lod] = slices*slices;
- sLODIndexOffset[lod] = max_indices;
- sLODIndexCount[lod] = (slices-1)*(slices-1)*6;
- max_indices += sLODIndexCount[lod];
- max_vertices += sLODVertexCount[lod];
+ //generate tree mesh
+ updateMesh();
}
+
+ return TRUE;
+}
+void LLVOTree::updateMesh()
+{
+ LLMatrix4 matrix;
+
+ // Translate to tree base HACK - adjustment in Z plants tree underground
+ const LLVector3 &pos_agent = getPositionAgent();
+ //glTranslatef(pos_agent.mV[VX], pos_agent.mV[VY], pos_agent.mV[VZ] - 0.1f);
+ LLMatrix4 trans_mat;
+ trans_mat.setTranslation(pos_agent.mV[VX], pos_agent.mV[VY], pos_agent.mV[VZ] - 0.1f);
+ trans_mat *= matrix;
+
+ // Rotate to tree position and bend for current trunk/wind
+ // Note that trunk stiffness controls the amount of bend at the trunk as
+ // opposed to the crown of the tree
+ //
+ const F32 TRUNK_STIFF = 22.f;
+
+ LLQuaternion rot =
+ LLQuaternion(mTrunkBend.magVec()*TRUNK_STIFF*DEG_TO_RAD, LLVector4(mTrunkBend.mV[VX], mTrunkBend.mV[VY], 0)) *
+ LLQuaternion(90.f*DEG_TO_RAD, LLVector4(0,0,1)) *
+ getRotation();
+
+ LLMatrix4 rot_mat(rot);
+ rot_mat *= trans_mat;
+
+ F32 radius = getScale().magVec()*0.05f;
+ LLMatrix4 scale_mat;
+ scale_mat.mMatrix[0][0] =
+ scale_mat.mMatrix[1][1] =
+ scale_mat.mMatrix[2][2] = radius;
+
+ scale_mat *= rot_mat;
+
+// const F32 THRESH_ANGLE_FOR_BILLBOARD = 15.f;
+// const F32 BLEND_RANGE_FOR_BILLBOARD = 3.f;
+
+ F32 droop = mDroop + 25.f*(1.f - mTrunkBend.magVec());
+
+ S32 stop_depth = 0;
+ F32 alpha = 1.0;
+
+ U32 vert_count = 0;
+ U32 index_count = 0;
+
+ calcNumVerts(vert_count, index_count, mTrunkLOD, stop_depth, mDepth, mTrunkDepth, mBranches);
+
+ LLFace* facep = mDrawable->getFace(0);
+ facep->mVertexBuffer = new LLVertexBuffer(LLDrawPoolTree::VERTEX_DATA_MASK, GL_STATIC_DRAW_ARB);
+ facep->mVertexBuffer->allocateBuffer(vert_count, index_count, TRUE);
+
LLStrider<LLVector3> vertices;
LLStrider<LLVector3> normals;
LLStrider<LLVector2> tex_coords;
- LLStrider<U16> indicesp;
-
- face->setSize(max_vertices, max_indices);
+ LLStrider<U16> indices;
+ U16 idx_offset = 0;
- face->mVertexBuffer = new LLVertexBuffer(LLDrawPoolTree::VERTEX_DATA_MASK, GL_STATIC_DRAW_ARB);
- face->mVertexBuffer->allocateBuffer(max_vertices, max_indices, TRUE);
- face->setGeomIndex(0);
- face->setIndicesIndex(0);
+ facep->mVertexBuffer->getVertexStrider(vertices);
+ facep->mVertexBuffer->getNormalStrider(normals);
+ facep->mVertexBuffer->getTexCoord0Strider(tex_coords);
+ facep->mVertexBuffer->getIndexStrider(indices);
- face->getGeometry(vertices, normals, tex_coords, indicesp);
+ genBranchPipeline(vertices, normals, tex_coords, indices, idx_offset, scale_mat, mTrunkLOD, stop_depth, mDepth, mTrunkDepth, 1.0, mTwist, droop, mBranches, alpha);
+ mReferenceBuffer->setBuffer(0);
+ facep->mVertexBuffer->setBuffer(0);
- S32 vertex_count = 0;
- S32 index_count = 0;
+}
+
+void LLVOTree::appendMesh(LLStrider<LLVector3>& vertices,
+ LLStrider<LLVector3>& normals,
+ LLStrider<LLVector2>& tex_coords,
+ LLStrider<U16>& indices,
+ U16& cur_idx,
+ LLMatrix4& matrix,
+ LLMatrix4& norm_mat,
+ S32 vert_start,
+ S32 vert_count,
+ S32 index_count,
+ S32 index_offset)
+{
+ LLStrider<LLVector3> v;
+ LLStrider<LLVector3> n;
+ LLStrider<LLVector2> t;
+ LLStrider<U16> idx;
+
+ mReferenceBuffer->getVertexStrider(v);
+ mReferenceBuffer->getNormalStrider(n);
+ mReferenceBuffer->getTexCoord0Strider(t);
+ mReferenceBuffer->getIndexStrider(idx);
- // First leaf
- *(normals++) = LLVector3(-SRR2, -SRR2, 0.f);
- *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_BOTTOM);
- *(vertices++) = LLVector3(-0.5f*LEAF_WIDTH, 0.f, 0.f);
- vertex_count++;
-
- *(normals++) = LLVector3(SRR3, -SRR3, SRR3);
- *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_TOP);
- *(vertices++) = LLVector3(0.5f*LEAF_WIDTH, 0.f, 1.f);
- vertex_count++;
-
- *(normals++) = LLVector3(-SRR3, -SRR3, SRR3);
- *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_TOP);
- *(vertices++) = LLVector3(-0.5f*LEAF_WIDTH, 0.f, 1.f);
- vertex_count++;
-
- *(normals++) = LLVector3(SRR2, -SRR2, 0.f);
- *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_BOTTOM);
- *(vertices++) = LLVector3(0.5f*LEAF_WIDTH, 0.f, 0.f);
- vertex_count++;
-
-
- *(indicesp++) = 0;
- index_count++;
- *(indicesp++) = 1;
- index_count++;
- *(indicesp++) = 2;
- index_count++;
-
- *(indicesp++) = 0;
- index_count++;
- *(indicesp++) = 3;
- index_count++;
- *(indicesp++) = 1;
- index_count++;
-
- // Same leaf, inverse winding/normals
- *(normals++) = LLVector3(-SRR2, SRR2, 0.f);
- *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_BOTTOM);
- *(vertices++) = LLVector3(-0.5f*LEAF_WIDTH, 0.f, 0.f);
- vertex_count++;
-
- *(normals++) = LLVector3(SRR3, SRR3, SRR3);
- *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_TOP);
- *(vertices++) = LLVector3(0.5f*LEAF_WIDTH, 0.f, 1.f);
- vertex_count++;
-
- *(normals++) = LLVector3(-SRR3, SRR3, SRR3);
- *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_TOP);
- *(vertices++) = LLVector3(-0.5f*LEAF_WIDTH, 0.f, 1.f);
- vertex_count++;
-
- *(normals++) = LLVector3(SRR2, SRR2, 0.f);
- *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_BOTTOM);
- *(vertices++) = LLVector3(0.5f*LEAF_WIDTH, 0.f, 0.f);
- vertex_count++;
-
- *(indicesp++) = 4;
- index_count++;
- *(indicesp++) = 6;
- index_count++;
- *(indicesp++) = 5;
- index_count++;
-
- *(indicesp++) = 4;
- index_count++;
- *(indicesp++) = 5;
- index_count++;
- *(indicesp++) = 7;
- index_count++;
-
-
- // next leaf
- *(normals++) = LLVector3(SRR2, -SRR2, 0.f);
- *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_BOTTOM);
- *(vertices++) = LLVector3(0.f, -0.5f*LEAF_WIDTH, 0.f);
- vertex_count++;
-
- *(normals++) = LLVector3(SRR3, SRR3, SRR3);
- *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_TOP);
- *(vertices++) = LLVector3(0.f, 0.5f*LEAF_WIDTH, 1.f);
- vertex_count++;
-
- *(normals++) = LLVector3(SRR3, -SRR3, SRR3);
- *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_TOP);
- *(vertices++) = LLVector3(0.f, -0.5f*LEAF_WIDTH, 1.f);
- vertex_count++;
-
- *(normals++) = LLVector3(SRR2, SRR2, 0.f);
- *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_BOTTOM);
- *(vertices++) = LLVector3(0.f, 0.5f*LEAF_WIDTH, 0.f);
- vertex_count++;
-
- *(indicesp++) = 8;
- index_count++;
- *(indicesp++) = 9;
- index_count++;
- *(indicesp++) = 10;
- index_count++;
-
- *(indicesp++) = 8;
- index_count++;
- *(indicesp++) = 11;
- index_count++;
- *(indicesp++) = 9;
- index_count++;
-
-
- // other side of same leaf
- *(normals++) = LLVector3(-SRR2, -SRR2, 0.f);
- *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_BOTTOM);
- *(vertices++) = LLVector3(0.f, -0.5f*LEAF_WIDTH, 0.f);
- vertex_count++;
-
- *(normals++) = LLVector3(-SRR3, SRR3, SRR3);
- *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_TOP);
- *(vertices++) = LLVector3(0.f, 0.5f*LEAF_WIDTH, 1.f);
- vertex_count++;
-
- *(normals++) = LLVector3(-SRR3, -SRR3, SRR3);
- *(tex_coords++) = LLVector2(LEAF_LEFT, LEAF_TOP);
- *(vertices++) = LLVector3(0.f, -0.5f*LEAF_WIDTH, 1.f);
- vertex_count++;
-
- *(normals++) = LLVector3(-SRR2, SRR2, 0.f);
- *(tex_coords++) = LLVector2(LEAF_RIGHT, LEAF_BOTTOM);
- *(vertices++) = LLVector3(0.f, 0.5f*LEAF_WIDTH, 0.f);
- vertex_count++;
-
- *(indicesp++) = 12;
- index_count++;
- *(indicesp++) = 14;
- index_count++;
- *(indicesp++) = 13;
- index_count++;
-
- *(indicesp++) = 12;
- index_count++;
- *(indicesp++) = 13;
- index_count++;
- *(indicesp++) = 15;
- index_count++;
-
- // Generate geometry for the cylinders
-
- // Different LOD's
-
- // Generate the vertices
- // Generate the indices
-
- for (lod = 0; lod < 4; lod++)
+ //copy/transform vertices into mesh - check
+ for (S32 i = 0; i < vert_count; i++)
+ {
+ U16 index = vert_start + i;
+ *vertices++ = v[index] * matrix;
+ LLVector3 norm = n[index] * norm_mat;
+ norm.normalize();
+ *normals++ = norm;
+ *tex_coords++ = t[index];
+ }
+
+ //copy offset indices into mesh - check
+ for (S32 i = 0; i < index_count; i++)
{
- slices = sLODSlices[lod];
- F32 base_radius = 0.65f;
- F32 top_radius = base_radius * sSpeciesTable[mSpecies]->mTaper;
- //llinfos << "Species " << ((U32) mSpecies) << ", taper = " << sSpeciesTable[mSpecies].mTaper << llendl;
- //llinfos << "Droop " << mDroop << ", branchlength: " << mBranchLength << llendl;
- F32 angle = 0;
- F32 angle_inc = 360.f/(slices-1);
- F32 z = 0.f;
- F32 z_inc = 1.f;
- if (slices > 3)
+ U16 index = index_offset + i;
+ if (idx[index] >= vert_start + vert_count ||
+ idx[index] < vert_start)
{
- z_inc = 1.f/(slices - 3);
+ llerrs << "WTF?" << llendl;
}
- F32 radius = base_radius;
-
- F32 x1,y1;
- F32 noise_scale = sSpeciesTable[mSpecies]->mNoiseMag;
- LLVector3 nvec;
-
- const F32 cap_nudge = 0.1f; // Height to 'peak' the caps on top/bottom of branch
-
- const S32 fractal_depth = 5;
- F32 nvec_scale = 1.f * sSpeciesTable[mSpecies]->mNoiseScale;
- F32 nvec_scalez = 4.f * sSpeciesTable[mSpecies]->mNoiseScale;
+ *indices++ = idx[index]-vert_start+cur_idx;
+ }
- F32 tex_z_repeat = sSpeciesTable[mSpecies]->mRepeatTrunkZ;
+ //increment index offset - check
+ cur_idx += vert_count;
+}
+
+
+void LLVOTree::genBranchPipeline(LLStrider<LLVector3>& vertices,
+ LLStrider<LLVector3>& normals,
+ LLStrider<LLVector2>& tex_coords,
+ LLStrider<U16>& indices,
+ U16& index_offset,
+ LLMatrix4& matrix,
+ S32 trunk_LOD,
+ S32 stop_level,
+ U16 depth,
+ U16 trunk_depth,
+ F32 scale,
+ F32 twist,
+ F32 droop,
+ F32 branches,
+ F32 alpha)
+{
+ //
+ // Generates a tree mesh by recursing, generating branches and then a 'leaf' texture.
+
+ static F32 constant_twist;
+ static F32 width = 0;
- F32 start_radius;
- F32 nangle = 0;
- F32 height = 1.f;
- F32 r0;
+ F32 length = ((trunk_depth || (scale == 1.f))? mTrunkLength:mBranchLength);
+ F32 aspect = ((trunk_depth || (scale == 1.f))? mTrunkAspect:mBranchAspect);
+
+ constant_twist = 360.f/branches;
- for (i = 0; i < slices; i++)
+ if (stop_level >= 0)
+ {
+ if (depth > stop_level)
{
- if (i == 0)
{
- z = - cap_nudge;
- r0 = 0.0;
+ llassert(sLODIndexCount[trunk_LOD] > 0);
+ width = scale * length * aspect;
+ LLMatrix4 scale_mat;
+ scale_mat.mMatrix[0][0] = width;
+ scale_mat.mMatrix[1][1] = width;
+ scale_mat.mMatrix[2][2] = scale*length;
+ scale_mat *= matrix;
+
+ glh::matrix4f norm((F32*) scale_mat.mMatrix);
+ LLMatrix4 norm_mat = LLMatrix4(norm.inverse().transpose().m);
+
+ norm_mat.invert();
+ appendMesh(vertices, normals, tex_coords, indices, index_offset, scale_mat, norm_mat,
+ sLODVertexOffset[trunk_LOD], sLODVertexCount[trunk_LOD], sLODIndexCount[trunk_LOD], sLODIndexOffset[trunk_LOD]);
}
- else if (i == (slices - 1))
+
+ // Recurse to create more branches
+ for (S32 i=0; i < (S32)branches; i++)
{
- z = 1.f + cap_nudge;//((i - 2) * z_inc) + cap_nudge;
- r0 = 0.0;
+ LLMatrix4 trans_mat;
+ trans_mat.setTranslation(0,0,scale*length);
+ trans_mat *= matrix;
+
+ LLQuaternion rot =
+ LLQuaternion(20.f*DEG_TO_RAD, LLVector4(0.f, 0.f, 1.f)) *
+ LLQuaternion(droop*DEG_TO_RAD, LLVector4(0.f, 1.f, 0.f)) *
+ LLQuaternion(((constant_twist + ((i%2==0)?twist:-twist))*i)*DEG_TO_RAD, LLVector4(0.f, 0.f, 1.f));
+
+ LLMatrix4 rot_mat(rot);
+ rot_mat *= trans_mat;
+
+ genBranchPipeline(vertices, normals, tex_coords, indices, index_offset, rot_mat, trunk_LOD, stop_level, depth - 1, 0, scale*mScaleStep, twist, droop, branches, alpha);
}
- else
+ // Recurse to continue trunk
+ if (trunk_depth)
{
- z = (i - 1) * z_inc;
- r0 = base_radius + (top_radius - base_radius)*z;
- }
+ LLMatrix4 trans_mat;
+ trans_mat.setTranslation(0,0,scale*length);
+ trans_mat *= matrix;
- for (j = 0; j < slices; j++)
+ LLMatrix4 rot_mat(70.5f*DEG_TO_RAD, LLVector4(0,0,1));
+ rot_mat *= trans_mat; // rotate a bit around Z when ascending
+ genBranchPipeline(vertices, normals, tex_coords, indices, index_offset, rot_mat, trunk_LOD, stop_level, depth, trunk_depth-1, scale*mScaleStep, twist, droop, branches, alpha);
+ }
+ }
+ else
+ {
+ //
+ // Append leaves as two 90 deg crossed quads with leaf textures
+ //
{
- if (slices - 1 == j)
- {
- angle = 0.f;
- }
- else
- {
- angle = j*angle_inc;
- }
-
- nangle = angle;
-
- x1 = cos(angle * DEG_TO_RAD);
- y1 = sin(angle * DEG_TO_RAD);
- LLVector2 tc;
- // This isn't totally accurate. Should compute based on slope as well.
- start_radius = r0 * (1.f + 1.2f*fabs(z - 0.66f*height)/height);
- nvec.setVec( cos(nangle * DEG_TO_RAD)*start_radius*nvec_scale,
- sin(nangle * DEG_TO_RAD)*start_radius*nvec_scale,
- z*nvec_scalez);
- // First and last slice at 0 radius (to bring in top/bottom of structure)
- radius = start_radius + turbulence3((F32*)&nvec.mV, (F32)fractal_depth)*noise_scale;
+ LLMatrix4 scale_mat;
+ scale_mat.mMatrix[0][0] =
+ scale_mat.mMatrix[1][1] =
+ scale_mat.mMatrix[2][2] = scale*mLeafScale;
- if (slices - 1 == j)
- {
- // Not 0.5 for slight slop factor to avoid edges on leaves
- tc = LLVector2(0.490f, (1.f - z/2.f)*tex_z_repeat);
- }
- else
- {
- tc = LLVector2((angle/360.f)*0.5f, (1.f - z/2.f)*tex_z_repeat);
- }
+ scale_mat *= matrix;
- *(vertices++) = LLVector3(x1*radius, y1*radius, z);
- *(normals++) = LLVector3(x1, y1, 0.f);
- *(tex_coords++) = tc;
- vertex_count++;
+ glh::matrix4f norm((F32*) scale_mat.mMatrix);
+ LLMatrix4 norm_mat = LLMatrix4(norm.inverse().transpose().m);
+
+ appendMesh(vertices, normals, tex_coords, indices, index_offset, scale_mat, norm_mat, 0, LEAF_VERTICES, LEAF_INDICES, 0);
}
}
+ }
+}
+
- for (i = 0; i < (slices - 1); i++)
+
+void LLVOTree::calcNumVerts(U32& vert_count, U32& index_count, S32 trunk_LOD, S32 stop_level, U16 depth, U16 trunk_depth, F32 branches)
+{
+ if (stop_level >= 0)
+ {
+ if (depth > stop_level)
{
- for (j = 0; j < (slices - 1); j++)
+ index_count += sLODIndexCount[trunk_LOD];
+ vert_count += sLODVertexCount[trunk_LOD];
+
+ // Recurse to create more branches
+ for (S32 i=0; i < (S32)branches; i++)
{
- S32 x1_offset = j+1;
- if ((j+1) == slices)
- {
- x1_offset = 0;
- }
- // Generate the matching quads
- *(indicesp) = j + (i*slices) + sLODVertexOffset[lod];
- llassert(*(indicesp) < (U32)max_vertices);
- indicesp++;
- index_count++;
- *(indicesp) = x1_offset + ((i+1)*slices) + sLODVertexOffset[lod];
- llassert(*(indicesp) < (U32)max_vertices);
- indicesp++;
- index_count++;
- *(indicesp) = j + ((i+1)*slices) + sLODVertexOffset[lod];
- llassert(*(indicesp) < (U32)max_vertices);
- indicesp++;
- index_count++;
-
- *(indicesp) = j + (i*slices) + sLODVertexOffset[lod];
- llassert(*(indicesp) < (U32)max_vertices);
- indicesp++;
- index_count++;
- *(indicesp) = x1_offset + (i*slices) + sLODVertexOffset[lod];
- llassert(*(indicesp) < (U32)max_vertices);
- indicesp++;
- index_count++;
- *(indicesp) = x1_offset + ((i+1)*slices) + sLODVertexOffset[lod];
- llassert(*(indicesp) < (U32)max_vertices);
- indicesp++;
- index_count++;
+ calcNumVerts(vert_count, index_count, trunk_LOD, stop_level, depth - 1, 0, branches);
+ }
+
+ // Recurse to continue trunk
+ if (trunk_depth)
+ {
+ calcNumVerts(vert_count, index_count, trunk_LOD, stop_level, depth, trunk_depth-1, branches);
}
}
- slices /= 2;
+ else
+ {
+ index_count += LEAF_INDICES;
+ vert_count += LEAF_VERTICES;
+ }
+ }
+ else
+ {
+ index_count += LEAF_INDICES;
+ vert_count += LEAF_VERTICES;
}
-
- face->mVertexBuffer->setBuffer(0);
- llassert(vertex_count == max_vertices);
- llassert(index_count == max_indices);
-
- return TRUE;
}
U32 LLVOTree::drawBranchPipeline(LLMatrix4& matrix, U16* indicesp, S32 trunk_LOD, S32 stop_level, U16 depth, U16 trunk_depth, F32 scale, F32 twist, F32 droop, F32 branches, F32 alpha)
@@ -821,7 +1163,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);
stop_glerror();
ret += sLODIndexCount[trunk_LOD];
}
@@ -871,7 +1213,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);
stop_glerror();
ret += LEAF_INDICES;
}
@@ -896,7 +1238,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);
stop_glerror();
ret += LEAF_INDICES;
@@ -920,7 +1262,7 @@ void LLVOTree::updateRadius()
void LLVOTree::updateSpatialExtents(LLVector3& newMin, LLVector3& newMax)
{
- F32 radius = getScale().magVec()*0.05f;
+ F32 radius = getScale().length()*0.05f;
LLVector3 center = getRenderPosition();
F32 sz = mBillboardScale*mBillboardRatio*radius*0.5f;
@@ -928,20 +1270,61 @@ void LLVOTree::updateSpatialExtents(LLVector3& newMin, LLVector3& newMax)
center += LLVector3(0, 0, size.mV[2]) * getRotation();
- newMin.setVec(center-size);
- newMax.setVec(center+size);
+ newMin.set(center-size);
+ newMax.set(center+size);
mDrawable->setPositionGroup(center);
}
+BOOL LLVOTree::lineSegmentIntersect(const LLVector3& start, const LLVector3& end, S32 face, BOOL pick_transparent, S32 *face_hitp,
+ LLVector3* intersection,LLVector2* tex_coord, LLVector3* normal, LLVector3* bi_normal)
+
+{
+
+ if (!lineSegmentBoundingBox(start, end))
+ {
+ return FALSE;
+ }
+
+ const LLVector3* ext = mDrawable->getSpatialExtents();
+
+ LLVector3 center = (ext[1]+ext[0])*0.5f;
+ LLVector3 size = (ext[1]-ext[0]);
+
+ LLQuaternion quat = getRotation();
+
+ center -= LLVector3(0,0,size.magVec() * 0.25f)*quat;
+
+ size.scaleVec(LLVector3(0.25f, 0.25f, 1.f));
+ size.mV[0] = llmin(size.mV[0], 1.f);
+ size.mV[1] = llmin(size.mV[1], 1.f);
+
+ LLVector3 pos, norm;
+
+ if (linesegment_tetrahedron(start, end, center, size, quat, pos, norm))
+ {
+ if (intersection)
+ {
+ *intersection = pos;
+ }
+
+ if (normal)
+ {
+ *normal = norm;
+ }
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
U32 LLVOTree::getPartitionType() const
{
return LLViewerRegion::PARTITION_TREE;
}
LLTreePartition::LLTreePartition()
-: LLSpatialPartition(0)
+: LLSpatialPartition(0, FALSE, 0)
{
- mRenderByGroup = FALSE;
mDrawableType = LLPipeline::RENDER_TYPE_TREE;
mPartitionType = LLViewerRegion::PARTITION_TREE;
mSlopRatio = 0.f;
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-14 00:06:31 +0000