llvoclouds.cpp

Go to the documentation of this file.

#include "llviewerprecompiledheaders.h"

#include "llvoclouds.h"

#include "lldrawpoolalpha.h"

#include "llviewercontrol.h"

#include "llagent.h"            // to get camera position
#include "lldrawable.h"
#include "llface.h"
#include "llprimitive.h"
#include "llsky.h"
#include "llviewercamera.h"
#include "llviewerimagelist.h"
#include "llviewerobjectlist.h"
#include "llviewerregion.h"
#include "llvosky.h"
#include "llworld.h"
#include "pipeline.h"
#include "viewer.h"

LLVOClouds::LLVOClouds(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
:       LLAlphaObject(id, LL_VO_CLOUDS, regionp)
{
        mCloudGroupp = NULL;
        mbCanSelect = FALSE;
        setNumTEs(1);
        LLViewerImage* image = gImageList.getImage(gCloudTextureID);
        image->setBoostLevel(LLViewerImage::BOOST_CLOUDS);
        setTEImage(0, image);
}


LLVOClouds::~LLVOClouds()
{
}


BOOL LLVOClouds::isActive() const
{
        return TRUE;
}


BOOL LLVOClouds::idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
{
        if (!(gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_CLOUDS)))
                return TRUE;
        
        // Set dirty flag (so renderer will rebuild primitive)
        if (mDrawable)
        {
                gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, TRUE);
        }
        return TRUE;
}


void LLVOClouds::setPixelAreaAndAngle(LLAgent &agent)
{
        mAppAngle = 50;
        mPixelArea = 1500*100;
}

void LLVOClouds::updateTextures(LLAgent &agent)
{
        getTEImage(0)->addTextureStats(mPixelArea);
}

LLDrawable* LLVOClouds::createDrawable(LLPipeline *pipeline)
{
        pipeline->allocDrawable(this);
        mDrawable->setLit(FALSE);
        mDrawable->setRenderType(LLPipeline::RENDER_TYPE_CLOUDS);

        return mDrawable;
}

BOOL LLVOClouds::updateGeometry(LLDrawable *drawable)
{
        LLFastTimer ftm(LLFastTimer::FTM_UPDATE_CLOUDS);
        if (!(gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_CLOUDS)))
                return TRUE;
        
        LLFace *facep;
        
        S32 num_faces = mCloudGroupp->getNumPuffs();

        if (num_faces > drawable->getNumFaces())
        {
                drawable->setNumFacesFast(num_faces, NULL, getTEImage(0));
        }

        mDepth = (getPositionAgent()-gCamera->getOrigin())*gCamera->getAtAxis();

        S32 face_indx = 0;
        for ( ; face_indx < num_faces; face_indx++)
        {
                facep = drawable->getFace(face_indx);
                if (!facep)
                {
                        llwarns << "No facep for index " << face_indx << llendl;
                        continue;
                }

                if (isParticle())
                {
                        facep->setSize(1,1);
                }
                else
                {
                        facep->setSize(4, 6);
                }
                facep->setTEOffset(face_indx);
                facep->setTexture(getTEImage(0));
                const LLCloudPuff &puff = mCloudGroupp->getPuff(face_indx);
                const LLVector3 puff_pos_agent = gAgent.getPosAgentFromGlobal(puff.getPositionGlobal());
                facep->mCenterLocal = puff_pos_agent;
        }
        for ( ; face_indx < drawable->getNumFaces(); face_indx++)
        {
                facep = drawable->getFace(face_indx);
                if (!facep)
                {
                        llwarns << "No facep for index " << face_indx << llendl;
                        continue;
                }

                facep->setTEOffset(face_indx);
                facep->setSize(0,0);
        }

        drawable->movePartition();

        return TRUE;
}

BOOL LLVOClouds::isParticle()
{
        return FALSE; // gGLManager.mHasPointParameters;
}

F32 LLVOClouds::getPartSize(S32 idx)
{
        return (CLOUD_PUFF_HEIGHT+CLOUD_PUFF_WIDTH)*0.5f;
}

void LLVOClouds::getGeometry(S32 te, 
                                                        LLStrider<LLVector3>& verticesp, 
                                                        LLStrider<LLVector3>& normalsp, 
                                                        LLStrider<LLVector2>& texcoordsp, 
                                                        LLStrider<LLColor4U>& colorsp, 
                                                        LLStrider<U32>& indicesp)
{

        if (te >= mCloudGroupp->getNumPuffs())
        {
                return;
        }

        LLDrawable* drawable = mDrawable;
        LLFace *facep = drawable->getFace(te);

        if (!facep->hasGeometry())
        {
                return;
        }
        
        LLVector3 normal(0.f,0.f,-1.f);

        const LLCloudPuff &puff = mCloudGroupp->getPuff(te);
        S32 index_offset = facep->getGeomIndex();
        LLColor4U color(255, 255, 255, (U8) (puff.getAlpha()*255));
        facep->setFaceColor(LLColor4(color));
                
        
        if (isParticle())
        {
                *verticesp++ = facep->mCenterLocal;
                *texcoordsp++ = LLVector2(0.5f, 0.5f);
                *colorsp++ = color;
                *normalsp++ = normal;
                *indicesp++ = facep->getGeomIndex();
        }
        else
        {
                LLVector3 up;
                LLVector3 right;
                LLVector3 at;

                const LLVector3& puff_pos_agent = facep->mCenterLocal;
                LLVector2 uvs[4];

                uvs[0].setVec(0.f, 1.f);
                uvs[1].setVec(0.f, 0.f);
                uvs[2].setVec(1.f, 1.f);
                uvs[3].setVec(1.f, 0.f);

                LLVector3 vtx[4];

                at = gCamera->getAtAxis();
                right = at % LLVector3(0.f, 0.f, 1.f);
                right.normVec();
                up = right % at;
                up.normVec();
                right *= 0.5f*CLOUD_PUFF_WIDTH;
                up *= 0.5f*CLOUD_PUFF_HEIGHT;;
                
                *colorsp++ = color;
                *colorsp++ = color;
                *colorsp++ = color;
                *colorsp++ = color;

                vtx[0] = puff_pos_agent - right + up;
                vtx[1] = puff_pos_agent - right - up;
                vtx[2] = puff_pos_agent + right + up;
                vtx[3] = puff_pos_agent + right - up;

                *verticesp++  = vtx[0];
                *verticesp++  = vtx[1];
                *verticesp++  = vtx[2];
                *verticesp++  = vtx[3];

                *texcoordsp++ = uvs[0];
                *texcoordsp++ = uvs[1];
                *texcoordsp++ = uvs[2];
                *texcoordsp++ = uvs[3];

                *normalsp++   = normal;
                *normalsp++   = normal;
                *normalsp++   = normal;
                *normalsp++   = normal;

                *indicesp++ = index_offset + 0;
                *indicesp++ = index_offset + 1;
                *indicesp++ = index_offset + 2;

                *indicesp++ = index_offset + 1;
                *indicesp++ = index_offset + 3;
                *indicesp++ = index_offset + 2;
        }
}

U32 LLVOClouds::getPartitionType() const
{
        return LLPipeline::PARTITION_CLOUD;
}

// virtual
void LLVOClouds::updateDrawable(BOOL force_damped)
{
        // Force an immediate rebuild on any update
        if (mDrawable.notNull())
        {
                mDrawable->updateXform(TRUE);
                gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_ALL, TRUE);
        }
        clearChanged(SHIFTED);
}

LLCloudPartition::LLCloudPartition()
{
        mDrawableType = LLPipeline::RENDER_TYPE_CLOUDS;
        mPartitionType = LLPipeline::PARTITION_CLOUD;
}

---