HPropert.h

Go to the documentation of this file.

// BC  6/14/2005  \Master120\Include\SDK\HPropert.h
//NAP Bitmap COMEBACK RGBFloat needs old ColorVector functions for backward compata
#define __HPROPERT_H

#ifndef _SMALLPDB

#ifndef __HHASHOBJ_H
#include "SDK/HHashObj.h"
#endif

#ifndef __DATAVALUE_H
#include "DataValue.h"
#endif

#ifndef __COLORVEC_H
#include "ColorVec.h"
#endif

//*********************************************************
//** HPropertyInfo
//*********************************************************

class PLUGINEXPORT HPropertyInfo
{
public:
   enum  DrawWhen { DRAWNEVER, DRAWALWAYS, DRAWIFSHADED, DRAWIFFLARES, DRAWIFMATERIALS, DRAWIFPARTICLES };
   enum  VisibleWhen { VISIBLENEVER, VISIBLEALWAYS, VISIBLECACHEONLY, VISIBLEINSTANCEONLY, VISIBLESOMETIMES };

   static HPropertyInfo *New( const char *localizedname, const char *matchname );
   void  operator delete( void *ptr ) { DeleteHandle( (HPropertyInfo *)ptr ); }
   static void DeleteHandle(HPropertyInfo *handle);
   
   void SetLocalizedName(const char *name); // for backward comp with V9.0o and older
   void SetMatchName(const char *name); // for backward comp with V9.0o and older
   
   void SetLocalizedName(const String &name);
   void SetMatchName(const String &name);
   String GetLocalizedName();
   String GetMatchName();
   void SetDocumentation(const char *doc);
   
   DrawWhen GetDrawWhen();
   void SetDrawWhen(DrawWhen dw);
   
   VisibleWhen GetVisibleWhen();
   void SetVisibleWhen(VisibleWhen vw);

   BOOL IsConstant();
   void SetConstant(BOOL state); // Constant will not animate over time

   BOOL IsReadOnly(); // Both cache and instanes will be read only
   void SetReadOnly(BOOL state);

   BOOL IsReadOnlyOnCache(); // User will not be able to change the value on the cache, SetReadOnly should be set to FALSE if you want the instances to be able to be editied
   void SetReadOnlyOnCache(BOOL state);

   BOOL IsReadOnlyOnInstance(); // User will not be able to change the value on the instance, SetReadOnly should be set to FALSE if you want the caches to be able to be editied
   void SetReadOnlyOnInstance(BOOL state);

   BOOL IsAdvanced(); // only shows up if user has Show Advanced Proerties on
   void SetAdvanced(BOOL state);

   BOOL IsSaveProperty(); // Defaults to TRUE
   void SetSaveProperty(BOOL state);

   BOOL IsNotifyAnimObjectValueChanged();
   void SetNotifyAnimObjectValueChanged(BOOL state); // use this to have HxtOnPtrMessage called for your property.  This is a speed hit
                                                    // so only set it if you really want the function to be called
   BOOL IsDeletable();
   void SetDeletable(BOOL state);

   void SetCacheAnimatable( BOOL state );
   BOOL GetCacheAnimatable();
};

//*********************************************************
//** HProperty
//*********************************************************
class HPropertyDriver;
class HPropertyShortcut;

class PLUGINEXPORT HProperty : public HHashObject
{
public:
   HPropertyInfo *GetPropertyInfo() const;
   HPropertyDriver *GetHeadDriver() const;
   
   void Show( BOOL bShow = TRUE );
   
   void SetNullable(BOOL isnullable);
   BOOL IsNullable();
   BOOL IsNull();
   void SetNull( BOOL state=TRUE, HAnimObject *animob=NULL );
   void SetIsDynamic(BOOL isdynamic);
   BOOL IsDynamic();
   
   HHashObject *CreateParentForDriver();
   HProperty *GetDriverProperty();
   void AddDriver(HPropertyDriver *);
   
   int Compare( const HProperty *other, BOOL dochildren=TRUE );  // 0 => EQUAL, 1 => NOT EQUAL
   
   BOOL IsDefaultValue() const;
   int GetIndex() const;
   
   void Copy(const HProperty *other);
   HPropertyShortcut *FindEmptyRelation();//should return HEmptyRelation probably
   HProperty *GetPropertyCache();
   HProperty *MakeCopy();
   
   String ToString();
   
   BOOL GetFirstRelationKey();
   BOOL GetNextRelationKey();
   BOOL GetPrevRelationKey(BOOL *pHasKey);
   
   HProperty *GetParentProperty();
   
   BOOL IsUserProperty();
};

//*********************************************************
//** HBoolPropertyInfo
//*********************************************************
class PLUGINEXPORT HBoolPropertyInfo : public HPropertyInfo
{
public:
   static HBoolPropertyInfo *New( const char *localizedname, const char *matchname );
   void SetDefaultValue( BOOL val );
   BOOL GetDefaultValue() const;

   void SetDisplayInPoseSlider(BOOL show);
   BOOL GetDisplayInPoseSlider();
};

//*********************************************************
//** HBoolProperty
//*********************************************************
class PLUGINEXPORT HBoolProperty : public HProperty
{
public:
   static HBoolProperty *New();
   static HBoolProperty *New( HBoolPropertyInfo *propinfo );
   BOOL GetValue() const;
   BOOL GetValue( Time time );
   void SetValue( BOOL value );
   void StoreValue( Time time, BOOL value, BOOL storeundo=TRUE );
};

//*********************************************************
//** HContainerProperty
//*********************************************************
class PLUGINEXPORT HContainerProperty : public HProperty
{
public:
   static HContainerProperty *New();
   static HContainerProperty *New( HPropertyInfo *propinfo );
};

//*********************************************************
// HCategoryProperty
// Maintains an array of sub variables
//*********************************************************
class PLUGINEXPORT HCategoryProperty : public HContainerProperty
{
public:
   static HCategoryProperty *New();
   static HCategoryProperty *New( HPropertyInfo *propinfo );
   int AddProperty( HProperty *property );
   BOOL RemoveProperty( HProperty *property);
};

//*********************************************************
//** HUserCategoryProperty
//*********************************************************
class PLUGINEXPORT HUserCategoryProperty : public HCategoryProperty
{
public:
   static HUserCategoryProperty *New();//Use this to add folders to other UserCategoryProperties
//   If trytokeep is TRUE the property name will be the name passed in if it doesn't exist,
//   otherwise it will be the name appended by a instance number of the name
   int AddUserProperty(HProperty *property, const String &basestring, BOOL trytokeepname=FALSE); // No PropertyInfo needed in passed in Property because it is dynamically allocated in this call
};

//*********************************************************
//** HBoolCategoryProperty
//*********************************************************
class PLUGINEXPORT HBoolCategoryProperty : public HCategoryProperty
{
public:
   static HBoolCategoryProperty *New();
   static HBoolCategoryProperty *New( HBoolPropertyInfo *propinfo );

   BOOL GetValue() const;
   BOOL GetValue( Time time );
   void SetValue( BOOL value );
   void StoreValue( Time time, BOOL value, BOOL storeundo=TRUE );
};

class HTypePropertyInfo;
//*********************************************************
//** HTypeCategoryProperty
//*********************************************************
class PLUGINEXPORT HTypeCategoryProperty : public HCategoryProperty
{
public:
   static HTypeCategoryProperty *New();
   static HTypeCategoryProperty *New( HTypePropertyInfo *propinfo );

   UINT GetValue() const;
   UINT GetValue( Time time );
   void SetValue( UINT value );
   void StoreValue( Time time, UINT value, BOOL storeundo=TRUE );
};

//*********************************************************
//** HAttrPropertyInfo
//*********************************************************
class PLUGINEXPORT HAttrPropertyInfo : public HPropertyInfo
{
public:
   static HAttrPropertyInfo *New( const char *localizedname, const char *matchname );
};

//*********************************************************
//** HAttrProperty
//*********************************************************
class HColorProperty;
class HFloatProperty;
class HPercentProperty;
class HMaterial;

class PLUGINEXPORT HAttrProperty : public HContainerProperty
{
public:
   static HAttrProperty *New( HAttrPropertyInfo *propinfo );
   static HAttrProperty *New();

   HAttrProperty *GetBaseAttr();
      
   HColorProperty *GetDiffuseColor();
   HFloatProperty *GetDiffuseFallOff();
   HColorProperty *GetAmbianceColor();
   HColorProperty *GetAmbianceColorForRead();
   HFloatProperty *GetAmbiance();
   HColorProperty *GetSpecularColor();
   HColorProperty *GetSpecularColorForRead();
   HFloatProperty *GetSpecularSize();
   HFloatProperty *GetSpecularIntensity();
   HFloatProperty *GetRoughness();
   HFloatProperty *GetRoughnessScale();
   HFloatProperty *GetTransparency();
   HFloatProperty *GetDensity();
   HFloatProperty *GetRefraction();
   HFloatProperty *GetTranslucency();
   HFloatProperty *GetReflectivity();
   HPercentProperty *GetReflectiveBlend();
   HFloatProperty *GetReflectivityFallOff();
   HFloatProperty *GetRadiance();
   HBoolProperty  *GetGlow();
   BOOL IsComplex();   // tells whether a pre-composited attr is complex (Combiners etc..)
   BOOL IsBump();      // tells whether any of the materials on a pre-composited attr had bump on
   BOOL IsInvariant(); // tells whether any of the materials on a pre-composited attr were invariant
   BOOL IsDisplace();  // tells whether any of the materials on a pre-composited attr had displace on
   HMaterial *GetMaterialHead();
};

//*********************************************************
//** HFileInfoPropertyInfo
//*********************************************************
class PLUGINEXPORT HFileInfoPropertyInfo : public HPropertyInfo
{
public:
};

class HFilenameProperty;
class HStringProperty;
//*********************************************************
//** HFileInfoProperty
//*********************************************************
class PLUGINEXPORT HFileInfoProperty : public HContainerProperty
{
public:
   HBoolProperty     *GetEmbedded();
   HFilenameProperty *GetFileName();
   HStringProperty   *GetCreatedBy();
   HStringProperty   *GetLastModifiedBy();
   HStringProperty   *GetDescription();
   HStringProperty   *GetNotes();
};

//*********************************************************
//** HFloatPropertyInfo
//*********************************************************
class PLUGINEXPORT HFloatPropertyInfo : public HPropertyInfo
{
public:
   enum { FF_X           = 0x0001,
          FF_Y           = 0x0002,
          FF_Z           = 0x0003,

          FF_RED         = 0x0008,
          FF_GREEN       = 0x0010,
          FF_BLUE        = 0x0020,

          FF_UNIT        = 0x0040,
          FF_PERCENTAGE  = 0x0080,
          FF_ANGLE       = 0x0100
        };

   static HFloatPropertyInfo *New( const char *localizedname, const char *matchname );
   void SetFactorValue( float val ); // Set Factor before calling SetDefault, SetMin or SetMax
   void SetModulo( float modulo );
   void SetDefaultValue( float val );
   void SetMinValue( float val );
   void SetMaxValue( float val );
   void SetFlags(UINT flags);
   
   float GetFactorValue() const;
   float GetDefaultValue() const;
   float GetMinValue() const;
   float GetMaxValue() const;
   UINT  GetFlags() const;
   
   void SetDisplayInPoseSlider(BOOL show);
   BOOL GetDisplayInPoseSlider();
};

//*********************************************************
//** HFloatProperty
//*********************************************************
class PLUGINEXPORT HFloatProperty : public HProperty
{
public:
   static HFloatProperty *New();
   static HFloatProperty *New( HFloatPropertyInfo *propinfo );
   float GetValue() const;
   float GetValue( Time time );
   void SetValue(float value);
   void StoreValue(Time time, float value, BOOL storeundo = TRUE);
};

//*********************************************************
//** HPercentPropertyInfo
//*********************************************************
class PLUGINEXPORT HPercentPropertyInfo : public HFloatPropertyInfo
{
public:

   static HPercentPropertyInfo *New( const char *localizedname, const char *matchname );
};

//*********************************************************
//** HPercentProperty
//*********************************************************
class PLUGINEXPORT HPercentProperty : public HFloatProperty
{
public:
   static HPercentProperty *New();
   static HPercentProperty *New( HPercentPropertyInfo *propinfo );
};

//*********************************************************
//** HIntPropertyInfo
//*********************************************************
class PLUGINEXPORT HIntPropertyInfo : public HPropertyInfo
{
public:
   static HIntPropertyInfo *New( const char *localizedname, const char *matchname );
   void SetDefaultValue( int val );
   void SetMinValue( int val );
   void SetMaxValue( int val );

   int GetDefaultValue() const;
   int GetMinValue() const;
   int GetMaxValue() const;
};

//*********************************************************
//** HIntProperty
//*********************************************************
class PLUGINEXPORT HIntProperty : public HProperty
{
public:
   static HIntProperty *New();
   static HIntProperty *New( HIntPropertyInfo *propinfo );
   int GetValue() const;
   int GetValue( Time time );
   void SetValue(int value);
   void StoreValue(Time time, int value, BOOL storeundo = TRUE);
};

//*********************************************************
//** HRotatePropertyInfo
//*********************************************************
class PLUGINEXPORT HRotatePropertyInfo : public HPropertyInfo
{
public:
   static HRotatePropertyInfo *New( const char *localizedname, const char *matchname );
};

//*********************************************************
//** HRotateProperty
//*********************************************************
class PLUGINEXPORT HRotateProperty : public HProperty
{
public:
   enum InterpolationMethod { VECTORINTERP, EULERINTERP, QUATINTERP };

   static HRotateProperty *New();
   static HRotateProperty *New( HRotatePropertyInfo *propinfo );
   
   InterpolationMethod GetDefaultObjectInterpolationMethod();
   void SetDefaultObjectInterpolationMethod(InterpolationMethod method);
   InterpolationMethod GetDefaultBoneInterpolationMethod();
   void SetDefaultBoneInterpolationMethod(InterpolationMethod method);
   InterpolationMethod GetDefaultRootBoneInterpolationMethod();
   void SetDefaultRootBoneInterpolationMethod(InterpolationMethod method);
   
   const Quaternion &GetValue() const;
   const Quaternion &GetValue( Time time );
   void SetValue( const Quaternion &value );
   void StoreValue( Time time, const Quaternion &value, BOOL storeroll=TRUE);// old for Backward compatibility, Defaults TRUE for StoreUndo
   void StoreValue( Time time, const Quaternion &value, BOOL storeroll, BOOL storeundo);
};

//*********************************************************
//** HButtonPropertyInfo
//*********************************************************
class PLUGINEXPORT HButtonPropertyInfo : public HPropertyInfo
{
public:
   static HButtonPropertyInfo *New( const char *localizedname, const char *matchname );
   
   void SetButtonText(const char *);
   const char *GetButtonText() const;
};

//*********************************************************
//** HButtonProperty
//*********************************************************
class PLUGINEXPORT HButtonProperty : public HProperty
{
public:
   static HButtonProperty *New();
   static HButtonProperty *New( HButtonPropertyInfo *propinfo );

   void SetButtonText(const char *); // Use this over the ones in ButtonPropertyInfo if you need to change the text on different instances of the property
   const char *GetButtonText() const;
   void Press();
};

//*********************************************************
//** HBiasPropertyInfo
//*********************************************************
class PLUGINEXPORT HBiasPropertyInfo : public HPropertyInfo
{
public:
   static HBiasPropertyInfo *New( const char *localizedname, const char *matchname );
   
   HFloatPropertyInfo *GetAlphaPropertyInfo();
   HFloatPropertyInfo *GetGammaPropertyInfo();
   HFloatPropertyInfo *GetMagnitudePropertyInfo();
};

//*********************************************************
//** HBiasProperty
//*********************************************************
class PLUGINEXPORT HBiasProperty : public HProperty
{
public:
   static HBiasProperty *New();
   static HBiasProperty *New( HBiasPropertyInfo *propinfo );

   float GetAlpha();
   float GetGamma();
   float GetMagnitude();
   void SetAlpha( float num );
   void SetGamma( float num );
   void SetMagnitude( float num );

   const Vector &GetValue();
   const Vector &GetValue(Time time);
   Vector GetFactoredValue();

   void SetFactoredValue( const Vector &value );
   void SetValue( const Vector &value );
   void StoreValue( Time time, const Vector &value, BOOL storeundo=TRUE );
};

//*********************************************************
//** HStringPropertyInfo
//*********************************************************
class PLUGINEXPORT HStringPropertyInfo : public HPropertyInfo
{
public:
   static HStringPropertyInfo *New( const char *localizedname, const char *matchname );
   void SetDefaultValue( const char *value );
   void SetIllegalChars( const char *value );
   const char *GetDefaultValue() const;
   const char *GetIllegalChars() const;
};

//*********************************************************
//** HStringProperty
//*********************************************************
class PLUGINEXPORT HStringProperty : public HProperty
{
public:
   static HStringProperty *New();
   static HStringProperty *New( HStringPropertyInfo *propinfo );
   const char *GetValue() const;
   void SetValue( const char *value );
   void StoreValue(const char *value, BOOL storeundo = TRUE);
};

//*********************************************************
//** HFilenamePropertyInfo
//*********************************************************
class PLUGINEXPORT HFilenamePropertyInfo : public HStringPropertyInfo
{
public:
   static HFilenamePropertyInfo *New( const char *localizedname, const char *matchname );
   void SetFileDialogTitle( const char *value );
   void SetFileDialogFilter( const char *value );
   void SetDefaultExtension( const char *value );
   void SetIsOpenDialog( BOOL isopendialog );
   const char *GetFileDialogTitle() const;
   const char *GetFileDialogFilter() const;
   const char *GetDefaultExtension() const;
   BOOL IsOpenDialog() const;
   BOOL IsPromptForMissingFileOnLoad();
   void SetIsPromptForMissingFileOnLoad(BOOL state);
};

//*********************************************************
//** HFilenameProperty
//*********************************************************
class PLUGINEXPORT HFilenameProperty : public HStringProperty
{
public:
   static HFilenameProperty *New();
   static HFilenameProperty *New( HFilenamePropertyInfo *propinfo );
};

//*********************************************************
//** HDirPropertyInfo
//*********************************************************
class PLUGINEXPORT HDirPropertyInfo : public HStringPropertyInfo
{
public:
   static HDirPropertyInfo *New( const char *localizedname, const char *matchname );
   void SetFileDialogTitle( const char *value );
   const char *GetFileDialogTitle() const;
};

//*********************************************************
//** HDirProperty
//*********************************************************
class PLUGINEXPORT HDirProperty : public HStringProperty
{
public:
   static HDirProperty *New();
   static HDirProperty *New( HDirPropertyInfo *propinfo );
};

//*********************************************************
//** HTimePropertyInfo
//*********************************************************
class PLUGINEXPORT HTimePropertyInfo : public HPropertyInfo
{
public:
   static HTimePropertyInfo *New( const char *localizedname, const char *matchname );
   void SetDefaultValue( Time val );
   void SetMinValue( Time val );
   void SetMaxValue( Time val );

   Time GetDefaultValue() const;
   Time GetMinValue() const;
   Time GetMaxValue() const;
};

//*********************************************************
//** HTimeProperty
//*********************************************************
class PLUGINEXPORT HTimeProperty : public HProperty
{
public:
   static HTimeProperty *New();
   static HTimeProperty *New( HTimePropertyInfo *propinfo );
   Time GetValue() const;
   Time GetValue(Time time);
   void SetValue(Time value);
   void StoreValue(Time time, Time value, BOOL storeundo = TRUE);
};

//*********************************************************
//** HTimeRangePropertyInfo
//*********************************************************
class PLUGINEXPORT HTimeRangePropertyInfo : public HPropertyInfo
{
public:
   static HTimeRangePropertyInfo *New( const char *localizedname, const char *matchname );
};

//*********************************************************
//** HTimeRangeProperty
//*********************************************************
class PLUGINEXPORT HTimeRangeProperty : public HContainerProperty
{
public:
   static HTimeRangeProperty *New();
   static HTimeRangeProperty *New( HTimeRangePropertyInfo *propinfo );
   HTimeProperty *GetStart();
   HTimeProperty *GetEnd();
};

//*********************************************************
//** HTransformPropertyInfo
//*********************************************************
class PLUGINEXPORT HTransformPropertyInfo : public HPropertyInfo
{
public:
   static HTransformPropertyInfo *New( const char *localizedname, const char *matchname );
};

class HTranslateProperty;
class HScaleProperty;
class HRotateProperty;
//*********************************************************
//** HTransformProperty
//*********************************************************
class PLUGINEXPORT HTransformProperty : public HProperty
{
public:
   static HTransformProperty *New();
   static HTransformProperty *New( HTransformPropertyInfo *propinfo );
   HTranslateProperty *GetTranslate();
   HScaleProperty *GetScale();
   HRotateProperty *GetRotate();
   TSQ GetTSQ() const;
};

class HTypeInfo;
//*********************************************************
//** TypeInfoArray
//*********************************************************
class PLUGINEXPORT TypeInfoArray
{
private:
   HTypeInfo *m_typeinfoarray;
   int m_count;

   void AllocArray(HTypeInfo **array, int count);
   void DeleteArray(HTypeInfo *array);
   HTypeInfo *ElementAt(HTypeInfo *array, int index);

public:
   TypeInfoArray() {
      m_typeinfoarray = NULL;
      m_count = 0;
   }
   ~TypeInfoArray() {
      DeleteArray(m_typeinfoarray);
   }
   void SetArraySize(int count) { 
      DeleteArray(m_typeinfoarray);
      AllocArray(&m_typeinfoarray, count);
      m_count = count;
   }
   void DeleteArray() { 
      DeleteArray(m_typeinfoarray);
      m_typeinfoarray = NULL;
      m_count = 0;
   }
   HTypeInfo *operator [] ( int index ) { return ElementAt(m_typeinfoarray, index); }

// Internal use only
   HTypeInfo *GetTypeInfoArrayData() { return m_typeinfoarray; }
   int GetCount() const { return m_count; }
};

//*********************************************************
//** HTypeInfo
//*********************************************************
class PLUGINEXPORT HTypeInfo
{
public:
   String GetMatchName() const;
   String GetLocalizedName() const;
   void SetMatchName(const String &name);
   void SetLocalizedName(const String &name);
   void SetMatchName(const char *);  // Old for backward Compatibility with version 9.0o and older
   void SetLocalizedName(const char *);  // Old for backward Compatibility with version 9.0o and older
};

//*********************************************************
//** HTypePropertyInfo
//*********************************************************
class PLUGINEXPORT HTypePropertyInfo : public HPropertyInfo
{
public:
   static HTypePropertyInfo *New( const char *localizedname, const char *matchname, TypeInfoArray *typeinfoarray );
   
   void SetDefaultIndex(UINT index);
   UINT GetDefaultIndex() const;   
};

//*********************************************************
//** HTypeProperty
//*********************************************************
class PLUGINEXPORT HTypeProperty : public HProperty
{
public:
   static HTypeProperty *New();
   static HTypeProperty *New( HTypePropertyInfo *propinfo );
   
   UINT GetValue() const;
   UINT GetValue( Time time );
   void SetValue( UINT value );
   void StoreValue( Time time, UINT value, BOOL storeundo = TRUE);
};

//*********************************************************
//** HVectorPropertyInfo
//*********************************************************
class PLUGINEXPORT HVectorPropertyInfo : public HPropertyInfo
{
public:
   static HVectorPropertyInfo *New( const char *localizedname, const char *matchname );
   
   HFloatPropertyInfo *GetX();
   HFloatPropertyInfo *GetY();
   HFloatPropertyInfo *GetZ();
   
   Vector GetDefaultValue() const;
   void SetDefaultValue(const Vector &v);
};

//*********************************************************
//** HVectorProperty
//*********************************************************
class PLUGINEXPORT HVectorProperty : public HProperty
{
public:
   static HVectorProperty *New();
   static HVectorProperty *New(HVectorPropertyInfo *propinfo);

   Vector GetValue() const;
   Vector GetValue( Time time );
   void SetValue( const Vector &value );
   void StoreValue( Time time, const Vector &value, BOOL storeundo=TRUE );
   
   HFloatProperty *GetX();
   HFloatProperty *GetY();
   HFloatProperty *GetZ();
};

//*********************************************************
//** HVectorPropertyNoSubsInfo
//*********************************************************
class PLUGINEXPORT HVectorPropertyNoSubsInfo : public HPropertyInfo
{
public:
   static HVectorPropertyNoSubsInfo *New( const char *localizedname, const char *matchname );
   
   HFloatPropertyInfo *GetX();
   HFloatPropertyInfo *GetY();
   HFloatPropertyInfo *GetZ();
   
   Vector GetDefaultValue() const;
   void SetDefaultValue(const Vector &v);
};

//*********************************************************
//** HVectorPropertyNoSubs
//*********************************************************
class PLUGINEXPORT HVectorPropertyNoSubs : public HProperty
{
public:
   static HVectorPropertyNoSubs *New();
   static HVectorPropertyNoSubs *New(HVectorPropertyNoSubsInfo *propinfo);

   float GetXFactor() const;
   float GetYFactor() const;
   float GetZFactor() const;
   const Vector &GetValue() const;
   const Vector &GetValue(Time time);
   Vector GetFactoredValue() const;
   void SetFactoredValue( const Vector &value );
   void SetValue( const Vector &value );
   void StoreValue( Time time, const Vector &value, BOOL storeundo=TRUE );
};

//*********************************************************
//** HVector2PropertyInfo
//*********************************************************
class PLUGINEXPORT HVector2PropertyInfo : public HPropertyInfo
{
public:
   static HVector2PropertyInfo *New( const char *localizedname, const char *matchname );
   
   HFloatPropertyInfo *GetX();
   HFloatPropertyInfo *GetY();

   Vector2 GetDefaultValue() const;
   void SetDefaultValue(const Vector2 &v);
};

//*********************************************************
//** HVector2Property
//*********************************************************
class PLUGINEXPORT HVector2Property : public HProperty
{
public:
   static HVector2Property *New();
   static HVector2Property *New(HVector2PropertyInfo *propinfo);

   Vector2 GetValue(  ) const;
   Vector2 GetValue( Time time );
   void SetValue( const Vector2 &value );
   void StoreValue( Time time, const Vector2 &value, BOOL storeundo=TRUE );
   
   HFloatProperty *GetX();
   HFloatProperty *GetY();
};

//*********************************************************
//** HColorPropertyInfo
//*********************************************************
class PLUGINEXPORT HColorPropertyInfo : public HVectorPropertyInfo
{
public:
   static HColorPropertyInfo *New( const char *localizedname, const char *matchname );

   HFloatPropertyInfo *GetRed();
   HFloatPropertyInfo *GetGreen();
   HFloatPropertyInfo *GetBlue();
   
   RGBFloat GetDefaultRGBFloatValue() const;
   /*don't use this one anymore*/ ColorVector GetDefaultValue() const;

   void SetDefaultValue(const RGBFloat &rgbfloat);
   /*don't use this one anymore*/ void SetDefaultValue(const ColorVector &cv);
};

//*********************************************************
//** HColorProperty
//*********************************************************
class ColorBuf;
class PLUGINEXPORT HColorProperty : public HVectorProperty
{
public:
   static HColorProperty *New();
   static HColorProperty *New(HColorPropertyInfo *propinfo);

   HFloatProperty *GetRed();
   HFloatProperty *GetGreen();
   HFloatProperty *GetBlue();

   float GetLuminance()const;

   COLORREF GetCOLORREF() const;
   RGBFloat GetFactoredRGBFloat() const;
   /*don't use this one anymore*/ ColorVector GetFactoredColorVector() const;
   
   RGBFloat GetNormalizedRGBFloat() const;
   /*don't use this one anymore*/ ColorVector GetNormalizedColorVector() const;
   
   void SetValue( const RGBFloat &value );
   /*don't use this one anymore*/ void SetValue( const ColorVector &value );
   
   void StoreValue( Time time, const RGBFloat &value, BOOL storeundo=TRUE );
   /*don't use this one anymore*/ void StoreValue( Time time, const ColorVector &value, BOOL storeundo=TRUE );
   
   void StoreValue( Time time, const ColorBuf &value, BOOL storeundo=TRUE );
};

//*********************************************************
//** HScalePropertyInfo
//*********************************************************
class PLUGINEXPORT HScalePropertyInfo : public HVectorPropertyInfo
{
public:
   static HScalePropertyInfo *New( const char *localizedname, const char *matchname );
};

//*********************************************************
//** HScaleProperty
//*********************************************************
class PLUGINEXPORT HScaleProperty : public HVectorProperty
{
public:
   static HScaleProperty *New();
   static HScaleProperty *New(HScalePropertyInfo *propinfo);
};

//*********************************************************
//** HTranslatePropertyInfo
//*********************************************************
class PLUGINEXPORT HTranslatePropertyInfo : public HVectorPropertyInfo
{
public:
   static HTranslatePropertyInfo *New( const char *localizedname, const char *matchname );
};

//*********************************************************
//** HTranslateProperty
//*********************************************************
class PLUGINEXPORT HTranslateProperty : public HVectorProperty
{
public:
   static HTranslateProperty *New();
   static HTranslateProperty *New(HTranslatePropertyInfo *propinfo);
};

//*********************************************************
//** HTranslatePropertyNoSubs
//*********************************************************
class PLUGINEXPORT HTranslatePropertyNoSubs : public HVectorPropertyNoSubs
{
public:
   static HTranslateProperty *New();
   static HTranslateProperty *New(HTranslatePropertyInfo *propinfo);
};

//*********************************************************
//** HObjectListNode
//*********************************************************
class PLUGINEXPORT HObjectListNode 
{
public:
   HObjectListNode *GetSibling();
   void SetSibling(HObjectListNode *);

   HTreeObject *GetObject();
   void SetObject(HTreeObject *);
   
   static HObjectListNode *New();
   static HObjectListNode *New( HTreeObject *obj, HObjectListNode *next );

   void  operator delete( void *ptr ) { DeleteHandle( (HObjectListNode *)ptr ); }
   static void DeleteHandle(HObjectListNode *handle);
};

//*********************************************************
//** HPointerPropertyInfo
//*********************************************************
class PLUGINEXPORT HPointerPropertyInfo : public HPropertyInfo
{
public:
   static HPointerPropertyInfo *New( const char *localizedname, const char *matchname );
};

//*********************************************************
//** HPointerProperty
//*********************************************************
class PLUGINEXPORT HPointerProperty : public HProperty
{
public:
   static HPointerProperty *New();
   static HPointerProperty *New(HPointerPropertyInfo *propinfo);
   HTreeObject *GetValue();
   void SetValue( HTreeObject *obj ); // Rarely used
   void StoreValue( Time time, HTreeObject *obj, BOOL storeundo=TRUE );
   String GetDescription();
   void SetDescription(const String &);
};

//*********************************************************
//** HClipPropertyInfo
//*********************************************************
class PLUGINEXPORT HClipPropertyInfo : public HPointerPropertyInfo
{
public:
   static HClipPropertyInfo *New( const char *localizedname, const char *matchname );
   HVector2PropertyInfo *GetRepeatInfo();
   HTimePropertyInfo *GetTimeInfo();
   HBoolPropertyInfo *GetSeamlessInfo();
};

class HClip;
//*********************************************************
//** HClipProperty
//*********************************************************
class PLUGINEXPORT HClipProperty : public HContainerProperty
{
public:
   static HClipProperty *New();
   static HClipProperty *New(HClipPropertyInfo *propinfo);
   HClip *GetClip();
   
   HVector2Property *GetRepeat();
   HTimeProperty *GetTime();
   HBoolProperty *GetIsSeamless();
   
   int  GetWidth();
   int  GetHeight();
   BOOL ReadBitmap( float x, float y, RGBFloat *diffuse, float *opacity, float pixelwidth);
   /*don't use this one anymore*/ BOOL ReadBitmap( float x, float y, ColorVector *diffuse, float *opacity, float pixelwidth);
   
   BOOL ReadBumpmap( float x, float y, Vector2 &delta, float pixelwidth );
   BOOL LoadImage( const String &filename );
};

//*********************************************************
//** HTexInfo
//*********************************************************
class PLUGINEXPORT HTexInfo 
{
public:
   HAttrProperty *GetAttr();
   Vector        *GetN(); // Screen Space
   float          GetHeight();
   void           SetHeight( float val );
   Time           GetTime();
   float          GetFPS();
   float          GetPixelWidth();
   Vector         GetGlobalP(); // World Space, If from a HSHader plugin, us HSHader::GetHitP rather than this.
   Vector         GetEye(); // Screen Space
   Vector         GetD(); // Screen Space
   Matrix34      *GetMatrix(); //Model Space To Screen Space
   int            GetObjectType();
   HObject       *GetObject();
   void          *GetSubObject();
};

//*********************************************************
//** HShading
//*********************************************************
class PLUGINEXPORT HShading : public HProperty
{
public:
   HTexInfo    *GetTexInfo();
   RGBFloat *GetACol(); //these gets invalidate plugins that used to use this built for v11.1 or earlier
   RGBFloat *GetDCol(); //should probably rewrite with RGBFloat GetACol(), and SetACol(RGBFloat &)
   RGBFloat *GetSCol(); //since these invalidate anyways.
   Vector      *GetAway();
   Vector      *GetL();
   float        GetIntensity();
   float        GetLDot();
   float        GetEDot();
   int          GetObjectType();
   HObject     *GetObject();
   void        *GetSubObject();
   Vector       GetHitP();
};

//*********************************************************
//** HGradientPropertyInfo
//*********************************************************
class PLUGINEXPORT HGradientPropertyInfo : public HPropertyInfo
{
public:
   static HGradientPropertyInfo *New( const char *localizedname, const char *matchname );
};

//*********************************************************
//** HGradientProperty
//*********************************************************
class PLUGINEXPORT HGradientProperty : public HProperty
{
public:
   static HGradientProperty *New();
   static HGradientProperty *New(HGradientPropertyInfo *propinfo);
   RGBFloat GetColor( RGBFloat &diffuse, float n );
   /*don't use this one anymore*/ ColorVector GetColor( ColorVector &diffuse, float n );
};

//*********************************************************
//** HDataPropertyInfo
//*********************************************************
class PLUGINEXPORT HDataPropertyInfo : public HPropertyInfo
{
public:
   static HDataPropertyInfo *New( const char *localizedname, const char *matchname );

   void SetDefaultValue( const DataValue &value );
   const DataValue &GetDefaultValue() const;

   void SetSaveCompressed( BOOL savecompressed );
   BOOL GetSaveCompressed() const;
};

//*********************************************************
//** HDataProperty
//*********************************************************
class PLUGINEXPORT HDataProperty : public HProperty
{
public:
   static HDataProperty *New();
   static HDataProperty *New( HDataPropertyInfo *propinfo );
   const DataValue &GetValue() const;
   DataValue GetValue(Time time) const;
   void SetValue( const DataValue &value );
   void StoreValue(const DataValue &value, BOOL storeundo = TRUE); // Stores at Time 0
   void StoreValue( Time time, const DataValue &value, BOOL storeundo=TRUE );
};

#endif

---