FCDocument/FCDocument.h

Go to the documentation of this file.

/*
    Copyright (C) 2005-2006 Feeling Software Inc.
    MIT License: http://www.opensource.org/licenses/mit-license.php
*/
/*
    Based on the FS Import classes:
    Copyright (C) 2005-2006 Feeling Software Inc
    Copyright (C) 2005-2006 Autodesk Media Entertainment
    MIT License: http://www.opensource.org/licenses/mit-license.php
*/

#ifndef _FC_DOCUMENT_H_
#define _FC_DOCUMENT_H_

#include "FUtils/FUObject.h"

template <class T> class FCDLibrary;
template <class T> class FUUniqueStringMapT;

class FCDAnimation;
class FCDAnimationChannel;
class FCDAnimationClip;
class FCDAnimated;
class FCDAsset;
class FCDCamera;
class FCDController;
class FCDEffect;
class FCDGeometry;
class FCDImage;
class FCDLight;
class FCDMaterial;
class FCDMaterialLibrary;
class FCDObject;
class FCDPhysicsMaterial;
class FCDPhysicsModel;
class FCDPhysicsSceneNode;
class FCDTexture;
class FCDSceneNode;
class FUFileManager;

class FCOLLADA_EXPORT FCDLayer
{
public:
    string name; 
    StringList objects; 
};

typedef vector<FCDMaterial*> FCDMaterialList; 
typedef vector<FCDAnimated*> FCDAnimatedList; 
typedef vector<FCDAnimationChannel*> FCDAnimationChannelList;  
typedef map<const float*, FCDAnimated*> FCDAnimatedValueMap;  
typedef vector<FCDLayer*> FCDLayerList; 
typedef vector<FCDObject*> FCDObjectList; 
typedef FCDLibrary<FCDAnimation> FCDAnimationLibrary; 
typedef FCDLibrary<FCDAnimationClip> FCDAnimationClipLibrary; 
typedef FCDLibrary<FCDCamera> FCDCameraLibrary; 
typedef FCDLibrary<FCDController> FCDControllerLibrary; 
typedef FCDLibrary<FCDGeometry> FCDGeometryLibrary; 
typedef FCDLibrary<FCDImage> FCDImageLibrary; 
typedef FCDLibrary<FCDLight> FCDLightLibrary; 
typedef FCDLibrary<FCDSceneNode> FCDVisualSceneNodeLibrary; 
typedef FCDLibrary<FCDPhysicsModel> FCDPhysicsModelLibrary; 
typedef FCDLibrary<FCDPhysicsMaterial> FCDPhysicsMaterialLibrary; 
typedef FCDLibrary<FCDPhysicsSceneNode> FCDPhysicsSceneLibrary; 
typedef FUUniqueStringMapT<FUSStringBuilder> FUSUniqueStringMap; 
class FCOLLADA_EXPORT FCDocument : public FUObjectContainer
{
private:
    FUFileManager* fileManager;
    FCDSceneNode* visualSceneRoot;
    FCDPhysicsSceneNode* physicsSceneRoot;
    FUSUniqueStringMap* uniqueNameMap;

    // Document parameters
    FCDAsset* asset;
    float lengthUnitWanted, lengthUnitConversion;
    bool hasStartTime, hasEndTime;
    float startTime, endTime; // Maya-only
    FCDLayerList layers; // Maya-only

    // Parsed and merged libraries
    FCDAnimationLibrary* animationLibrary;
    FCDAnimationClipLibrary* animationClipLibrary;
    FCDCameraLibrary* cameraLibrary;
    FCDControllerLibrary* controllerLibrary;
    FCDGeometryLibrary* geometryLibrary;
    FCDImageLibrary* imageLibrary;
    FCDLightLibrary* lightLibrary;
    FCDMaterialLibrary* materialLibrary;
    FCDPhysicsModelLibrary* physicsModelLibrary;
    FCDPhysicsMaterialLibrary* physicsMaterialLibrary;
    FCDPhysicsSceneLibrary* physicsSceneLibrary;
    FCDVisualSceneNodeLibrary* visualSceneLibrary;

    // Animated values
    FCDAnimatedList animatedValues;
    FCDAnimatedValueMap animatedValueMap;

    StringList postCmds;

public:
    FCDocument();

    virtual ~FCDocument();

    FCDAsset* GetAsset() { return asset; }
    const FCDAsset* GetAsset() const { return asset; }  
    FUFileManager* GetFileManager() { return fileManager; }
    const FUFileManager* GetFileManager() const { return fileManager; } 
    FCDSceneNode* GetVisualSceneRoot() { return visualSceneRoot; }
    const FCDSceneNode* GetVisualSceneRoot() const { return visualSceneRoot; } 
    FCDPhysicsSceneNode* GetPhysicsSceneRoot() { return physicsSceneRoot; }
    const FCDPhysicsSceneNode* GetPhysicsSceneRoot() const { return physicsSceneRoot; } 
    const FCDMaterialList& GetMaterialList();

    FUSUniqueStringMap* GetUniqueNameMap() { return uniqueNameMap; }
    const FUSUniqueStringMap* GetUniqueNameMap() const { return uniqueNameMap; } 
    const FMVector3& GetUpAxis() const;

    float GetLengthUnit() const;

    float GetLengthUnitConversion() const { return lengthUnitConversion; }

    inline void SetLengthUnitWanted(float wantedLengthUnit) { lengthUnitWanted = wantedLengthUnit; }

    bool HasStartTime() const { return hasStartTime; }
    float GetStartTime() const { return startTime; }
    void SetStartTime(float time) { startTime = time; hasStartTime = true; }

    bool HasEndTime() const { return hasEndTime; }
    float GetEndTime() const { return endTime; }
    void SetEndTime(float time) { endTime = time; hasEndTime = true; }

    FCDLayerList& GetLayers() { return layers; }
    const FCDLayerList& GetLayers() const { return layers; } 
    size_t GetLayerCount() const { return layers.size(); }

    FCDLayer* GetLayer(size_t index) { FUAssert(index < GetLayerCount(), return NULL); return layers.at(index); }
    const FCDLayer* GetLayer(size_t index) const { FUAssert(index < GetLayerCount(), return NULL); return layers.at(index); }

    FCDLayer* AddLayer();

    void ReleaseLayer(FCDLayer* layer);

    FCDAnimationLibrary* GetAnimationLibrary() { return animationLibrary; }
    const FCDAnimationLibrary* GetAnimationLibrary() const { return animationLibrary; } 
    FCDAnimationClipLibrary* GetAnimationClipLibrary() { return animationClipLibrary; }
    const FCDAnimationClipLibrary* GetAnimationClipLibrary() const { return animationClipLibrary; } 
    FCDCameraLibrary* GetCameraLibrary() { return cameraLibrary; }
    const FCDCameraLibrary* GetCameraLibrary() const { return cameraLibrary; } 
    FCDControllerLibrary* GetControllerLibrary() { return controllerLibrary; }
    const FCDControllerLibrary* GetControllerLibrary() const { return controllerLibrary; } 
    FCDGeometryLibrary* GetGeometryLibrary() { return geometryLibrary; }
    const FCDGeometryLibrary* GetGeometryLibrary() const { return geometryLibrary; } 
    FCDImageLibrary* GetImageLibrary() { return imageLibrary; }
    const FCDImageLibrary* GetImageLibrary() const { return imageLibrary; } 
    FCDLightLibrary* GetLightLibrary() { return lightLibrary; }
    const FCDLightLibrary* GetLightLibrary() const { return lightLibrary; } 
    FCDMaterialLibrary* GetMaterialLibrary() { return materialLibrary; }
    const FCDMaterialLibrary* GetMaterialLibrary() const { return materialLibrary; } 
    FCDMaterialLibrary* GetEffectLibrary() { return materialLibrary; } 
    const FCDMaterialLibrary* GetEffectLibrary() const { return materialLibrary; } 
    FCDVisualSceneNodeLibrary* GetVisualSceneLibrary() { return visualSceneLibrary; }
    const FCDVisualSceneNodeLibrary* GetVisualSceneLibrary() const { return visualSceneLibrary; } 
    FCDPhysicsModelLibrary* GetPhysicsModelLibrary() { return physicsModelLibrary; }
    const FCDPhysicsModelLibrary* GetPhysicsModelLibrary() const { return physicsModelLibrary; } 
    FCDPhysicsMaterialLibrary* GetPhysicsMaterialLibrary() { return physicsMaterialLibrary; }
    const FCDPhysicsMaterialLibrary* GetPhysicsMaterialLibrary() const { return physicsMaterialLibrary; } 
    FCDPhysicsSceneLibrary* GetPhysicsSceneLibrary() { return physicsSceneLibrary;}
    const FCDPhysicsSceneLibrary* GetPhysicsSceneLibrary() const { return physicsSceneLibrary;} 
    FCDSceneNode* AddVisualScene();

    FCDPhysicsSceneNode* AddPhysicsScene();
    
    void FindAnimationChannels(const string& pointer, FCDAnimationChannelList& channels);

    void FindAnimationChannelsArrayIndices(xmlNode* targetArray, Int32List& animatedIndices);

    FCDAnimation* FindAnimation(const string& daeId);

    FCDAnimationClip* FindAnimationClip(const string& daeId);

    FCDCamera* FindCamera(const string& daeId);

    FCDController* FindController(const string& daeId);

    FCDEffect* FindEffect(const string& daeId);

    FCDGeometry* FindGeometry(const string& daeId);

    FCDImage* FindImage(const string& daeId);

    FCDLight* FindLight(const string& daeId);

    FCDMaterial* FindMaterial(const string& daeId);

    FCDTexture* FindTexture(const string& daeId);

    FCDSceneNode* FindVisualScene(const string& daeId);

    FCDPhysicsSceneNode* FindPhysicsScene(const string& daeId);

    FCDPhysicsMaterial* FindPhysicsMaterial(const string& daeId);

    FCDPhysicsModel* FindPhysicsModel(const string& daeId);

    FCDSceneNode* FindSceneNode(const string& daeId);

    void RegisterAnimatedValue(FCDAnimated* animated);

    void UnregisterAnimatedValue(FCDAnimated* animated);

    bool LinkDriver(FCDAnimated* animated);

    FCDAnimated* FindAnimatedValue(float* ptr);
    const FCDAnimated* FindAnimatedValue(const float* ptr) const; 
    const float* FindAnimatedTarget(const string& fullyQualifiedTarget);

    const FCDAnimated* FindNamedAnimated(const string& shader, const string& attribute) const;

    bool IsValueAnimated(const float* ptr) const;

    FUStatus LoadFromFile(const fstring& filename);

    FUStatus LoadFromText(const fstring& basePath, const fchar* text);

    FUStatus LoadDocumentFromXML(xmlNode* colladaNode);

    FUStatus WriteToFile(const fstring& filename) const;

    FUStatus WriteDocumentToXML(xmlNode* colladaNode) const;

    void WriteAnimatedValueToXML(const float* value, xmlNode* valueNode, const char* wantedSid, int32 arrayElement = -1) const;

    const StringList& GetPostProcessCmds() const { return postCmds; }
    
    const FCDAnimatedList& getAnimatedValues() { return animatedValues; }
};

#endif //_FC_DOCUMENT_H_

---