Second Life Viewer: llprimitive.h Source File

00001 
00032 #ifndef LL_LLPRIMITIVE_H
00033 #define LL_LLPRIMITIVE_H
00034 
00035 #include "lluuid.h"
00036 #include "v3math.h"
00037 #include "xform.h"
00038 #include "message.h"
00039 #include "llmemory.h"
00040 #include "llvolume.h"
00041 #include "lltextureentry.h"
00042 
00043 // Moved to stdtypes.h --JC
00044 // typedef U8 LLPCode;
00045 class LLMessageSystem;
00046 class LLVolumeParams;
00047 class LLColor4;
00048 class LLColor3;
00049 class LLTextureEntry;
00050 class LLDataPacker;
00051 
00052 enum LLGeomType // NOTE: same vals as GL Ids
00053 {
00054         LLInvalid   = 0,
00055         LLLineLoop  = 2,
00056         LLLineStrip = 3,
00057         LLTriangles = 4,
00058         LLTriStrip  = 5,
00059         LLTriFan    = 6,
00060         LLQuads     = 7, 
00061         LLQuadStrip = 8
00062 };
00063 
00064 class LLVolume;
00065 
00069 extern const F32 OBJECT_CUT_MIN;
00070 extern const F32 OBJECT_CUT_MAX;
00071 extern const F32 OBJECT_CUT_INC;
00072 extern const F32 OBJECT_MIN_CUT_INC;
00073 extern const F32 OBJECT_ROTATION_PRECISION;
00074 
00075 extern const F32 OBJECT_TWIST_MIN;
00076 extern const F32 OBJECT_TWIST_MAX;
00077 extern const F32 OBJECT_TWIST_INC;
00078 
00079 // This is used for linear paths,
00080 // since twist is used in a slightly different manner.
00081 extern const F32 OBJECT_TWIST_LINEAR_MIN;
00082 extern const F32 OBJECT_TWIST_LINEAR_MAX;
00083 extern const F32 OBJECT_TWIST_LINEAR_INC;
00084 
00085 extern const F32 OBJECT_MIN_HOLE_SIZE;
00086 extern const F32 OBJECT_MAX_HOLE_SIZE_X;
00087 extern const F32 OBJECT_MAX_HOLE_SIZE_Y;
00088 
00089 // Revolutions parameters.
00090 extern const F32 OBJECT_REV_MIN;
00091 extern const F32 OBJECT_REV_MAX;
00092 extern const F32 OBJECT_REV_INC;
00093 
00094 extern const char *SCULPT_DEFAULT_TEXTURE;
00095 
00096 //============================================================================
00097 
00098 // TomY: Base class for things that pack & unpack themselves
00099 class LLNetworkData
00100 {
00101 public:
00102         // Extra parameter IDs
00103         enum
00104         {
00105                 PARAMS_FLEXIBLE = 0x10,
00106                 PARAMS_LIGHT    = 0x20,
00107                 PARAMS_SCULPT   = 0x30
00108         };
00109         
00110 public:
00111         U16 mType;
00112         virtual ~LLNetworkData() {};
00113         virtual BOOL pack(LLDataPacker &dp) const = 0;
00114         virtual BOOL unpack(LLDataPacker &dp) = 0;
00115         virtual bool operator==(const LLNetworkData& data) const = 0;
00116         virtual void copy(const LLNetworkData& data) = 0;
00117         static BOOL isValid(U16 param_type, U32 size);
00118 };
00119 
00120 extern const F32 LIGHT_MIN_RADIUS;
00121 extern const F32 LIGHT_DEFAULT_RADIUS;
00122 extern const F32 LIGHT_MAX_RADIUS;
00123 extern const F32 LIGHT_MIN_FALLOFF;
00124 extern const F32 LIGHT_DEFAULT_FALLOFF;
00125 extern const F32 LIGHT_MAX_FALLOFF;
00126 extern const F32 LIGHT_MIN_CUTOFF;
00127 extern const F32 LIGHT_DEFAULT_CUTOFF;
00128 extern const F32 LIGHT_MAX_CUTOFF;
00129 
00130 class LLLightParams : public LLNetworkData
00131 {
00132 protected:
00133         LLColor4 mColor; // alpha = intensity
00134         F32 mRadius;
00135         F32 mFalloff;
00136         F32 mCutoff;
00137 
00138 public:
00139         LLLightParams();
00140         /*virtual*/ BOOL pack(LLDataPacker &dp) const;
00141         /*virtual*/ BOOL unpack(LLDataPacker &dp);
00142         /*virtual*/ bool operator==(const LLNetworkData& data) const;
00143         /*virtual*/ void copy(const LLNetworkData& data);
00144 
00145         void setColor(const LLColor4& color)    { mColor = color; mColor.clamp(); }
00146         void setRadius(F32 radius)                              { mRadius = llclamp(radius, LIGHT_MIN_RADIUS, LIGHT_MAX_RADIUS); }
00147         void setFalloff(F32 falloff)                    { mFalloff = llclamp(falloff, LIGHT_MIN_FALLOFF, LIGHT_MAX_FALLOFF); }
00148         void setCutoff(F32 cutoff)                              { mCutoff = llclamp(cutoff, LIGHT_MIN_CUTOFF, LIGHT_MAX_CUTOFF); }
00149 
00150         LLColor4 getColor() const                               { return mColor; }
00151         F32 getRadius() const                                   { return mRadius; }
00152         F32 getFalloff() const                                  { return mFalloff; }
00153         F32 getCutoff() const                                   { return mCutoff; }
00154 };
00155 
00156 //-------------------------------------------------
00157 // This structure is also used in the part of the 
00158 // code that creates new flexible objects.
00159 //-------------------------------------------------
00160 
00161 // These were made into enums so that they could be used as fixed size
00162 // array bounds.
00163 enum EFlexibleObjectConst
00164 {
00165         // "Softness" => [0,3], increments of 1
00166         // Represents powers of 2: 0 -> 1, 3 -> 8
00167         FLEXIBLE_OBJECT_MIN_SECTIONS = 0,
00168         FLEXIBLE_OBJECT_DEFAULT_NUM_SECTIONS = 2,
00169         FLEXIBLE_OBJECT_MAX_SECTIONS = 3
00170 };
00171 
00172 // "Tension" => [0,10], increments of 0.1
00173 extern const F32 FLEXIBLE_OBJECT_MIN_TENSION;
00174 extern const F32 FLEXIBLE_OBJECT_DEFAULT_TENSION;
00175 extern const F32 FLEXIBLE_OBJECT_MAX_TENSION;
00176 
00177 // "Drag" => [0,10], increments of 0.1
00178 extern const F32 FLEXIBLE_OBJECT_MIN_AIR_FRICTION;
00179 extern const F32 FLEXIBLE_OBJECT_DEFAULT_AIR_FRICTION;
00180 extern const F32 FLEXIBLE_OBJECT_MAX_AIR_FRICTION;
00181 
00182 // "Gravity" = [-10,10], increments of 0.1
00183 extern const F32 FLEXIBLE_OBJECT_MIN_GRAVITY;
00184 extern const F32 FLEXIBLE_OBJECT_DEFAULT_GRAVITY;
00185 extern const F32 FLEXIBLE_OBJECT_MAX_GRAVITY;
00186 
00187 // "Wind" = [0,10], increments of 0.1
00188 extern const F32 FLEXIBLE_OBJECT_MIN_WIND_SENSITIVITY;
00189 extern const F32 FLEXIBLE_OBJECT_DEFAULT_WIND_SENSITIVITY;
00190 extern const F32 FLEXIBLE_OBJECT_MAX_WIND_SENSITIVITY;
00191 
00192 extern const F32 FLEXIBLE_OBJECT_MAX_INTERNAL_TENSION_FORCE;
00193 
00194 extern const F32 FLEXIBLE_OBJECT_DEFAULT_LENGTH;
00195 extern const BOOL FLEXIBLE_OBJECT_DEFAULT_USING_COLLISION_SPHERE;
00196 extern const BOOL FLEXIBLE_OBJECT_DEFAULT_RENDERING_COLLISION_SPHERE;
00197 
00198 
00199 class LLFlexibleObjectData : public LLNetworkData
00200 {
00201 protected:
00202         S32                     mSimulateLOD;           // 2^n = number of simulated sections
00203         F32                     mGravity;
00204         F32                     mAirFriction;           // higher is more stable, but too much looks like it's underwater
00205         F32                     mWindSensitivity;       // interacts with tension, air friction, and gravity
00206         F32                     mTension;                       //interacts in complex ways with other parameters
00207         LLVector3       mUserForce;                     // custom user-defined force vector
00208         //BOOL          mUsingCollisionSphere;
00209         //BOOL          mRenderingCollisionSphere;
00210 
00211 public:
00212         void            setSimulateLOD(S32 lod)                 { mSimulateLOD = llclamp(lod, (S32)FLEXIBLE_OBJECT_MIN_SECTIONS, (S32)FLEXIBLE_OBJECT_MAX_SECTIONS); }
00213         void            setGravity(F32 gravity)                 { mGravity = llclamp(gravity, FLEXIBLE_OBJECT_MIN_GRAVITY, FLEXIBLE_OBJECT_MAX_GRAVITY); }
00214         void            setAirFriction(F32 friction)    { mAirFriction = llclamp(friction, FLEXIBLE_OBJECT_MIN_AIR_FRICTION, FLEXIBLE_OBJECT_MAX_AIR_FRICTION); }
00215         void            setWindSensitivity(F32 wind)    { mWindSensitivity = llclamp(wind, FLEXIBLE_OBJECT_MIN_WIND_SENSITIVITY, FLEXIBLE_OBJECT_MAX_WIND_SENSITIVITY); }
00216         void            setTension(F32 tension)                 { mTension = llclamp(tension, FLEXIBLE_OBJECT_MIN_TENSION, FLEXIBLE_OBJECT_MAX_TENSION); }
00217         void            setUserForce(LLVector3 &force)  { mUserForce = force; }
00218 
00219         S32                     getSimulateLOD() const                  { return mSimulateLOD; }
00220         F32                     getGravity() const                              { return mGravity; }
00221         F32                     getAirFriction() const                  { return mAirFriction; }
00222         F32                     getWindSensitivity() const              { return mWindSensitivity; }
00223         F32                     getTension() const                              { return mTension; }
00224         LLVector3       getUserForce() const                    { return mUserForce; }
00225 
00226         //------ the constructor for the structure ------------
00227         LLFlexibleObjectData();
00228         BOOL pack(LLDataPacker &dp) const;
00229         BOOL unpack(LLDataPacker &dp);
00230         bool operator==(const LLNetworkData& data) const;
00231         void copy(const LLNetworkData& data);
00232 };// end of attributes structure
00233 
00234 
00235 
00236 class LLSculptParams : public LLNetworkData
00237 {
00238 protected:
00239         LLUUID mSculptTexture;
00240         U8 mSculptType;
00241         
00242 public:
00243         LLSculptParams();
00244         /*virtual*/ BOOL pack(LLDataPacker &dp) const;
00245         /*virtual*/ BOOL unpack(LLDataPacker &dp);
00246         /*virtual*/ bool operator==(const LLNetworkData& data) const;
00247         /*virtual*/ void copy(const LLNetworkData& data);
00248 
00249         void setSculptTexture(const LLUUID& id) { mSculptTexture = id; }
00250         LLUUID getSculptTexture()               { return mSculptTexture; }
00251         void setSculptType(U8 type)             { mSculptType = type; }
00252         U8 getSculptType()                      { return mSculptType; }
00253 };
00254 
00255 
00256 
00257 class LLPrimitive : public LLXform
00258 {
00259 public:
00260         LLPrimitive();
00261         virtual ~LLPrimitive();
00262 
00263         static LLPrimitive *createPrimitive(LLPCode p_code);
00264         void init(LLPCode p_code);
00265 
00266         void setPCode(const LLPCode pcode);
00267         const LLVolume *getVolumeConst() const { return mVolumep; }             // HACK for Windoze confusion about ostream operator in LLVolume
00268         LLVolume *getVolume() const { return mVolumep; }
00269         virtual BOOL setVolume(const LLVolumeParams &volume_params, const S32 detail, bool unique_volume = false);
00270 
00271         // Modify texture entry properties
00272         inline BOOL validTE(const U8 te_num) const;
00273         const LLTextureEntry *getTE(const U8 te_num) const;
00274 
00275         virtual void setNumTEs(const U8 num_tes);
00276         virtual void setAllTETextures(const LLUUID &tex_id);
00277         virtual void setTE(const U8 index, const LLTextureEntry &te);
00278         virtual S32 setTEColor(const U8 te, const LLColor4 &color);
00279         virtual S32 setTEColor(const U8 te, const LLColor3 &color);
00280         virtual S32 setTEAlpha(const U8 te, const F32 alpha);
00281         virtual S32 setTETexture(const U8 te, const LLUUID &tex_id);
00282         virtual S32 setTEScale (const U8 te, const F32 s, const F32 t);
00283         virtual S32 setTEScaleS(const U8 te, const F32 s);
00284         virtual S32 setTEScaleT(const U8 te, const F32 t);
00285         virtual S32 setTEOffset (const U8 te, const F32 s, const F32 t);
00286         virtual S32 setTEOffsetS(const U8 te, const F32 s);
00287         virtual S32 setTEOffsetT(const U8 te, const F32 t);
00288         virtual S32 setTERotation(const U8 te, const F32 r);
00289         virtual S32 setTEBumpShinyFullbright(const U8 te, const U8 bump);
00290         virtual S32 setTEBumpShiny(const U8 te, const U8 bump);
00291         virtual S32 setTEMediaTexGen(const U8 te, const U8 media);
00292         virtual S32 setTEBumpmap(const U8 te, const U8 bump);
00293         virtual S32 setTETexGen(const U8 te, const U8 texgen);
00294         virtual S32 setTEShiny(const U8 te, const U8 shiny);
00295         virtual S32 setTEFullbright(const U8 te, const U8 fullbright);
00296         virtual S32 setTEMediaFlags(const U8 te, const U8 flags);
00297         virtual S32 setTEGlow(const U8 te, const F32 glow);
00298         virtual BOOL setMaterial(const U8 material); // returns TRUE if material changed
00299 
00300         void setTEArrays(const U8 size,
00301                                           const LLUUID* image_ids,
00302                                           const F32* scale_s,
00303                                           const F32* scale_t);
00304         void copyTEs(const LLPrimitive *primitive);
00305         S32 packTEField(U8 *cur_ptr, U8 *data_ptr, U8 data_size, U8 last_face_index, EMsgVariableType type) const;
00306         S32 unpackTEField(U8 *cur_ptr, U8 *buffer_end, U8 *data_ptr, U8 data_size, U8 face_count, EMsgVariableType type);
00307         BOOL packTEMessage(LLMessageSystem *mesgsys) const;
00308         BOOL packTEMessage(LLDataPacker &dp) const;
00309         S32 unpackTEMessage(LLMessageSystem *mesgsys, char *block_name);
00310         S32 unpackTEMessage(LLMessageSystem *mesgsys, char *block_name, const S32 block_num); // Variable num of blocks
00311         BOOL unpackTEMessage(LLDataPacker &dp);
00312         
00313 #ifdef CHECK_FOR_FINITE
00314         inline void setPosition(const LLVector3& pos);
00315         inline void setPosition(const F32 x, const F32 y, const F32 z);
00316         inline void addPosition(const LLVector3& pos);
00317 
00318         inline void setAngularVelocity(const LLVector3& avel);
00319         inline void setAngularVelocity(const F32 x, const F32 y, const F32 z);
00320         inline void setVelocity(const LLVector3& vel);
00321         inline void setVelocity(const F32 x, const F32 y, const F32 z);
00322         inline void setVelocityX(const F32 x);
00323         inline void setVelocityY(const F32 y);
00324         inline void setVelocityZ(const F32 z);
00325         inline void addVelocity(const LLVector3& vel);
00326         inline void setAcceleration(const LLVector3& accel);
00327         inline void setAcceleration(const F32 x, const F32 y, const F32 z);
00328 #else
00329         // Don't override the base LLXForm operators.
00330         // Special case for setPosition.  If not check-for-finite, fall through to LLXform method.
00331         // void         setPosition(F32 x, F32 y, F32 z)
00332         // void         setPosition(LLVector3)
00333 
00334         void            setAngularVelocity(const LLVector3& avel)       { mAngularVelocity = avel; }
00335         void            setAngularVelocity(const F32 x, const F32 y, const F32 z)       { mAngularVelocity.setVec(x,y,z); }
00336         void            setVelocity(const LLVector3& vel)                       { mVelocity = vel; }
00337         void            setVelocity(const F32 x, const F32 y, const F32 z)                      { mVelocity.setVec(x,y,z); }
00338         void            setVelocityX(const F32 x)                                       { mVelocity.mV[VX] = x; }
00339         void            setVelocityY(const F32 y)                                       { mVelocity.mV[VY] = y; }
00340         void            setVelocityZ(const F32 z)                                       { mVelocity.mV[VZ] = z; }
00341         void            addVelocity(const LLVector3& vel)                       { mVelocity += vel; }
00342         void            setAcceleration(const LLVector3& accel)         { mAcceleration = accel; }
00343         void            setAcceleration(const F32 x, const F32 y, const F32 z)          { mAcceleration.setVec(x,y,z); }
00344 #endif
00345         
00346         LLPCode                         getPCode() const                        { return mPrimitiveCode; }
00347         const char *            getPCodeString() const          { return pCodeToString(mPrimitiveCode); }
00348         const LLVector3&        getAngularVelocity() const      { return mAngularVelocity; }
00349         const LLVector3&        getVelocity() const                     { return mVelocity; }
00350         const LLVector3&        getAcceleration() const         { return mAcceleration; }
00351         U8                                      getNumTEs() const                       { return mNumTEs; }
00352 
00353         U8                                      getMaterial() const                     { return mMaterial; }
00354         
00355         void                            setVolumeType(const U8 code);
00356         U8                                      getVolumeType();
00357 
00358         void setTextureList(LLTextureEntry *listp);
00359 
00360         inline BOOL                     isAvatar() const;
00361         
00362         static const char *pCodeToString(const LLPCode pcode);
00363         static LLPCode legacyToPCode(const U8 legacy);
00364         static U8 pCodeToLegacy(const LLPCode pcode);
00365         static bool getTESTAxes(const U8 face, U32* s_axis, U32* t_axis);
00366         
00367         inline static BOOL isPrimitive(const LLPCode pcode);
00368         inline static BOOL isApp(const LLPCode pcode);
00369 
00370 protected:
00371         LLPCode                         mPrimitiveCode;         // Primitive code
00372         LLVector3                       mVelocity;                      // how fast are we moving?
00373         LLVector3                       mAcceleration;          // are we under constant acceleration?
00374         LLVector3                       mAngularVelocity;       // angular velocity
00375         LLPointer<LLVolume> mVolumep;
00376         LLTextureEntry          *mTextureList;          // list of texture GUIDs, scales, offsets
00377         U8                                      mMaterial;                      // Material code
00378         U8                                      mNumTEs;                        // # of faces on the primitve   
00379 };
00380 
00381 inline BOOL LLPrimitive::isAvatar() const
00382 {
00383         return mPrimitiveCode == LL_PCODE_LEGACY_AVATAR;
00384 }
00385 
00386 // static
00387 inline BOOL LLPrimitive::isPrimitive(const LLPCode pcode)
00388 {
00389         LLPCode base_type = pcode & LL_PCODE_BASE_MASK;
00390 
00391         if (base_type && (base_type < LL_PCODE_APP))
00392         {
00393                 return TRUE;
00394         }
00395         return FALSE;
00396 }
00397 
00398 // static
00399 inline BOOL LLPrimitive::isApp(const LLPCode pcode)
00400 {
00401         LLPCode base_type = pcode & LL_PCODE_BASE_MASK;
00402 
00403         return (base_type == LL_PCODE_APP);
00404 }
00405 
00406 
00407 #ifdef CHECK_FOR_FINITE
00408 // Special case for setPosition.  If not check-for-finite, fall through to LLXform method.
00409 void LLPrimitive::setPosition(const F32 x, const F32 y, const F32 z)
00410 {
00411         if (llfinite(x) && llfinite(y) && llfinite(z))
00412         {
00413                 LLXform::setPosition(x, y, z);
00414         }
00415         else
00416         {
00417                 llerrs << "Non Finite in LLPrimitive::setPosition(x,y,z) for " << pCodeToString(mPrimitiveCode) << llendl;
00418         }
00419 }
00420 
00421 // Special case for setPosition.  If not check-for-finite, fall through to LLXform method.
00422 void LLPrimitive::setPosition(const LLVector3& pos)
00423 {
00424         if (pos.isFinite())
00425         {
00426                 LLXform::setPosition(pos);
00427         }
00428         else
00429         {
00430                 llerrs << "Non Finite in LLPrimitive::setPosition(LLVector3) for " << pCodeToString(mPrimitiveCode) << llendl;
00431         }
00432 }
00433 
00434 void LLPrimitive::setAngularVelocity(const LLVector3& avel)
00435 { 
00436         if (avel.isFinite())
00437         {
00438                 mAngularVelocity = avel;
00439         }
00440         else
00441         {
00442                 llerror("Non Finite in LLPrimitive::setAngularVelocity", 0);
00443         }
00444 }
00445 
00446 void LLPrimitive::setAngularVelocity(const F32 x, const F32 y, const F32 z)             
00447 { 
00448         if (llfinite(x) && llfinite(y) && llfinite(z))
00449         {
00450                 mAngularVelocity.setVec(x,y,z);
00451         }
00452         else
00453         {
00454                 llerror("Non Finite in LLPrimitive::setAngularVelocity", 0);
00455         }
00456 }
00457 
00458 void LLPrimitive::setVelocity(const LLVector3& vel)                     
00459 { 
00460         if (vel.isFinite())
00461         {
00462                 mVelocity = vel; 
00463         }
00464         else
00465         {
00466                 llerrs << "Non Finite in LLPrimitive::setVelocity(LLVector3) for " << pCodeToString(mPrimitiveCode) << llendl;
00467         }
00468 }
00469 
00470 void LLPrimitive::setVelocity(const F32 x, const F32 y, const F32 z)                    
00471 { 
00472         if (llfinite(x) && llfinite(y) && llfinite(z))
00473         {
00474                 mVelocity.setVec(x,y,z); 
00475         }
00476         else
00477         {
00478                 llerrs << "Non Finite in LLPrimitive::setVelocity(F32,F32,F32) for " << pCodeToString(mPrimitiveCode) << llendl;
00479         }
00480 }
00481 
00482 void LLPrimitive::setVelocityX(const F32 x)                                                     
00483 { 
00484         if (llfinite(x))
00485         {
00486                 mVelocity.mV[VX] = x;
00487         }
00488         else
00489         {
00490                 llerror("Non Finite in LLPrimitive::setVelocityX", 0);
00491         }
00492 }
00493 
00494 void LLPrimitive::setVelocityY(const F32 y)                                                     
00495 { 
00496         if (llfinite(y))
00497         {
00498                 mVelocity.mV[VY] = y;
00499         }
00500         else
00501         {
00502                 llerror("Non Finite in LLPrimitive::setVelocityY", 0);
00503         }
00504 }
00505 
00506 void LLPrimitive::setVelocityZ(const F32 z)                                                     
00507 { 
00508         if (llfinite(z))
00509         {
00510                 mVelocity.mV[VZ] = z;
00511         }
00512         else
00513         {
00514                 llerror("Non Finite in LLPrimitive::setVelocityZ", 0);
00515         }
00516 }
00517 
00518 void LLPrimitive::addVelocity(const LLVector3& vel)                     
00519 { 
00520         if (vel.isFinite())
00521         {
00522                 mVelocity += vel;
00523         }
00524         else
00525         {
00526                 llerror("Non Finite in LLPrimitive::addVelocity", 0);
00527         }
00528 }
00529 
00530 void LLPrimitive::setAcceleration(const LLVector3& accel)               
00531 { 
00532         if (accel.isFinite())
00533         {
00534                 mAcceleration = accel; 
00535         }
00536         else
00537         {
00538                 llerrs << "Non Finite in LLPrimitive::setAcceleration(LLVector3) for " << pCodeToString(mPrimitiveCode) << llendl;
00539         }
00540 }
00541 
00542 void LLPrimitive::setAcceleration(const F32 x, const F32 y, const F32 z)                
00543 { 
00544         if (llfinite(x) && llfinite(y) && llfinite(z))
00545         {
00546                 mAcceleration.setVec(x,y,z); 
00547         }
00548         else
00549         {
00550                 llerrs << "Non Finite in LLPrimitive::setAcceleration(F32,F32,F32) for " << pCodeToString(mPrimitiveCode) << llendl;
00551         }
00552 }
00553 #endif // CHECK_FOR_FINITE
00554 
00555 inline BOOL LLPrimitive::validTE(const U8 te_num) const
00556 {
00557         return (mNumTEs && te_num < mNumTEs);
00558 }
00559 
00560 #endif
00561