CigiBaseSymbolSurfaceDef.h

Go to the documentation of this file.

#if !defined(_CIGI_BASE_SYMBOL_SURFACE_DEF_INCLUDED_)
#define _CIGI_BASE_SYMBOL_SURFACE_DEF_INCLUDED_


#include "CigiBasePacket.h"

// ====================================================================
// preprocessor definitions
// ====================================================================

#define CIGI_SYMBOL_SURFACE_DEF_PACKET_ID_V3_3 29
#define CIGI_SYMBOL_SURFACE_DEF_PACKET_SIZE_V3_3 56


class CigiSymbolSurfaceDefV3_3;


//=========================================================
class CIGI_SPEC CigiBaseSymbolSurfaceDef :
   public CigiBasePacket
{

   friend class CigiSymbolSurfaceDefV3_3;

public:

   //=========================================================
   enum StateGrp
   {
      Active=0,
      Destroyed=1
   };

   //=========================================================
   enum AttachStateGrp
   {
      EntityAttached=0,
      ViewAttached=1
   };

   //=========================================================
   enum BillboardStateGrp
   {
      NotBillboard=0,
      Billboard=1
   };

   //=========================================================
   enum PerspectiveGrowthStateGrp
   {
      Disable=0,
      Enable=1
   };


   //==> Management

   //=========================================================
   CigiBaseSymbolSurfaceDef(void);

   //=========================================================
   virtual ~CigiBaseSymbolSurfaceDef(void);


   //==> Buffer Packing/Unpacking

   //=========================================================
   virtual int Pack(CigiBasePacket * Base, Cigi_uint8 * Buff, void *Spec) const=0;

   //=========================================================
   virtual int Unpack(Cigi_uint8 * Buff, bool Swap, void *Spec) =0;

   //=========================================================
   virtual int GetCnvt(CigiVersionID &CnvtVersion,
                       CigiCnvtInfoType::Type &CnvtInfo);



   //==> Accessing Member Variable Values functions

   //+> SurfaceID

   //=========================================================
   int SetSurfaceID(const Cigi_uint16 SurfaceIDIn, bool bndchk=true)
   {
      SurfaceID = SurfaceIDIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   Cigi_uint16 GetSurfaceID(void) const { return(SurfaceID); }


   //+> SurfaceState

   //=========================================================
   int SetSurfaceState(const StateGrp SurfaceStateIn, bool bndchk=true);

   //=========================================================
   StateGrp GetSurfaceState(void) const { return(SurfaceState); }


   //+> Attached

   //=========================================================
   int SetAttached(const AttachStateGrp AttachedIn, bool bndchk=true);

   //=========================================================
   AttachStateGrp GetAttached(void) const { return(Attached); }


   //+> BillBoardState

   //=========================================================
   int SetBillboardState(const BillboardStateGrp BillboardStateIn, bool bndchk=true);

   //=========================================================
   BillboardStateGrp GetBillboardState(void) const { return(BillboardState); }


   //+> PerspectiveGrowth

   //=========================================================
   int SetPerspectiveGrowth(const PerspectiveGrowthStateGrp PerspectiveGrowthIn, bool bndchk=true);

   //=========================================================
   PerspectiveGrowthStateGrp GetPerspectiveGrowth(void) const { return(PerspectiveGrowth); }


   //+> Attach

   //=========================================================
   int SetEntityID(const Cigi_uint16 EntityIDIn, bool bndchk=true)
   {
      EntityViewID = EntityIDIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   Cigi_uint16 GetEntityID(void) const { return(EntityViewID); }

   //=========================================================
   int SetViewID(const Cigi_uint16 ViewIDIn, bool bndchk=true)
   {
      EntityViewID = ViewIDIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   Cigi_uint16 GetViewID(void) const { return(EntityViewID); }


   //+> Offsets

   //=========================================================
   int SetXOffset(const float XOffsetIn, bool bndchk=true)
   {
      XLeft = XOffsetIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   float GetXOffset(void) const { return(XLeft); }

   //=========================================================
   int SetYOffset(const float YOffsetIn, bool bndchk=true)
   {
      YRight = YOffsetIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   float GetYOffset(void) const { return(YRight); }

   //=========================================================
   int SetZOffset(const float ZOffsetIn, bool bndchk=true)
   {
      ZTop = ZOffsetIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   float GetZOffset(void) const { return(ZTop); }


   //+> Attitude

   //=========================================================
   int SetYaw(const float YawIn, bool bndchk=true);

   //=========================================================
   float GetYaw(void) const { return(YawBottom); }

   //=========================================================
   int SetPitch(const float PitchIn, bool bndchk=true);

   //=========================================================
   float GetPitch(void) const { return(Pitch); }

   //=========================================================
   int SetRoll(const float RollIn, bool bndchk=true);

   //=========================================================
   float GetRoll(void) const { return(Roll); }


   //+> Size

   //=========================================================
   int SetWidth(const float WidthIn, bool bndchk=true)
   {
      Width = WidthIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   float GetWidth(void) const { return(Width); }

   //=========================================================
   int SetHeight(const float HeightIn, bool bndchk=true)
   {
      Height = HeightIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   float GetHeight(void) const { return(Height); }



   //+> Symbol Surface Edge Positions

   //=========================================================
   int SetLeftEdgePosition(const float LeftEdgePosition, bool bndchk=true);

   //=========================================================
   float GetLeftEdgePosition(void) const { return(XLeft); }

   //=========================================================
   int SetRightEdgePosition(const float RightEdgePosition, bool bndchk=true);

   //=========================================================
   float GetRightEdgePosition(void) const { return(YRight); }

   //=========================================================
   int SetTopEdgePosition(const float TopEdgePosition, bool bndchk=true);

   //=========================================================
   float GetTopEdgePosition(void) const { return(ZTop); }

   //=========================================================
   int SetBottomEdgePosition(const float BottomEdgePosition, bool bndchk=true);

   //=========================================================
   float GetBottomEdgePosition(void) const { return(YawBottom); }


   //+> Edge Coordinates

   //=========================================================
   int SetMinU(const float MinUIn, bool bndchk=true)
   {
      MinU = MinUIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   float GetMinU(void) const { return(MinU); }

   //=========================================================
   int SetMaxU(const float MaxUIn, bool bndchk=true)
   {
      MaxU = MaxUIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   float GetMaxU(void) const { return(MaxU); }

   //=========================================================
   int SetMinV(const float MinVIn, bool bndchk=true)
   {
      MinV = MinVIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   float GetMinV(void) const { return(MinV); }

   //=========================================================
   int SetMaxV(const float MaxVIn, bool bndchk=true)
   {
      MaxV = MaxVIn;
      return(CIGI_SUCCESS);
   }

   //=========================================================
   float GetMaxV(void) const { return(MaxV); }



protected:

   //==> Member variables

   //=========================================================
   Cigi_uint16 SurfaceID;

   //=========================================================
   StateGrp SurfaceState;

   //=========================================================
   AttachStateGrp Attached;

   //=========================================================
   BillboardStateGrp BillboardState;

   //=========================================================
   PerspectiveGrowthStateGrp PerspectiveGrowth;

   //=========================================================
   Cigi_uint16 EntityViewID;

   //=========================================================
   float XLeft;

   //=========================================================
   float YRight;

   //=========================================================
   float ZTop;

   //=========================================================
   float YawBottom;

   //=========================================================
   float Pitch;

   //=========================================================
   float Roll;

   //=========================================================
   float Width;

   //=========================================================
   float Height;

   //=========================================================
   float MinU;

   //=========================================================
   float MaxU;

   //=========================================================
   float MinV;

   //=========================================================
   float MaxV;




};



#endif   //  #if !defined(_CIGI_BASE_SYMBOL_SURFACE_DEF_INCLUDED_)

---