llcape.cpp

Go to the documentation of this file.

#include "llviewerprecompiledheaders.h"

#include "llcape.h"

#include "llglheaders.h"
#include "llsphere.h"
#include "llrand.h"
#include "llvoavatar.h"
#include "llagent.h"
#include "llviewerobject.h"
#include "llimagegl.h"
#include "llviewerimagelist.h"
#include "llviewercontrol.h"
#include "llflexibleobject.h"

const int _X_                   = 0;
const int _Y_                   = 1;
const int _Z_                   = 2;
const F32 ONE_HALF              = 0.5f;
const F32 STRAND_VISUALIZATION_ANCHOR_BALL_RADIUS = 0.01f;

//-----------------------------------------------
// constructor
//-----------------------------------------------
LLVOCloth::LLVOCloth(const LLUUID &id, const LLPCode type, LLViewerRegion *regionp)
        : LLViewerObject(id, type, regionp)
{
        mAttributes.mTextureFileName                                            = CLOTH_DEFAULT_TEXTURE_FILENAME;
        mAttributes.mTextureIndex                                                       = CLOTH_DEFAULT_TEXTURE_INDEX;
        mAttributes.mNumStrands                                                         = CLOTH_DEFAULT_NUM_STRANDS;
        mAttributes.mNumSegments                                                        = CLOTH_DEFAULT_NUM_SEGMENTS;
        mAttributes.mVisualizeStrands                                           = CLOTH_DEFAULT_VISUALIZE_STRANDS;
        mAttributes.mVisualizeAvCollisionSphere                         = CLOTH_DEFAULT_VISUALIZE_COLLISION_SPHERE;
        mAttributes.mWidth                                                                      = CLOTH_DEFAULT_WIDTH;
        mAttributes.mLength                                                                     = CLOTH_DEFAULT_LENGTH;
        mAttributes.mPitch                                                                      = CLOTH_DEFAULT_PITCH;
        mAttributes.mGravity                                                            = CLOTH_DEFAULT_GRAVITY;
        mAttributes.mTension                                                            = CLOTH_DEFAULT_TENSION;
        mAttributes.mAirFriction                                                        = CLOTH_DEFAULT_AIR_FRICTION;
        mAttributes.mWindSensitivity                                            = CLOTH_DEFAULT_WIND_SENSITIVITY;
        mAttributes.mCircleWrapAmount                                           = CLOTH_DEFAULT_CIRCLE_WRAP_AMOUNT;
        mAttributes.mUsingAvatarCollisionSphere                         = CLOTH_DEFAULT_USING_AVATAR_COLLISION_SPHERE;          
        //mAttributes.mAvatarCollisionSpherePositionOffset      = CLOTH_DEFAULT_AVATAR_COLLISION_SPHERE_POSITION_OFFSET;
        mAttributes.mAvatarCollisionSphereRadius                        = CLOTH_DEFAULT_AVATAR_COLLISION_SPHERE_RADIUS;
        mAttributes.mAvatarCollisionSphereRightOffset           = CLOTH_DEFAULT_AVATAR_COLLISION_SPHERE_RIGHT_OFFSET;
        mAttributes.mAvatarCollisionSphereUpOffset                      = CLOTH_DEFAULT_AVATAR_COLLISION_SPHERE_UP_OFFSET;
        mAttributes.mAvatarCollisionSphereForwardOffset         = CLOTH_DEFAULT_AVATAR_COLLISION_SPHERE_FORWARD_OFFSET;

        generateStrands();

}//------------------------------------------------------------------------------


//------------------------------------------------------------------------------
// this method is only called when attributes of the cloth are set, 
// and so it is not so important to try optimized it. 
//------------------------------------------------------------------------------
void LLVOCloth::generateStrands()
{
        LLFlexibleObjectData strandAttributes;

        bool    oddNumStrands   = (bool)( mAttributes.mNumStrands % 2 );
        F32             piOver180               = F_PI / 180.0f;
        F32             x                               = 0.0f;
        F32             y                               = 0.0f;
        F32             startAngle              = -mAttributes.mCircleWrapAmount * 180.0f;
        F32             angleDelta              = ( mAttributes.mCircleWrapAmount * 360.0f )    / (F32)( mAttributes.mNumStrands - 1 );
        F32             subWidth                =   mAttributes.mWidth / (F32)( mAttributes.mNumStrands - 1 );

        F32     angle = 0.0f;

        if ( mAttributes.mNumStrands > 2 ) 
        {
                angle = startAngle;
        }

        //-------------------------------------------
        // displace x and y to start the process of 
        // iterating through the positional offsets
        //-------------------------------------------
        if ( ! oddNumStrands )
        {
                y += subWidth * ONE_HALF;
        }

        int half = mAttributes.mNumStrands / 2;
        for ( int s=0; s<half; s ++)
        {
                if ( mAttributes.mNumStrands > 2 ) 
                {
                        angle += angleDelta;
                }

                F32 r = angle * piOver180;
                x -= subWidth * sin(r);
                y -= subWidth * cos(r);
        }


        if ( mAttributes.mNumStrands > 2 )
                {
                        angle = startAngle;
                }
        else
                {
                        angle = 0.0f;
                }

                
        for ( int s=0; s<mAttributes.mNumStrands; s ++)
        {
                //strandAttributes.mAnchorPositionOffset.setVec( x, y, 0.0f );

                if ( mAttributes.mNumStrands > 2 )
                {
                        angle += angleDelta;
                }

                F32 r = angle * piOver180;
                F32 dX = subWidth * sin(r);
                F32 dY = subWidth * cos(r);
                x += dX;
                y += dY;

                //--------------------------------------------------
                // set anchor directions
                //--------------------------------------------------
                LLVector3 perpendicular;
                perpendicular.setVec( -dY, dX, 0.0f );
                perpendicular.normVec();

                //F32 pitchRadian = mAttributes.mPitch * F_PI_BY_TWO;

                /*strandAttributes.mAnchorDirection.setVec
                        ( 
                                perpendicular.mV[_X_] * cos( pitchRadian ), 
                                perpendicular.mV[_Y_] * cos( pitchRadian ), 
                                                                                sin( pitchRadian ) 
                        );*/

                //strandAttributes.mAnchorDirection.normVec(); // just to be sure...

                /*strandAttributes.mTension                             = mAttributes.mTension;
                strandAttributes.mSimulateLOD                   = mAttributes.mNumSegments;
                strandAttributes.mGravity                               = mAttributes.mGravity;
                strandAttributes.mAirFriction                   = mAttributes.mAirFriction;
                strandAttributes.mWindSensitivity               = mAttributes.mWindSensitivity;
                strandAttributes.mUsingCollisionSphere  = mAttributes.mUsingAvatarCollisionSphere;*/
        }

}//------------------------------------------------------------------------------






//---------------------------------------------------------------------------------
void LLVOCloth::update()
{
        if ( mAttributes.mUsingAvatarCollisionSphere )
        {
                LLVector3 offset;
                offset.setVec
                        ( 
                                mAttributes.mAvatarCollisionSphereForwardOffset, // in this strange world, forward is along X (I think that's kinda wierd)
                                mAttributes.mAvatarCollisionSphereRightOffset,
                                mAttributes.mAvatarCollisionSphereUpOffset
                        );

                //------------------------------------------------------
                // rotate into avatar space
                //------------------------------------------------------
                offset *= gAgent.getAvatarObject()->getRenderRotation();

                mAvatarCollisionSpherePosition = gAgent.getAvatarObject()->getRenderPosition() + offset;        
        }

        if ( mParent )
        {
                // update the attachment of the strands to their parent object, and let them flop around! 
                for ( int s=0; s<mAttributes.mNumStrands; s++)
                {
                        mStrand[s]->setParentPositionAndRotationDirectly( getRenderPosition(), getRenderRotation() );
                        //mStrand[s]->update();
                        
                        if ( mAttributes.mUsingAvatarCollisionSphere )
                        {
                                // it's not efficient to create the exact same collision 
                                // sphere for every strand, but it'll do for the time being
                                mStrand[s]->setCollisionSphere( mAvatarCollisionSpherePosition, mAttributes.mAvatarCollisionSphereRadius );
                        }                       
                }
        }

}//------------------------------------------------------------------




//------------------------------------------------------------------
void LLVOCloth::render()
{
        if ( mAttributes.mTextureFileName != "not_specified" )
        {
                LLViewerImage* theTexture = gImageList.getImage( LLUUID( gViewerArt.getString( mAttributes.mTextureFileName ) ), MIPMAP_FALSE, TRUE);
                if  ( theTexture )
                {       
                        /*if ( mAttributes.mVisualizeAvCollisionSphere )
                        {
                                for ( int s=0; s<mAttributes.mNumStrands; s++)
                                {
                                        mStrand[s]->renderCollisionSphere();
                                }
                        }*/

                        if ( mAttributes.mVisualizeStrands )
                        {
                                for ( int s=0; s<mAttributes.mNumStrands; s++)
                                {
                                        //------------------------------------------------
                                        // draw a small sphere at the top of the strand
                                        //------------------------------------------------
                                        glPushMatrix();

                                        glTranslatef
                                                ( 
                                                        mStrand[s]->getAnchorPosition().mV[_X_],
                                                        mStrand[s]->getAnchorPosition().mV[_Y_], 
                                                        mStrand[s]->getAnchorPosition().mV[_Z_]
                                                );

                                        glScalef
                                                ( 
                                                        STRAND_VISUALIZATION_ANCHOR_BALL_RADIUS, 
                                                        STRAND_VISUALIZATION_ANCHOR_BALL_RADIUS, 
                                                        STRAND_VISUALIZATION_ANCHOR_BALL_RADIUS 
                                                );

                                        gSphere.render();
                                        glPopMatrix();

                                        //--------------------------------
                                        // draw the strand
                                        //--------------------------------
                                        //mStrand[s]->render();







                                        //--------------------------------------------
                                        // draw the segments between the strands
                                        //--------------------------------------------
                                        if ( s > 0 )
                                        {
                                                //--------------------------------
                                                // draw the top edge...
                                                //--------------------------------
                                                glBegin( GL_LINES );
                                                        glVertex3fv( mStrand[s-1]->getAnchorPosition().mV );
                                                        glVertex3fv( mStrand[s  ]->getAnchorPosition().mV );
                                                glEnd();

                                                //--------------------------------------------
                                                // draw the rest of the segments
                                                //--------------------------------------------
                                                for ( int i=0; i<mAttributes.mNumSegments; i++)
                                                {
                                                        glBegin( GL_LINES );
                                                                glVertex3fv( mStrand[s-1]->getNodePosition(i).mV );
                                                                glVertex3fv( mStrand[s  ]->getNodePosition(i).mV );
                                                        glEnd();
                                                }
                                        }
                                }
                        }

                        //--------------------------------------------------------
                        // now, render the cape itself
                        //--------------------------------------------------------
                        glColor4fv( LLColor4( 1.0f, 1.0f, 1.0f, 1.0f ).mV );

                        for ( int s=1; s<mAttributes.mNumStrands; s++)
                        {
                                //to be optimized later (should be calculated only once and stored in an array)
                                F32 x0 = (F32)(s-1)     / (F32)( mAttributes.mNumStrands - 1 );
                                F32 x1 = (F32)s         / (F32)( mAttributes.mNumStrands - 1 );

                                for ( int i=0; i<mAttributes.mNumSegments; i++)
                                {
                                        LLVector3 leftBottom;
                                        LLVector3 rightBottom;
                                        LLVector3 leftTop;
                                        LLVector3 rightTop;

                                        F32 y0 = (F32)i         / (F32)mAttributes.mNumSegments;
                                        F32 y1 = (F32)(i+1)     / (F32)mAttributes.mNumSegments;

                                        y0 = 1.0f - y0;
                                        y1 = 1.0f - y1;

                                        if ( i == 0 )
                                        {
                                                leftBottom      = mStrand[ s-1  ]->getAnchorPosition();
                                                rightBottom     = mStrand[ s    ]->getAnchorPosition();
                                        }
                                        else
                                        {
                                                leftBottom      = mStrand[ s-1  ]->getNodePosition( i-1 );
                                                rightBottom     = mStrand[ s    ]->getNodePosition( i-1 );
                                        }

                                        leftTop         = mStrand[ s-1  ]->getNodePosition( i );
                                        rightTop        = mStrand[ s    ]->getNodePosition( i );

                                        //gGLSTexture.set(); //set render state to use texture
                                        LLViewerImage::bindTexture(theTexture);

                                        glBegin( GL_TRIANGLE_STRIP );
                                                glTexCoord2f( x0, y0 ); glVertex3fv( leftBottom.mV );
                                                glTexCoord2f( x1, y0 ); glVertex3fv( rightBottom.mV );
                                                glTexCoord2f( x0, y1 ); glVertex3fv( leftTop.mV );
                                        glEnd();
                                        glBegin( GL_TRIANGLE_STRIP );
                                                glTexCoord2f( x1, y0 ); glVertex3fv( rightBottom.mV );
                                                glTexCoord2f( x1, y1 ); glVertex3fv( rightTop.mV );
                                                glTexCoord2f( x0, y1 ); glVertex3fv( leftTop.mV );
                                        glEnd();

                                        theTexture->unbindTexture(0, GL_TEXTURE_2D);
                                }
                        }
                }
        }

}//------------------------------------------------------------------




//------------------------------------------------------------------
void LLVOCloth::setAttributes( LLClothAttributes a )
{
        mAttributes.mTextureFileName                                            = a.mTextureFileName;
        mAttributes.mTextureIndex                                                       = a.mTextureIndex;
        mAttributes.mNumSegments                                                        = a.mNumSegments;
        mAttributes.mNumStrands                                                         = a.mNumStrands;
        mAttributes.mVisualizeStrands                                           = a.mVisualizeStrands;
        mAttributes.mVisualizeAvCollisionSphere                         = a.mVisualizeAvCollisionSphere;
        mAttributes.mWidth                                                                      = a.mWidth;
        mAttributes.mLength                                                                     = a.mLength;
        mAttributes.mPitch                                                                      = a.mPitch;
        mAttributes.mTension                                                            = a.mTension;
        mAttributes.mGravity                                                            = a.mGravity;
        mAttributes.mAirFriction                                                        = a.mAirFriction;       
        mAttributes.mWindSensitivity                                            = a.mWindSensitivity;   
        mAttributes.mCircleWrapAmount                                           = a.mCircleWrapAmount;  
        mAttributes.mUsingAvatarCollisionSphere                         = a.mUsingAvatarCollisionSphere;                
//mAttributes.mAvatarCollisionSpherePositionOffset      = a.mAvatarCollisionSpherePositionOffset;
        mAttributes.mAvatarCollisionSphereRadius                        = a.mAvatarCollisionSphereRadius;
        mAttributes.mAvatarCollisionSphereRightOffset           = a.mAvatarCollisionSphereRightOffset;
        mAttributes.mAvatarCollisionSphereUpOffset                      = a.mAvatarCollisionSphereUpOffset;
        mAttributes.mAvatarCollisionSphereForwardOffset         = a.mAvatarCollisionSphereForwardOffset;


        if              ( mAttributes.mTextureIndex             < CLOTH_MIN_TEXTURE_INDEX               ){ mAttributes.mTextureIndex            = CLOTH_MIN_TEXTURE_INDEX;      }
        else if ( mAttributes.mTextureIndex             > CLOTH_MAX_TEXTURE_INDEX               ){ mAttributes.mTextureIndex            = CLOTH_MAX_TEXTURE_INDEX;      }
        if              ( mAttributes.mPitch                    < CLOTH_MIN_PITCH                               ){ mAttributes.mPitch                           = CLOTH_MIN_PITCH;                      }
        else if ( mAttributes.mPitch                    > CLOTH_MAX_PITCH                               ){ mAttributes.mPitch                           = CLOTH_MAX_PITCH;                      }
        if              ( mAttributes.mWidth                    < CLOTH_MIN_WIDTH                               ){ mAttributes.mWidth                           = CLOTH_MIN_WIDTH;                      }
        else if ( mAttributes.mWidth                    > CLOTH_MAX_WIDTH                               ){ mAttributes.mWidth                           = CLOTH_MAX_WIDTH;                      }
        if              ( mAttributes.mLength                   < CLOTH_MIN_LENGTH                              ){ mAttributes.mLength                          = CLOTH_MIN_LENGTH;                     }
        else if ( mAttributes.mLength                   > CLOTH_MAX_LENGTH                              ){ mAttributes.mLength                          = CLOTH_MAX_LENGTH;                     }
        if              ( mAttributes.mNumSegments              < CLOTH_MIN_SEGMENTS                    ){ mAttributes.mNumSegments                     = CLOTH_MIN_SEGMENTS;           }
        else if ( mAttributes.mNumSegments              > CLOTH_MAX_SEGMENTS                    ){ mAttributes.mNumSegments                     = CLOTH_MAX_SEGMENTS;           }
        if              ( mAttributes.mNumStrands               < CLOTH_MIN_STRANDS                             ){ mAttributes.mNumStrands                      = CLOTH_MIN_STRANDS;            }
        else if ( mAttributes.mNumStrands               > CLOTH_MAX_STRANDS                             ){ mAttributes.mNumStrands                      = CLOTH_MAX_STRANDS;            }
        if              ( mAttributes.mTension                  < CLOTH_MIN_TENSION                             ){ mAttributes.mTension                         = CLOTH_MIN_TENSION;            }
        else if ( mAttributes.mTension                  > CLOTH_MAX_TENSION                             ){ mAttributes.mTension                         = CLOTH_MAX_TENSION;            }
        if              ( mAttributes.mGravity                  < CLOTH_MIN_GRAVITY                             ){ mAttributes.mGravity                         = CLOTH_MIN_GRAVITY;            }
        else if ( mAttributes.mGravity                  > CLOTH_MAX_GRAVITY                             ){ mAttributes.mGravity                         = CLOTH_MAX_GRAVITY;            }
        if              ( mAttributes.mAirFriction              < CLOTH_MIN_AIR_FRICTION                ){ mAttributes.mAirFriction                     = CLOTH_MIN_AIR_FRICTION;       }
        else if ( mAttributes.mAirFriction              > CLOTH_MAX_AIR_FRICTION                ){ mAttributes.mAirFriction                     = CLOTH_MAX_AIR_FRICTION;       }
        if              ( mAttributes.mWindSensitivity  < CLOTH_MIN_WIND_SENSITIVITY    ){ mAttributes.mWindSensitivity         = CLOTH_MIN_WIND_SENSITIVITY;}
        else if ( mAttributes.mWindSensitivity  > CLOTH_MAX_WIND_SENSITIVITY    ){ mAttributes.mWindSensitivity         = CLOTH_MAX_WIND_SENSITIVITY;}
        if              ( mAttributes.mCircleWrapAmount < CLOTH_MIN_CIRCLE_WRAP_AMOUNT  ){ mAttributes.mCircleWrapAmount        = CLOTH_MIN_CIRCLE_WRAP_AMOUNT;}
        else if ( mAttributes.mCircleWrapAmount > CLOTH_MAX_CIRCLE_WRAP_AMOUNT  ){ mAttributes.mCircleWrapAmount        = CLOTH_MAX_CIRCLE_WRAP_AMOUNT;}
        
        if              ( mAttributes.mAvatarCollisionSphereRadius                      < CLOTH_MIN_AVATAR_COLLISION_SPHERE_RADIUS                      ){ mAttributes.mAvatarCollisionSphereRadius                     = CLOTH_MIN_AVATAR_COLLISION_SPHERE_RADIUS;}
        else if ( mAttributes.mAvatarCollisionSphereRadius                      > CLOTH_MAX_AVATAR_COLLISION_SPHERE_RADIUS                      ){ mAttributes.mAvatarCollisionSphereRadius                     = CLOTH_MAX_AVATAR_COLLISION_SPHERE_RADIUS;}
        if              ( mAttributes.mAvatarCollisionSphereRightOffset         < CLOTH_MIN_AVATAR_COLLISION_SPHERE_RIGHT_OFFSET        ){ mAttributes.mAvatarCollisionSphereRightOffset        = CLOTH_MIN_AVATAR_COLLISION_SPHERE_RIGHT_OFFSET;}
        else if ( mAttributes.mAvatarCollisionSphereRightOffset         > CLOTH_MAX_AVATAR_COLLISION_SPHERE_RIGHT_OFFSET        ){ mAttributes.mAvatarCollisionSphereRightOffset        = CLOTH_MAX_AVATAR_COLLISION_SPHERE_RIGHT_OFFSET;}
        if              ( mAttributes.mAvatarCollisionSphereUpOffset            < CLOTH_MIN_AVATAR_COLLISION_SPHERE_UP_OFFSET           ){ mAttributes.mAvatarCollisionSphereUpOffset           = CLOTH_MIN_AVATAR_COLLISION_SPHERE_UP_OFFSET;}
        else if ( mAttributes.mAvatarCollisionSphereUpOffset            > CLOTH_MAX_AVATAR_COLLISION_SPHERE_UP_OFFSET           ){ mAttributes.mAvatarCollisionSphereUpOffset           = CLOTH_MAX_AVATAR_COLLISION_SPHERE_UP_OFFSET;}
        if              ( mAttributes.mAvatarCollisionSphereForwardOffset       < CLOTH_MIN_AVATAR_COLLISION_SPHERE_FORWARD_OFFSET      ){ mAttributes.mAvatarCollisionSphereForwardOffset      = CLOTH_MIN_AVATAR_COLLISION_SPHERE_FORWARD_OFFSET;}
        else if ( mAttributes.mAvatarCollisionSphereForwardOffset       > CLOTH_MAX_AVATAR_COLLISION_SPHERE_FORWARD_OFFSET      ){ mAttributes.mAvatarCollisionSphereForwardOffset      = CLOTH_MAX_AVATAR_COLLISION_SPHERE_FORWARD_OFFSET;}

        //-----------------------------------------------------------------------------------
        // based on the above attributes, the strands (flexible objects) are generated
        //-----------------------------------------------------------------------------------
        generateStrands();

}//------------------------------------------------------------------





//------------------------------------------------------------------
// set methods
//------------------------------------------------------------------

//------------------------------------------------------------------
void LLVOCloth::setNumStrands( int num )
{
        mAttributes.mNumStrands = num;
        generateStrands();
}//------------------------------------------------------------------
//------------------------------------------------------------------
void LLVOCloth::setNumSegments( int num )
{
        mAttributes.mNumSegments = num;
        generateStrands();
}//------------------------------------------------------------------
//------------------------------------------------------------------
void LLVOCloth::setLength( F32 le )
{
        mAttributes.mLength = le;
        generateStrands();
}//------------------------------------------------------------------
//------------------------------------------------------------------
void LLVOCloth::setCircleWrapAmount( F32 n )
{
        mAttributes.mCircleWrapAmount = n;
        generateStrands();
}//------------------------------------------------------------------
//------------------------------------------------------------------
void LLVOCloth::setGravity( F32 g )
{
        mAttributes.mGravity = g;
        generateStrands();
}//------------------------------------------------------------------
//------------------------------------------------------------------
void LLVOCloth::setPitch( F32 p )
{
        mAttributes.mPitch = p;
        generateStrands();
}//------------------------------------------------------------------
//------------------------------------------------------------------
void LLVOCloth::setAirFriction( F32 a )
{
        mAttributes.mAirFriction = a;
        generateStrands();
}//------------------------------------------------------------------
//------------------------------------------------------------------
void LLVOCloth::setWindSensitivity( F32 w )
{
        mAttributes.mWindSensitivity = w;
        generateStrands();
}//------------------------------------------------------------------
//------------------------------------------------------------------
void LLVOCloth::setTension( F32 t )
{
        mAttributes.mTension = t;
        generateStrands();
}//------------------------------------------------------------------
//------------------------------------------------------------------
void LLVOCloth::setWidth( F32 n )
{
        mAttributes.mWidth = n;
        generateStrands();
}//------------------------------------------------------------------
//------------------------------------------------------------------
void LLVOCloth::setVisualizingStrands( bool v )
{
        mAttributes.mVisualizeStrands = v;
}//------------------------------------------------------------------//------------------------------------------------------------------
void LLVOCloth::setVisualizingAvCollisionSphere( bool v )
{
        mAttributes.mVisualizeAvCollisionSphere = v;
}//------------------------------------------------------------------
//------------------------------------------------------------------
void LLVOCloth::setAvatarCollisionSphereRadius( F32 r )
{
        mAttributes.mAvatarCollisionSphereRadius = r;

}//------------------------------------------------------------------
//------------------------------------------------------------------
void LLVOCloth::setAvatarCollisionSphereRight( F32 r )
{
        mAttributes.mAvatarCollisionSphereRightOffset = r;

}//------------------------------------------------------------------
//------------------------------------------------------------------
void LLVOCloth::setAvatarCollisionSphereUp( F32 u )
{
        mAttributes.mAvatarCollisionSphereUpOffset = u;

}//------------------------------------------------------------------
//------------------------------------------------------------------
void LLVOCloth::setAvatarCollisionSphereForward( F32 f )
{
        mAttributes.mAvatarCollisionSphereForwardOffset = f;

}//------------------------------------------------------------------


//------------------------------------------------------------------
// get methods
//------------------------------------------------------------------

//------------------------------------------------------------------
int LLVOCloth::getNumStrands()
{
        return mAttributes.mNumStrands;
}//------------------------------------------------------------------
//------------------------------------------------------------------
int LLVOCloth::getNumSegments()
{
        return mAttributes.mNumSegments;
}//------------------------------------------------------------------
//------------------------------------------------------------------
F32 LLVOCloth::getLength()
{
        return mAttributes.mLength;
}//------------------------------------------------------------------
//------------------------------------------------------------------
F32 LLVOCloth::getWidth()
{
        return mAttributes.mWidth;
}//------------------------------------------------------------------
//------------------------------------------------------------------
F32 LLVOCloth::getCircleWrapAmount()
{
        return mAttributes.mCircleWrapAmount;
}//------------------------------------------------------------------
//------------------------------------------------------------------
F32 LLVOCloth::getPitch()
{
        return mAttributes.mPitch;
}//------------------------------------------------------------------
//------------------------------------------------------------------
F32 LLVOCloth::getTension()
{
        return mAttributes.mTension;
}//------------------------------------------------------------------
//------------------------------------------------------------------
F32 LLVOCloth::getGravity()
{
        return mAttributes.mGravity;
}//------------------------------------------------------------------
//------------------------------------------------------------------
F32 LLVOCloth::getAirFriction()
{
        return mAttributes.mAirFriction;
}//------------------------------------------------------------------
//------------------------------------------------------------------
F32 LLVOCloth::getWindSensitivity()
{
        return mAttributes.mWindSensitivity;
}//------------------------------------------------------------------
//------------------------------------------------------------------
bool LLVOCloth::getVisualizingStrands() const
{
        return mAttributes.mVisualizeStrands;
}//------------------------------------------------------------------
//------------------------------------------------------------------
bool LLVOCloth::getVisualizingAvCollisionSphere() const
{
        return mAttributes.mVisualizeAvCollisionSphere;
}//------------------------------------------------------------------
//------------------------------------------------------------------
F32 LLVOCloth::getAvatarCollisionSphereRadius()
{
        return mAttributes.mAvatarCollisionSphereRadius;
}//------------------------------------------------------------------
//------------------------------------------------------------------
F32 LLVOCloth::getAvatarCollisionSphereRight()
{
        return mAttributes.mAvatarCollisionSphereRightOffset;
}//------------------------------------------------------------------
//------------------------------------------------------------------
F32 LLVOCloth::getAvatarCollisionSphereUp()
{
        return mAttributes.mAvatarCollisionSphereUpOffset;
}//------------------------------------------------------------------
//------------------------------------------------------------------
F32 LLVOCloth::getAvatarCollisionSphereForward()
{
        return mAttributes.mAvatarCollisionSphereForwardOffset;
}//------------------------------------------------------------------



//------------------------------------------------------------------
void LLVOCloth::markAsDead()
{
        mDead = TRUE;

}//------------------------------------------------------------------

---