fbmodel.h

Go to the documentation of this file.

 #ifndef __FBMODEL_H__

fbmodel.h

#define __FBMODEL_H__
/**************************************************************************
 Copyright (c) 1994 - 2009 Autodesk, Inc. and/or its licensors.
 All Rights Reserved.
 
 The coded instructions, statements, computer programs, and/or related 
 material (collectively the "Data") in these files contain unpublished 
 information proprietary to Autodesk, Inc. and/or its licensors, which is 
 protected by Canada and United States of America federal copyright law 
 and by international treaties.
 
 The Data may not be disclosed or distributed to third parties, in whole 
 or in part, without the prior written consent of Autodesk, Inc. 
 ("Autodesk").
 
 THE DATA IS PROVIDED "AS IS" AND WITHOUT WARRANTY.
 ALL WARRANTIES ARE EXPRESSLY EXCLUDED AND DISCLAIMED. AUTODESK MAKES NO 
 WARRANTY OF ANY KIND WITH RESPECT TO THE DATA, EXPRESS, IMPLIED OR 
 ARISING BY CUSTOM OR TRADE USAGE, AND DISCLAIMS ANY IMPLIED WARRANTIES 
 OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR 
 PURPOSE OR USE. WITHOUT LIMITING THE FOREGOING, AUTODESK DOES NOT 
 WARRANT THAT THE OPERATION OF THE DATA WILL BE UNINTERRUPTED OR ERROR 
 FREE.
 
 IN NO EVENT SHALL AUTODESK, ITS AFFILIATES, PARENT COMPANIES, LICENSORS 
 OR SUPPLIERS ("AUTODESK GROUP") BE LIABLE FOR ANY LOSSES, DAMAGES OR 
 EXPENSES OF ANY KIND (INCLUDING WITHOUT LIMITATION PUNITIVE OR MULTIPLE 
 DAMAGES OR OTHER SPECIAL, DIRECT, INDIRECT, EXEMPLARY, INCIDENTAL, LOSS 
 OF PROFITS, REVENUE OR DATA, COST OF COVER OR CONSEQUENTIAL LOSSES OR 
 DAMAGES OF ANY KIND), HOWEVER CAUSED, AND REGARDLESS OF THE THEORY OF 
 LIABILITY, WHETHER DERIVED FROM CONTRACT, TORT (INCLUDING, BUT NOT 
 LIMITED TO, NEGLIGENCE), OR OTHERWISE, ARISING OUT OF OR RELATING TO THE 
 DATA OR ITS USE OR ANY OTHER PERFORMANCE, WHETHER OR NOT AUTODESK HAS 
 BEEN ADVISED OF THE POSSIBILITY OF SUCH LOSS OR DAMAGE.
 
**************************************************************************/

#include <kaydaradef.h>
#ifndef FBSDK_DLL 

    #define FBSDK_DLL K_DLLIMPORT
#endif

#include <fbsdk/fbcore.h>
#include <fbsdk/fbcomponent.h>
#include <fbsdk/fbshader.h> // FBPropertyListShader

// somebody at SGI defined this in their include files
// until we find which one, we remove it
#undef Status

#ifdef FBSDKUseNamespace
    namespace FBSDKNamespace {
#endif
typedef class FBSDK_DLL FBArrayTemplate<HFBModel> FBModelList;

FB_DEFINE_COMPONENT( FBSDK_DLL, Camera          );
FB_DEFINE_COMPONENT( FBSDK_DLL, Light           );
FB_DEFINE_COMPONENT( FBSDK_DLL, Model           );
FB_DEFINE_COMPONENT( FBSDK_DLL, Cluster         );
FB_DEFINE_COMPONENT( FBSDK_DLL, Geometry        );
FB_DEFINE_COMPONENT( FBSDK_DLL, Mesh            );
FB_DEFINE_COMPONENT( FBSDK_DLL, ModelVertexData );
FB_DEFINE_COMPONENT( FBSDK_DLL, Video           );
FB_DEFINE_COMPONENT( FBSDK_DLL, AnimationNode   );

FBSDK_DLL void FBModelTransactionBegin();

FBSDK_DLL void FBModelTransactionEnd();

// FBPropertyListModel
__FB_FORWARD( FBModel ); 
__FB_FORWARD( FBPropertyListModel );
FB_DEFINE_LIST( FBSDK_DLL, Model );

class FBSDK_DLL FBPropertyListModel : public FBPropertyListComponentBase
{
public:
    int  Add    ( HFBModel pItem );

    int  Remove ( HFBModel pItem );

    virtual void RemoveAt( int pIndex );

    FBModel* operator[](int pIndex);

    virtual int  GetCount();
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    inline virtual FBComponent* GetAt(int pIndex) { return (FBComponent*)operator[](pIndex); }
private:
    inline virtual int Add  ( FBComponent* pItem ) { return Add((FBModel*)pItem); }
    inline virtual int Remove   ( FBComponent* pItem ) { return Remove((FBModel*)pItem); }
#endif
};

// FBPropertyListMaterial
__FB_FORWARD( FBMaterial );

class FBSDK_DLL FBPropertyListMaterial : public FBPropertyListComponent
{
public:
    FBPropertyListMaterial();
    FBMaterial* operator[](int pIndex);
};

// FBPropertyListTexture
__FB_FORWARD( FBTexture );

class FBSDK_DLL FBPropertyListTexture : public FBPropertyListComponent
{
public:
    FBPropertyListTexture();
    virtual int Add( FBTexture* pItem );
    FBTexture* operator[](int pIndex);

private:
    inline virtual int Add  ( FBComponent* pItem ) { return Add((FBTexture*)pItem); }
};

// FBModel
__FB_FORWARD( FBModel       );

enum FBModelTransformationMatrix {   
    kModelTransformation           = 1<<0,                  
    kModelRotation                 = 1<<1,                  
    kModelTranslation              = 1<<2,                  
    kModelScaling                  = 1<<3,                  
    kModelInverse_Transformation   = 1<<4,                  
    kModelInverse_Rotation         = 1<<5,                  
    kModelInverse_Translation      = 1<<6,                  
    kModelInverse_Scaling          = 1<<7,                  
    kModelCenter                   = 1<<8,                  
    kModelAll                      = (kModelCenter<<1)-1    
};

enum FBModelShadingMode {   
    kFBModelShadingDefault,     
    kFBModelShadingWire,        
    kFBModelShadingFlat,        
    kFBModelShadingLight,       
    kFBModelShadingHard,        
    kFBModelShadingTexture,     
    kFBModelShadingAll,         
};

enum FBModelRenderPass {    
    kFBModelRenderPassStandard,     
    kFBModelRenderPassTransparency, 
    kFBModelRenderPassPick,         
};

enum FBModelRotationOrder { 
    kFBEulerXYZ = 0,    
    kFBEulerXZY,        
    kFBEulerYZX,        
    kFBEulerYXZ,        
    kFBEulerZXY,        
    kFBEulerZYX,        
    kFBSphericXYZ       
};

FB_DEFINE_ENUM( FBSDK_DLL, ModelShadingMode             ); 
FB_DEFINE_ENUM( FBSDK_DLL, ModelTransformationMatrix    );
FB_DEFINE_ENUM( FBSDK_DLL, ModelRotationOrder           ); 

class FBSDK_DLL FBModel : public FBBox 
{
    __FBClassDeclare( FBModel,FBBox );
public:
    FBModel(char *pName, HIObject pObject=NULL);
    virtual void    FBDelete();

    IQuery_Declare      (Implementation);           // Interface to IObject.
    ICallback_Declare   (Implementation);           // Interface to ICallback.

    FBPropertyListModel             Children;       

    FBPropertyListShader            Shaders;        
    FBPropertyListMaterial          Materials;      
    FBPropertyListTexture           Textures;       
    FBPropertyBool                  Icon3D;         
    FBPropertyBool                  SoftSelected;   
    FBPropertyBool                  IsDeformable;   
    FBPropertyBool                  IsConstrained;  
    FBPropertyModel                 Parent;         
    FBPropertyModel                 LookAt;         
    FBPropertyModel                 UpVector;       
    FBPropertyGeometry              Geometry;       
    FBPropertyMesh                  TessellatedMesh;
    FBPropertyModelVertexData       ModelVertexData;
    FBPropertyCluster               Cluster;        
    FBPropertyScene                 Scene;          
    FBPropertyModelShadingMode      ShadingMode;    
    FBPropertyAnimationNode         AnimationNode;  

    FBPropertyModelRotationOrder    RotationOrder;  

    // Limits
    FBPropertyBool                  RotationSpaceForLimitOnly; 
    FBPropertyBool                  RotationActive; 
    FBPropertyVector3d              PreRotation;    
    FBPropertyVector3d              PostRotation;   
    FBPropertyVector3d              RotationMin;    
    FBPropertyVector3d              RotationMax;    
    FBPropertyBool                  RotationMinX;   
    FBPropertyBool                  RotationMinY;   
    FBPropertyBool                  RotationMinZ;   
    FBPropertyBool                  RotationMaxX;   
    FBPropertyBool                  RotationMaxY;   
    FBPropertyBool                  RotationMaxZ;   

    // Animatable
    FBPropertyAnimatableDouble      Visibility;     
    FBPropertyAnimatableVector3d    Translation;    
    FBPropertyAnimatableVector3d    Rotation;       
    FBPropertyAnimatableVector3d    Scaling;        

    FBPropertyVector3d              GeometricTranslation;   
    FBPropertyVector3d              GeometricRotation;      
    FBPropertyVector3d              GeometricScaling;       

    FBPropertyBool                  QuaternionInterpolate;  

    FBPropertyBool                  Show;           
    FBPropertyBool                  Pickable;       

    virtual HFBModel Clone();

    void SetMatrix(FBMatrix pMatrix, int pWhat=kModelTransformation,    bool pGlobalInfo=true, bool pPushUndo = false, HFBEvaluateInfo pEvaluateInfo=NULL);

    void GetMatrix(FBMatrix &pMatrix, int pWhat=kModelTransformation,   bool pGlobalInfo=true, HFBEvaluateInfo pEvaluateInfo=NULL);

    void SetVector(FBVector3d pVector, int pWhat=kModelTranslation, bool pGlobalInfo=true, bool pPushUndo = false, HFBEvaluateInfo pEvaluateInfo=NULL);

    void GetVector(FBVector3d &pVector, int pWhat=kModelTranslation,    bool pGlobalInfo=true, HFBEvaluateInfo pEvaluateInfo=NULL);

    void GetBoundingBox( FBVector3d& pMin, FBVector3d& pMax );

    virtual bool HasCustomDisplay() { return false; }

    virtual void CustomModelDisplay( FBCamera* pCamera, FBModelShadingMode pShadingMode, FBModelRenderPass pRenderPass, float pPickingAreaWidth, float pPickingAreaHeight) {}

    virtual bool CustomModelPicking(    int pNbHits, unsigned int *pSelectBuffer, FBCamera* pCamera, 
                                        int pMouseX,int pMouseY,
                                        FBTVector* pLocalRaySrc, FBTVector* pLocalRayDir,
                                        FBTVector* pWorldRaySrc, FBTVector* pWorldRayDir,
                                        FBMatrix* pGlobalInverseMatrix,
                                        FBTVector* pOutPickedPoint) { return false; }

    unsigned char* GetSelectedPoints();

    int GetSelectedPointsCount();

    virtual bool FbxStore(HFBFbxObject pFbxObject, kFbxObjectStore pStoreWhat);
    virtual bool FbxRetrieve(HFBFbxObject pFbxObject, kFbxObjectStore pStoreWhat);

    void SetupPropertiesForShapes();

    virtual char*   FbxGetObjectType();

    virtual char*   FbxGetObjectSubType();

};

// FBModelNull
__FB_FORWARD( FBModelNull);

class FBSDK_DLL FBModelNull : public FBModel {
    __FBClassDeclare( FBModelNull,FBModel );
public:
    FBModelNull(char *pName, HIObject pObject=NULL);

    FBPropertyDouble    Size;   
};

// FBModelRoot
__FB_FORWARD( FBModelRoot);

class FBSDK_DLL FBModelRoot : public FBModel {
    __FBClassDeclare( FBModelRoot,FBModel );
public:
    FBModelRoot(char *pName, HIObject pObject=NULL);

    FBPropertyDouble    Size;   
};

// FBModelMarker
__FB_FORWARD( FBModelMarker);

enum FBMarkerResolutionLevel
{
    kFBMarkerLowResolution,     
    kFBMarkerMediumResolution,  
    kFBMarkerHighResolution     
};

enum FBMarkerLook
{
    kFBMarkerLookCube,          
    kFBMarkerLookHardCross,     
    kFBMarkerLookLightCross,    
    kFBMarkerLookSphere,        
    kFBMarkerLookCapsule        
};

enum FBMarkerType
{
    kFBMarkerTypeStandard,      
    kFBMarkerTypeOptical,       
    kFBMarkerTypeFKEffector,    
    kFBMarkerTypeIKEffector     
};

FB_DEFINE_ENUM( FBSDK_DLL, MarkerResolutionLevel );
FB_DEFINE_ENUM( FBSDK_DLL, MarkerLook );
FB_DEFINE_ENUM( FBSDK_DLL, MarkerType );

class FBSDK_DLL FBModelMarker : public FBModel {
    __FBClassDeclare( FBModelMarker,FBModel );
public:
    FBModelMarker(char *pName, HIObject pObject=NULL);

    FBPropertyDouble    Size;   
    FBPropertyDouble    Length; 
    FBPropertyMarkerResolutionLevel ResLevel; 
    FBPropertyMarkerLook Look;  
    FBPropertyMarkerType Type;  
    FBPropertyColor     Color;  
    FBPropertyVector3d  IKPivot;   
    FBPropertyBool      IKSync;    

    void SetFKOpacity(double pValue);
};


// FBModelSkeleton
__FB_FORWARD( FBModelSkeleton);

class FBSDK_DLL FBModelSkeleton : public FBModel {
    __FBClassDeclare( FBModelSkeleton,FBModel );
public:
    FBModelSkeleton(char *pName, HIObject pObject=NULL);

    FBPropertyDouble    Size;   
    FBPropertyColor     Color;  
};

// FBModelCube
__FB_FORWARD( FBModelCube );

class FBSDK_DLL FBModelCube : public FBModel {
    __FBClassDeclare( FBModelCube, FBModel );
public:
    FBModelCube(char *pName, HIObject pObject=NULL);
};

// FBModelPlane
__FB_FORWARD( FBModelPlane );

class FBSDK_DLL FBModelPlane : public FBModel {
    __FBClassDeclare( FBModelPlane, FBModel );
public:
    FBModelPlane(char *pName, HIObject pObject=NULL);
};

// FBModelPath3D
__FB_FORWARD( FBModelPath3D );

enum FBPathTangeantMode {
    kFBPathTangeantInvalid, 
    kFBPathTangeantLinear,  
    kFBPathTangeantCubic,   
    kFBPathTangeantAuto,    
    kFBPathTangeantUser     
};

FB_DEFINE_ENUM(FBSDK_DLL, PathTangeantMode);

class FBSDK_DLL FBModelPath3D : public FBModel
{
    __FBClassDeclare(FBModelPath3D, FBModel);

public:
    FBModelPath3D(char* pName, HIObject pObject=NULL);

    //--- Visual ------------------------------------------------------------------------------------------------------------------------
    void        ShowCurveControls(bool pShow);
    void        ShowCurvePoints(bool pShow);

    //--- Key Manipulation --------------------------------------------------------------------------------------------------------------
    int     PathKeyGetCount();
    FBVector4d  PathKeyGet(int pKeyIndex);
    void        PathKeySet(int pKeyIndex, FBVector4d pTLocal, bool pUpdate=true);

    void        PathSetKeyLeftRightTangeant(int pKeyIndex, FBVector4d pKeyTLocal, FBVector4d pLeftTangentTLocal, FBVector4d pRightTangentTLocal, bool pUpdate=true); 
    void        PathKeyRemove(int pKeyIndex);
    void        PathKeyClear();

    //--- Tangeant ----------------------------------------------------------------------------------------------------------------------
    void        PathKeySetLeftTangeant(int pKeyIndex, FBVector4d pTLocal, bool pUpdate=true);
    void        PathKeySetRightTangeant(int pKeyIndex, FBVector4d pTLocal, bool pUpdate=true);
    FBVector4d  PathKeyGetLeftTangeant(int pKeyIndex);
    FBVector4d  PathKeyGetRightTangeant(int pKeyIndex);
    void        PathKeySetXDerivative(int pKeyIndex, double pDerivative, bool pUpdate);
    void        PathKeySetYDerivative(int pKeyIndex, double pDerivative, bool pUpdate);
    void        PathKeySetZDerivative(int pKeyIndex, double pDerivative, bool pUpdate);
    void        PathKeySetXYZDerivative(int pKeyIndex, FBVector4d pDerivative, bool pUpdate);
    FBVector4d  PathKeyGetXYZDerivative(int pKeyIndex);
    double      PatKeyGetLeftTangeantLength(int pKeyIndex);
    double      PatKeyGetRightTangeantLength(int pKeyIndex);

    //--- Path remove keys (editing) ----------------------------------------------------------------------------------------------------
    int     GetSelectedPathKeyCount();
    void        PathKeyRemoveSelected();

    //--- Keys Helpers ------------------------------------------------------------------------------------------------------------------
    int     InsertNewStartKey();
    int     InsertNewEndKey();
    int     PathKeyStartAdd(FBVector4d pTLocal);
    int     PathKeyEndAdd(FBVector4d pTLocal);

    //--- Curve -------------------------------------------------------------------------------------------------------------------------
    int     Total_PathKeyAdd(double pTotalPercent, FBVector4d pTLocal);
    int     Total_IsPathKey(double pTotalPercent);
    FBVector4d  Total_GlobalPathEvaluate(double pTotalPercent);
    FBVector4d  Total_LocalPathEvaluate(double pTotalPercent);
    FBVector4d  Total_GlobalPathEvaluateDerivative(double pTotalPercent);
    FBVector4d  Total_LocalPathEvaluateDerivative(double pTotalPercent);
    int     Segment_PathKeyAdd(double pSegmentPercent, FBVector4d pTLocal);
    int     Segment_IsPathKey(double pSegmentPercent);
    FBVector4d  Segment_GlobalPathEvaluate(double pSegmentPercent);
    FBVector4d  Segment_LocalPathEvaluate(double pSegmentPercent);
    FBVector4d  Segment_GlobalPathEvaluateDerivative(double pSegmentPercent);
    FBVector4d  Segment_LocalPathEvaluateDerivative(double pSegmentPercent);

    //--- Key Type Converter ------------------------------------------------------------------------------------------------------------
    double      ConvertTotalPercentToSegmentPercent(double pPercent);
    double      ConvertSegmentPercentToTotalPercent(double pPercent);
    double      ConvertToSegmentPercentFactor();
    double      ConvertToTotalPercentFactor();

    //--- Tangeant ----------------------------------------------------------------------------------------------------------------------
    bool                SetRightTangeantMode(int pKeyIndex, FBPathTangeantMode pTangeantMode);
    bool                SetLeftTangeantMode(int pKeyIndex, FBPathTangeantMode pTangeantMode);
    FBPathTangeantMode  GetRightTangeantMode(int pKeyIndex);
    FBPathTangeantMode  GetLeftTangeantMode(int pKeyIndex);

    void    UpdateGeometry();
};


// FBTexture
__FB_FORWARD( FBTexture );

enum FBTextureUseType   {
    kFBTextureUseColor              = 1,        
    kFBTextureUseShadowMap          = 2,        
    kFBTextureUseLightMap           = 3,        
    kFBTextureUseSphericalReflexionMap  = 4,    
    kFBTextureUseSphereReflexionMap     = 5,    
    kFBTextureUseBumpNormalMap          = 6 
};

enum FBTextureMapping   {
    kFBTextureMappingUV             = 1,        
    kFBTextureMappingXY             = 2,        
    kFBTextureMappingYZ             = 3,        
    kFBTextureMappingXZ             = 4,        
    kFBTextureMappingSpherical      = 5,        
    kFBTextureMappingCylindrical    = 6,        
    kFBTextureMappingEnvironment    = 7,        
    kFBTextureMappingProjection     = 8         
};

enum FBTextureBlendMode { 
    kFBTextureBlendTranslucent,             
    kFBTextureBlendAdditive,                
    kFBTextureBlendModulate,                
    kFBTextureBlendModulate2,               
};

FB_DEFINE_ENUM( FBSDK_DLL, TextureUseType   );
FB_DEFINE_ENUM( FBSDK_DLL, TextureMapping   );
FB_DEFINE_ENUM( FBSDK_DLL, TextureBlendMode );

// This class is used to encapsulate an underlying media that is used to texture a model.
//
class FBSDK_DLL FBTexture : public FBBox {
    __FBClassDeclare( FBTexture,FBBox );
public:
    FBTexture(char *pName, HIObject pObject=NULL);
    virtual void FBDelete();

    FBTexture* Clone();

    FBPropertyString            Filename;       
    FBPropertyInt               Width;          
    FBPropertyInt               Height;         

    FBPropertyTextureUseType    UseType;        
    FBPropertyTextureMapping    Mapping;        
    FBPropertyTextureBlendMode  BlendMode;      

    FBPropertyAnimatableVector3d    Translation;    
    FBPropertyAnimatableVector3d    Rotation;       
    FBPropertyAnimatableVector3d    Scaling;        
    FBPropertyAnimatableDouble      Alpha;          

    FBPropertyBool              SwapUV;         
    FBPropertyInt               CroppingX[2];   
    FBPropertyInt               CroppingY[2];   

    FBPropertyVideo             Video;          

    void    OGLInit(HFBRenderOptions pRenderOptions = NULL);
    unsigned int GetTextureObject();
    double* GetMatrix();
};

// FBLayeredTexture
__FB_FORWARD( FBLayeredTexture );

// This class is used to encapsulate list of textures.
//
class FBSDK_DLL FBLayeredTexture : public FBTexture {
    __FBClassDeclare( FBLayeredTexture,FBTexture );
public:
    FBLayeredTexture(char *pName, HIObject pObject=NULL);
    virtual void FBDelete();

    FBLayeredTexture* Clone();

    FBPropertyListTexture   Layers;     
};

// FBMaterial
enum FBMaterialTextureType {        
    kFBMaterialTextureEmissive,
    kFBMaterialTextureEmissiveFactor,
    kFBMaterialTextureAmbient,
    kFBMaterialTextureAmbientFactor,
    kFBMaterialTextureDiffuse,
    kFBMaterialTextureDiffuseFactor,
    kFBMaterialTextureSpecular,
    kFBMaterialTextureSpecularFactor,
    kFBMaterialTextureShiness,
    kFBMaterialTextureBump,
    kFBMaterialTextureNormalMap,
    kFBMaterialTextureTransparent,
    kFBMaterialTextureTransparentFactor,
    kFBMaterialTextureReflection,
    kFBMaterialTextureReflectionFactor,
    kFBMaterialTextureDisplacementColor
};

//FB_DEFINE_ENUM( FBSDK_DLL, MaterialTextureType    ); 

class FBSDK_DLL FBMaterial : public FBBox {
    __FBClassDeclare( FBMaterial,FBBox );
public:
    FBMaterial(char *pName, HIObject pObject=NULL);

    FBMaterial* Clone();

    FBPropertyAnimatableColor   Ambient;            
    FBPropertyAnimatableDouble  AmbientFactor;      
    
    FBPropertyAnimatableColor   Emissive;           
    FBPropertyAnimatableDouble  EmissiveFactor;     
    
    FBPropertyAnimatableColor   Diffuse;            
    FBPropertyAnimatableDouble  DiffuseFactor;      
    
    FBPropertyAnimatableColor   TransparentColor;   
    FBPropertyAnimatableDouble  TransparencyFactor; 
    
    FBPropertyAnimatableColor   Bump;               
    FBPropertyAnimatableColor   NormalMap;          
    FBPropertyAnimatableDouble  BumpFactor;         

    FBPropertyAnimatableColor   Specular;           
    FBPropertyAnimatableDouble  SpecularFactor;     
    FBPropertyAnimatableDouble  Shininess;          
    
    FBPropertyAnimatableColor   Reflection;         
    FBPropertyAnimatableDouble  ReflectionFactor;   

    FBPropertyAnimatableColor   DisplacementColor;  
    FBPropertyAnimatableDouble  DisplacementFactor; 

    HFBTexture GetTexture(FBMaterialTextureType = kFBMaterialTextureDiffuse);

    void SetTexture(FBTexture* pTexture, FBMaterialTextureType pType = kFBMaterialTextureDiffuse);

    void OGLInit();
};

// FBCluster
enum FBClusterMode  {
    kFBClusterNormalize,        
    kFBClusterAdditive,         
    kFBClusterTotal100          
};
FB_DEFINE_ENUM( FBSDK_DLL, ClusterMode );

__FB_FORWARD( FBCluster );

class FBSDK_DLL FBCluster : public FBComponent {
    __FBClassDeclare( FBCluster,FBComponent );

protected:
    FBCluster(HFBModel pModel);
    friend class DataFBModel;

public:

    //--- Cluster-level operations
    int ClusterBegin(int pIndex = -1);

    int ClusterEnd(bool pQueryOnly = false);

    //--- Link-level operations
    void        LinkSetName(char *pName, int pLinkNumber);
    char*       LinkGetName(int pLinkNumber);
    void        LinkRemove(int pLinkNumber);
    int         LinkGetCount();
    void        LinkSetModel(HFBModel pModel);
    HFBModel    LinkGetModel(int pLinkNumber);
    HFBModel    LinkGetAssociateModel(int pLinkNumber);
    void        LinkClearUnused( double pThreshold = -1.0 );
    void        LinkSetCurrentVertex(int pLinkIndex,int pPointIndex);
    int         LinkGetVertexIndex(int pIndex);

    //--- Vertex level operations.
    void        VertexSetTransform(FBVector3d pPosition,FBVector3d pRotation, FBVector3d pScaling);
    void        VertexGetTransform(FBVector3d& pPosition,FBVector3d& pRotation, FBVector3d& pScaling);
    void        VertexAdd(int pVertexIndex,double pWeight);
    void        VertexRemove(int pVertexIndex);
    int         VertexGetCount();
    int         VertexGetNumber(int pIndex);
    double      VertexGetWeight(int pIndex);
    void        VertexSetWeight(double pWeight,int pIndex);
    void        VertexClear();

    FBPropertyClusterMode   ClusterMode;        
    FBPropertyDouble        ClusterAccuracy;    
};

// FBCamera
__FB_FORWARD( FBCamera );

enum FBCameraFrameSizeMode { 
    kFBFrameSizeWindow,                 
    kFBFrameSizeFixedRatio,             
    kFBFrameSizeFixedResolution,        
    kFBFrameSizeFixedWidthResolution,   
    kFBFrameSizeFixedHeightResolution   
};

enum FBCameraResolutionMode { 
    kFBResolutionCustom,                
    kFBResolutionD1NTSC,                
    kFBResolutionNTSC,                  
    kFBResolutionPAL,                   
    kFBResolutionD1PAL,                 
    kFBResolutionHD,                    
    kFBResolution640x480,               
    kFBResolution320x200,               
    kFBResolution320x240,               
    kFBResolution128x128,               
    kFBResolutionFullScreen             
};

enum FBCameraApertureMode { 
    kFBApertureVertical,                
    kFBApertureHorizontal,              
    kFBApertureVertHoriz,               
    kFBApertureFocalLength              
};

enum FBCameraFilmBackType { 
    kFBFilmBackCustom,                  
    kFBFilmBack16mmTheatrical,          
    kFBFilmBackSuper16mm,               
    kFBFilmBack35mmAcademy,             
    kFBFilmBack35mmTVProjection,        
    kFBFilmBack35mmFullAperture,        
    kFBFilmBack35mm185Projection,       
    kFBFilmBack35mmAnamorphic,          
    kFBFilmBack70mmProjection,          
    kFBFilmBackVistaVision,             
    kFBFilmBackDynavision,              
    kFBFilmBackIMAX                     
};

enum FBCameraViewPlaneMode { 
    kFBViewPlaneDisabled,               
    kFBViewPlaneAlways,                 
    kFBViewPlaneWhenMedia               
};

enum FBCameraDistanceMode { 
    kFBDistModeRelativeToInterest,      
    kFBDistModeAbsoluteFromCamera       
};

enum FBCameraSafeAreaMode { 
    kFBSafeAreaSquare,                  
    kFBSafeAreaRound                    
};

enum FBCameraAntiAliasingMethod { 
    kFBAntiAliasingSoftware,            
    kFBAntialiasingMultiSamplingOnyx    
};

enum FBCameraSamplingType { 
    kFBSamplingUniform,                 
    kFBSamplingStochastic               
};

enum FBCameraFocusDistanceSource { 
    kFBFocusDistanceCameraInterest,     
    kFBFocusDistanceSpecificDistance    
};


enum FBCameraType { 
    kFBCameraTypePerspective,           
    kFBCameraTypeOrthogonal             
};


enum FBCameraMatrixType { 
    kFBProjection,                      
    kFBModelView                        
};


FB_DEFINE_ENUM( FBSDK_DLL, CameraType                   ); 
FB_DEFINE_ENUM( FBSDK_DLL, CameraApertureMode           ); 
FB_DEFINE_ENUM( FBSDK_DLL, CameraFilmBackType           ); 
FB_DEFINE_ENUM( FBSDK_DLL, CameraFrameSizeMode          ); 
FB_DEFINE_ENUM( FBSDK_DLL, CameraResolutionMode         ); 
FB_DEFINE_ENUM( FBSDK_DLL, CameraViewPlaneMode          ); 
FB_DEFINE_ENUM( FBSDK_DLL, CameraDistanceMode           ); 
FB_DEFINE_ENUM( FBSDK_DLL, CameraSafeAreaMode           ); 
FB_DEFINE_ENUM( FBSDK_DLL, CameraAntiAliasingMethod     ); 
FB_DEFINE_ENUM( FBSDK_DLL, CameraSamplingType           );
FB_DEFINE_ENUM( FBSDK_DLL, CameraFocusDistanceSource    ); 
FB_DEFINE_ENUM( FBSDK_DLL, CameraMatrixType             ); 

class FBSDK_DLL FBCamera : public FBModel {
    __FBClassDeclare( FBCamera,FBModel );
public:
    FBCamera(char * pName, HIObject pObject=NULL);

    FBPropertyBool                      SystemCamera;           

    // Camera Format
    FBPropertyCameraFrameSizeMode       FrameSizeMode;          
    FBPropertyCameraResolutionMode      ResolutionMode;         
    FBPropertyDouble                    ResolutionWidth;        
    FBPropertyDouble                    ResolutionHeight;       
    FBPropertyDouble                    WindowHeight;           
    FBPropertyDouble                    PixelAspectRatio;       
    FBPropertyDouble                    NearPlaneDistance;      
    FBPropertyDouble                    FarPlaneDistance;       
    FBPropertyBool                      MouseLockCamera;        
    FBPropertyCameraType                Type;                   
    FBPropertyCameraApertureMode        ApertureMode;           
    FBPropertyAnimatableDouble          FieldOfView;            

    FBPropertyAnimatableDouble          FieldOfViewX;           
    FBPropertyAnimatableDouble          FieldOfViewY;           
    FBPropertyAnimatableDouble          OpticalCenterX;         
    FBPropertyAnimatableDouble          OpticalCenterY;         
    FBPropertyAnimatableDouble          FocalLength;            

    FBPropertyCameraFilmBackType        FilmBackType;           
    FBPropertyDouble                    FilmSizeWidth;          
    FBPropertyDouble                    FilmSizeHeight;         
    FBPropertyDouble                    FilmAspectRatio;        
    FBPropertyDouble                    SqueezeRatio;           
    FBPropertyDouble                    OrthogonalVerticalSize; 

    // Camera Background options
    FBPropertyVideo                     BackGroundMedia;                
    FBPropertyCameraViewPlaneMode       ViewBackGroundPlaneMode;        
    FBPropertyBool                      BackGroundImageCenter;          
    FBPropertyBool                      BackGroundImageFit;             
    FBPropertyBool                      BackGroundImageKeepRatio;       
    FBPropertyBool                      BackGroundImageCrop;            
    FBPropertyDouble                    BackGroundPlaneDistance;        
    FBPropertyCameraDistanceMode        BackGroundPlaneDistanceMode;    

    // Camera Foreground options
    FBPropertyAnimatableDouble          ForeGroundAlpha;                
    FBPropertyDouble                    ForeGroundMaterialThreshold;    
    FBPropertyBool                      ForeGroundTransparent;          
    FBPropertyVideo                     ForeGroundMedia;                
    FBPropertyCameraViewPlaneMode       ViewForeGroundPlaneMode;        
    FBPropertyBool                      ForeGroundImageCenter;          
    FBPropertyBool                      ForeGroundImageFit;             
    FBPropertyBool                      ForeGroundImageKeepRatio;       
    FBPropertyBool                      ForeGroundImageCrop;            
    FBPropertyDouble                    ForeGroundPlaneDistance;        
    FBPropertyCameraDistanceMode        ForeGroundPlaneDistanceMode;    

    // Camera View Options
    FBPropertyBool                      ViewCameraInterest;     
    FBPropertyBool                      ViewNearFarPlane;       
    FBPropertyBool                      ViewShowGrid;           
    FBPropertyBool                      ViewShowAxis;           
    FBPropertyBool                      ViewShowTimeCode;       
    FBPropertyBool                      ViewDisplaySafeArea;    
    FBPropertyBool                      ViewOpticalCenter;      
    FBPropertyCameraSafeAreaMode        SafeAreaMode;           

    FBPropertyAnimatableColor           BackGroundColor;        
    FBPropertyBool                      UseFrameColor;          
    FBPropertyColor                     FrameColor;             

    // Camera Render Options
        // Rendering Options
    FBPropertyBool                      UseAntiAliasing;        
    FBPropertyBool                      UseDepthOfField;        
    FBPropertyBool                      InteractiveMode;        

        // Antialiasing Options
    FBPropertyDouble                    AntiAliasingIntensity;  
    FBPropertyCameraAntiAliasingMethod  AntiAliasingMethod;     
    FBPropertyInt                       NumberOfSamples;        
    FBPropertyCameraSamplingType        SamplingType;           
    FBPropertyBool                      UseAccumulationBuffer;  
    
        // Depth of Field Options
    FBPropertyCameraFocusDistanceSource FocusDistanceSource;    
    FBPropertyDouble                    FocusSpecificDistance;  
    FBPropertyDouble                    FocusAngle;             

        // 2D Magnifier
    FBPropertyBool                      Use2DMagnifier;         
    FBPropertyBool                      Display2DMagnifierFrame;
    FBPropertyAnimatableDouble          MagnifierZoom;          
    FBPropertyAnimatableDouble          MagnifierPosX;          
    FBPropertyAnimatableDouble          MagnifierPosY;          

    // Other Attributes
    FBPropertyModel                     Interest;               
    FBPropertyAnimatableDouble          Roll;                   
    FBPropertyAnimatableDouble          TurnTable;              
    FBPropertyBool                      DisplayTurnTableIcon;   

    double* GetMatrix( FBCameraMatrixType pType );
};

// FBPropertyListCamera
class FBSDK_DLL FBPropertyListCamera : public FBPropertyListComponent
{
public:
    FBPropertyListCamera();
    FBCamera* operator[](int pIndex);
};

// FBCameraSwitcher
__FB_FORWARD( FBCameraSwitcher );

class FBSDK_DLL FBCameraSwitcher : public FBModel
{
    __FBClassDeclare( FBCameraSwitcher, FBBox );
public:
    FBCameraSwitcher();

    FBPropertyCamera    CurrentCamera;      
    FBPropertyInt       CurrentCameraIndex; 
};


// FBGlobalLight
__FB_FORWARD( FBGlobalLight );

enum FBFogMode  { 
    kFBFogModeLinear,               
    kFBFogModeExponential,          
    kFBFogModeSquareExponential     
};

FB_DEFINE_ENUM( FBSDK_DLL, FogMode );

class FBSDK_DLL FBGlobalLight : public FBBox
{
    __FBClassDeclare( FBGlobalLight, FBBox );
public:
    FBGlobalLight();

    FBPropertyAnimatableColor   AmbientColor;       

    // Fog
    FBPropertyBool              FogEnable;          

    FBPropertyAnimatableColor   FogColor;           
    FBPropertyAnimatableDouble  FogBegin;           
    FBPropertyAnimatableDouble  FogEnd;             
    FBPropertyAnimatableDouble  FogDensity;         

    FBPropertyFogMode           FogMode;            
};

// FBLight
__FB_FORWARD( FBLight );

enum FBLightType    { 
    kFBLightTypePoint,      
    kFBLightTypeInfinite,   
    kFBLightTypeSpot        
};

FB_DEFINE_ENUM( FBSDK_DLL, LightType    );


enum FBAttenuationType  { 
    kFBAttenuationNone = 0,         
    kFBAttenuationLinear,       
    kFBAttenuationQuadratic,    
    kFBAttenuationCubic         
};

FB_DEFINE_ENUM( FBSDK_DLL, AttenuationType  );

class FBSDK_DLL FBLight : public FBModel 
{
    __FBClassDeclare( FBLight,FBModel );
public:
    FBLight(char *pName, HIObject pObject=NULL);

    // Light parameters
    FBPropertyLightType         LightType;                  
    FBPropertyAttenuationType   AttenuationType;            
    FBPropertyAnimatableDouble  Intensity;                  
    FBPropertyAnimatableDouble  ConeAngle;                  
    FBPropertyAnimatableDouble  FogIntensity;               
    FBPropertyAnimatableColor   DiffuseColor;               
    FBPropertyBool              CastLightOnObject;          

    // Effects and Gobos
    FBPropertyBool              DrawGroundProjection;       
    FBPropertyBool              DrawVolumetricLight;        
    FBPropertyBool              DrawFrontFacingVolumetric;  
    FBPropertyVideo             GoboMedia;                  
};

// FBPropertyListLight
class FBSDK_DLL FBPropertyListLight : public FBPropertyListComponent
{
public:
    FBPropertyListLight();
    FBLight* operator[](int pIndex);
};

// FBModelVertexData
__FB_FORWARD( FBModelVertexData );

enum FBGeometryPrimitiveType
{
    kFBGeometry_POINTS          = 0x0000, //GL_POINTS,
    kFBGeometry_LINES           = 0x0001, //GL_LINES,
    kFBGeometry_LINE_LOOP       = 0x0002, //GL_LINE_LOOP,
    kFBGeometry_LINE_STRIP      = 0x0003, //GL_LINE_STRIP,
    kFBGeometry_TRIANGLES       = 0x0004, //GL_TRIANGLES,
    kFBGeometry_TRIANGLE_STRIP  = 0x0005, //GL_TRIANGLE_STRIP,
    kFBGeometry_TRIANGLE_FAN    = 0x0006, //GL_TRIANGLE_FAN,
    kFBGeometry_QUADS           = 0x0007, //GL_QUADS,
    kFBGeometry_QUADS_STRIP     = 0x0008, //GL_QUAD_STRIP,
    kFBGeometry_POLYGON         = 0x0009, //GL_POLYGON,
};

enum FBGeometryArrayID { 
    kFBGeometryArrayID_Point,                         
    kFBGeometryArrayID_NormalByPoint,                 
    kFBGeometryArrayID_Tangent,                       
    kFBGeometryArrayID_Binormal,                      
};

enum FBGeometryArrayElementType {
    kFBGeometryArrayElementType_Unknown,
    kFBGeometryArrayElementType_Integer, 
    kFBGeometryArrayElementType_Float,
    kFBGeometryArrayElementType_Float2,
    kFBGeometryArrayElementType_Float3,     
    kFBGeometryArrayElementType_Float4,      
    kFBGeometryArrayElementType_FloatMatrix4x4,
    kFBGeometryArrayElementType_IntegerArrayPointer
};

class FBSDK_DLL FBModelVertexData : public FBComponent {
    __FBClassDeclare( FBModelVertexData,FBComponent );

protected:
    FBModelVertexData(HFBModel pModel);
    friend class DataFBModel;

public:

    bool IsDeformable();        

    bool IsDrawable();

    int GetVertexCount();


    int GetSubPatchCount();
    
    int GetSubPatchMaterialId(int pSubPatchIndex);

    FBMaterial* GetSubPatchMaterial(int pSubPatchIndex);

    FBGeometryPrimitiveType GetSubPatchPrimitiveType(int pSubPatchIndex);

    int GetSubPatchIndexOffset(int pSubPatchIndex);

    int GetSubPatchIndexSize(int pSubPatchIndex);

    void DrawSubPatch(int pSubPatchIndex, bool pWireFrame = false);



    int GetSubRegionCount();

    FBMaterial* GetSubRegionMaterial(int pSubRegionIndex);

    void DrawSubRegion(int pSubRegionIndex, bool pWireFrame = false);


    void EnableOGLVertexData(bool pAfterdeform = true);

    void DisableOGLVertexData();

    void VertexArrayMappingRequest();

    void VertexArrayMappingRelease();

    int* GetIndexArray();

    unsigned int GetIndexArrayVBOId();

    FBGeometryArrayElementType GetVertexArrayType(FBGeometryArrayID pArrayId, bool pAfterDeform = true);

    void* GetVertexArray(FBGeometryArrayID pArrayId, bool pAfterDeform = true);

    unsigned int GetVertexArrayVBOId(FBGeometryArrayID pArrayId, bool pAfterDeform = true);

    void* GetVertexArrayVBOOffset(FBGeometryArrayID pArrayId, bool pAfterDeform = true);


    void EnableOGLUVSet(FBTextureMapping pTextrueMapping = kFBTextureMappingUV, const char* pUVSet = NULL);

    void DisableOGLUVSet();

    FBGeometryArrayElementType GetUVSetArrayFormat(FBTextureMapping pTextrueMapping = kFBTextureMappingUV, const char* pUVSet = NULL);

    void* GetUVSetArray(FBTextureMapping pTextrueMapping = kFBTextureMappingUV, const char* pUVSet = NULL);

    unsigned int GetUVSetVBOId(FBTextureMapping pTextrueMapping = kFBTextureMappingUV, const char* pUVSet = NULL);

    void* GetUVSetVBOOffset(FBTextureMapping pTextrueMapping = kFBTextureMappingUV, const char* pUVSet = NULL);

};


// FBGeometry
__FB_FORWARD( FBGeometry );


enum FBGeometryMappingMode
{
    kFBGeometryMapping_NONE,
    kFBGeometryMapping_BY_CONTROL_POINT,
    kFBGeometryMapping_BY_POLYGON_VERTEX,
    kFBGeometryMapping_BY_POLYGON,
    kFBGeometryMapping_BY_EDGE,
    kFBGeometryMapping_ALL_SAME
} ;

enum FBGeometryReferenceMode
{
    kFBGeometryReference_DIRECT,
    kFBGeometryReference_INDEX,
    kFBGeometryReference_INDEX_TO_DIRECT    
};

FB_DEFINE_ENUM( FBSDK_DLL, GeometryMappingMode ); 
FB_DEFINE_ENUM( FBSDK_DLL, GeometryReferenceMode ); 

enum kFBGeometryUpdateFlags
{
    kFBGeometryUpdateNone               = 0,        
    kFBGeometryUpdateAll                = 1 << 0,   
    kFBGeometryUpdatePositionAndNormal  = 1 << 1,   
    kFBGeometryUpdateSkinWeight         = 1 << 2,   
    kFBGeometryUpdateInverseNormal      = 1 << 3,   
    kFBGeometryUpdateMappingMode        = 1 << 4,   
};

class FBSDK_DLL FBGeometry : public FBComponent {
    __FBClassDeclare( FBGeometry,FBComponent );

public:
    FBGeometry(char *pName, HIObject pObject=NULL);


    bool        GeometryBegin();
    bool        GeometryEnd();

    void        VertexInit  (int pSize, bool pResize, bool pInitUV = true);

    bool        VertexClear ();

    int         VertexAdd   (FBVertex pVertex);

    int         VertexAdd   (FBVertex pVertex, FBNormal pNormal);

    int         VertexAdd   (FBVertex pVertex, FBNormal pNormal, FBUV pUV);

    int         VertexAdd   (double px, double py, double pz);
    int         VertexAdd   (double px, double py, double pz, double nx, double ny, double nz);
    int         VertexAdd   (double px, double py, double pz, double nx, double ny, double nz, double UVu, double UVv);

    bool        VertexSet   (FBVertex pVertex,int pIndex=-1);

    bool        VertexSet   (double px, double py, double pz,int pIndex=-1);

    bool        VertexNormalSet(FBNormal pVertex,int pIndex=-1);

    bool        VertexNormalSet(double px, double py, double pz,int pIndex=-1);


    bool        VertexUVSet(FBUV pUV, int pIndex=-1);

    bool        VertexUVSet(float pU, float pV, int pIndex=-1);



    int         VertexCount () const;

    FBVertex    VertexGet   (int pIndex) const;

    FBVertex*   GetVertexes() const;

    FBNormal    VertexNormalGet(int pIndex=-1) const;

    FBUV        VertexUVGet(int pIndex=-1) const;




    FBPropertyGeometryMappingMode   NormalMappingMode;      
    FBPropertyGeometryReferenceMode NormalReferenceMode;    

    int*        GetNormalsIndexArray(int& pOutArrayCount) const;

    FBNormal*   GetNormalsDirectArray(int& pOutArrayCount) const;

    FBStringList GetUVSets() const;

    FBGeometryMappingMode   GetUVSetMappingMode(const char* pUVSetName) const;

    FBGeometryReferenceMode GetUVSetReferenceMode(const char* pUVSetName) const;

    int*        GetVUVSetIndexArray(int& pOutArrayCount, const char* pUVSetName) const;
    
    FBUV*       GetUVSetDirectArray(int& pOutArrayCount, const char* pUVsetName = NULL) const;

    FBPropertyGeometryMappingMode   MaterialMappingMode;    

    int*        GetMaterialIndexArray(int& pOutArrayCount, const char* pUVSetName) const;




    bool VertexGetSelected(int pIndex);
    bool VertexSetSelected(int pIndex,bool pState);

    bool VertexGetVisible(int pIndex);
    bool VertexSetVisible(int pIndex,bool pState);

    bool VertexGetTransformable(int pIndex);


    int ShapeGetCount() const;

    const char* ShapeGetName(int pShapeIdx) const;

    int ShapeAdd(const char* pName);

    void ShapeClearAll();

    void ShapeInit(int pShapeIdx, int pDiffSize, bool pWithNormal = false);

    int ShapeGetDiffPointCount(int pShapeIdx) const;

    bool ShapeSetDiffPoint(int pShapeIdx, int pDiffIndex, int pOriIndex, const FBVertex& pPosDiff);
    bool ShapeSetDiffPoint(int pShapeIdx, int pDiffIndex, int pOriIndex, const FBVertex& pPosDiff, const FBNormal& pNormalDiff);

    bool ShapeGetDiffPoint(int pShapeIdx, int pDiffIndex, int& pOriIndex, FBVertex& pPosDiff) const;
    bool ShapeGetDiffPoint(int pShapeIdx, int pDiffIndex, int& pOriIndex, FBVertex& pPosDiff, FBNormal& pNormalDiff) const;




    void ModifyNotify( kFBGeometryUpdateFlags pFlags=kFBGeometryUpdateAll, int pFirstIndex=-1, int pLastIndex=-1 );

};

// FBMesh
__FB_FORWARD( FBMesh );

class FBSDK_DLL FBMesh : public FBGeometry {
    __FBClassDeclare( FBMesh,FBGeometry );

public:
    FBMesh(char *pName, HIObject pObject=NULL);


    int     PolygonBegin();

    bool    PolygonVertexAdd(int pVertex);

    int     PolygonMaterialIdGet(int pIndex=-1);

    int     PolygonEnd();

    int     PolygonVertexCount(int pPolygonIndex);

    int     PolygonVertexIndex(int pPolygonIndex, int pVertexPolygonIndex);

    int     PolygonCount();

    void ComputeVertexNormals(bool pCW = false);

    void InverseNormal();
};

// FBSurface
__FB_FORWARD( FBSurface );

enum FBSurfaceMode
{
    kFBSurfaceModeRaw,              
    kFBSurfaceModeLowNoNormals,     
    kFBSurfaceModeLow,              
    kFBSurfaceModeHighNoNormals,    
    kFBSurfaceModeHigh              
};
FB_DEFINE_ENUM( FBSDK_DLL, SurfaceMode );

enum FBSurfaceType
{
    kFBSurfaceTypeBezier,           
    kFBSurfaceTypeBezierQuadric,    
    kFBSurfaceTypeCardinal,         
    kFBSurfaceTypeBspline,          
    kFBSurfaceTypeLinear,           
};
FB_DEFINE_ENUM( FBSDK_DLL, SurfaceType );


class FBSDK_DLL FBSurface : public FBGeometry
{
    __FBClassDeclare( FBSurface, FBGeometry );

public:
    FBSurface(char* pName, HIObject pObject=NULL);

    IObject_Declare( Implementation );

    virtual void    SurfaceBegin();
    virtual void    SurfaceEnd();
    virtual void    SurfaceEditBegin();
    virtual void    SurfaceEditEnd();
    virtual bool    GetSurfaceCapped( int pUorV, int pDirection );
    virtual int     GetVertexCount( int pUorVorGlobal = -1 );
    virtual void    ControlPointsBegin() = 0;
    virtual void    SetControlPoint( int pIndex, double pX, double pY, double pZ, double pW );
    virtual void    GetControlPoint( int pIndex, double &pX, double &pY, double &pZ, double &pW );
    virtual void    ControlPointsEnd();

    bool VertexGetSelected(int pU,int pV);
    bool VertexSetSelected(int pU,int pV,bool pState);
        
    bool VertexGetVisible(int pU,int pV);

    bool VertexSetVisible(int pU,int pV,bool pState);
    
    bool VertexGetTransformable(int pU,int pV);


    FBPropertyInt           Size        [2];    
    FBPropertyInt           Step        [2];    
    FBPropertyBool          Closed      [2];    

    FBPropertySurfaceMode   SurfaceMode;        

private:
    void FBSurfaceInitProperties();
};

enum FBNurbType
{
    kFBNurbTypePeriodic,    
    kFBNurbTypeClosed,      
    kFBNurbTypeOpen,        
};
FB_DEFINE_ENUM( FBSDK_DLL, NurbType );


// FBNurbs
__FB_FORWARD( FBNurbs );

class FBSDK_DLL FBNurbs : public FBSurface
{
    __FBClassDeclare( FBNurbs, FBSurface );

public:
    FBNurbs(char *pName, HIObject pObject=NULL);

    virtual void    SurfaceBegin();

    virtual void    SurfaceEnd();

    virtual void    SurfaceEditBegin();
    virtual void    SurfaceEditEnd();
    virtual void    ControlPointsBegin();
    virtual void    ControlPointsEnd();
    virtual void    SetControlWeight( int pIndex, double pWeight );
    virtual double  GetControlWeight( int pIndex );
    virtual void    SetControlMultiplicity( int pUorV, int pIndex, int  pMultiplicity   );
    virtual int     GetControlMultiplicity( int pUorV, int pIndex );
    virtual void    SetControlKnotValue( int pUorV, int pIndex, double  pKnotValue      );
    virtual double  GetControlKnotValue( int pUorV, int pIndex );
    virtual int     GetKnotCount( int pUorV );

    FBPropertyInt           Order   [2];    
    FBPropertyNurbType      NurbType[2];    

private:
    void FBNurbsInitProperties();
};

// FBPatch
__FB_FORWARD( FBPatch );

class FBSDK_DLL FBPatch : public FBSurface
{
    __FBClassDeclare( FBPatch, FBSurface );

public:
    FBPatch(char *pName, HIObject pObject=NULL);

    
    virtual void SurfaceBegin();

    virtual void SurfaceEnd();

    virtual void SurfaceEditBegin();

    virtual void SurfaceEditEnd();

    virtual void ControlPointsBegin();
    virtual void ControlPointsEnd();


    FBPropertySurfaceType   SurfaceType[2]; 

private:
    void FBPatchInitProperties();

};

// FBDeformer
__FB_FORWARD( FBDeformer );

class FBSDK_DLL FBDeformer : public FBComponent {
    __FBClassDeclare( FBDeformer,FBComponent );
public:
    FBDeformer(char *pName, HIObject pObject=NULL);
};


#ifdef FBSDKUseNamespace
    }
#endif
#endif

---

Please send us your comments about this page.