FCDocument/FCDEffectStandard.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 _FCD_MATERIAL_STANDARD_H_
#define _FCD_MATERIAL_STANDARD_H_

#include "FUtils/FUDaeEnum.h"
#include "FCDocument/FCDEffectProfile.h"

class FCDocument;
class FCDEffect;
class FCDEffectParameter;
class FCDTexture;
class FCDEffectParameterList;

typedef vector<FCDTexture*> FCDTextureList;

class FCOLLADA_EXPORT FCDEffectStandard : public FCDEffectProfile
{
public:
    enum LightingType
    {
        CONSTANT, 

        LAMBERT,

        PHONG,

        BLINN,

        UNKNOWN
    };

private:
    DeclareObjectType;
    LightingType type;
    FCDTextureList* textureBuckets;

    // Common material parameter: Emission
    FMVector3 emissionColor;
    float emissionFactor; // Max-specific
    
    // Common material parameter: Translucency
    FMVector3 translucencyColor;
    float translucencyFactor;

    // Lambert material parameters
    FMVector3 diffuseColor;
    FMVector3 ambientColor;

    // Phong material parameters: Specular
    FMVector3 specularColor;
    float specularFactor; // Max-specific
    float shininess;

    // Phong material parameter: Reflectivity
    FMVector3 reflectivityColor; // Maya-specific
    float reflectivityFactor; // Maya-specific

    // Geometry modifier
    bool isFaceted; // Max-specific
    bool isDoubleSided; // Max-specific for now
    bool isWireframe; // Max-specific
    bool isFaceMap; // Max-specific
    bool isEmissionFactor; // Max-specific

public:
    FCDEffectStandard(FCDocument* document, FCDEffect* parent);

    virtual ~FCDEffectStandard();

    inline LightingType GetLightingType() const { return type; }

    inline void SetLightingType(LightingType _type) { type = _type; }

    virtual FUDaeProfileType::Type GetType() const { return FUDaeProfileType::COMMON; }

    const FCDTextureList& GetTextureBucket(uint32 bucket) const;

    size_t GetTextureCount(uint32 bucket) const { FUAssert(bucket < FUDaeTextureChannel::COUNT, return 0); return textureBuckets[bucket].size(); }

    inline FCDTexture* GetTexture(uint32 bucket, size_t index) { FUAssert(index < GetTextureCount(bucket), return NULL); return textureBuckets[bucket].at(index); }
    inline const FCDTexture* GetTexture(uint32 bucket, size_t index) const { FUAssert(index < GetTextureCount(bucket), return NULL); return textureBuckets[bucket].at(index); } 
    FCDTexture* AddTexture(uint32 bucket);

    void ReleaseTexture(FCDTexture* texture);

    inline const FMVector3& GetTranslucencyColor() const { return translucencyColor; }

    inline void SetTranslucencyColor(const FMVector3& color) { translucencyColor = color; }

    inline const float& GetTranslucencyFactor() const { return translucencyFactor; }

    inline void SetTranslucencyFactor(float factor) { translucencyFactor = factor; }

    float GetOpacity() const;

    inline const FMVector3& GetEmissionColor() const { return emissionColor; }

    inline void SetEmissionColor(const FMVector3& color) { emissionColor = color; }

    inline const float& GetEmissionFactor() const { return emissionFactor; }

    inline void SetEmissionFactor(float factor) { emissionFactor = factor; }

    inline bool IsEmissionFactor() const { return isEmissionFactor; }

    inline void SetIsEmissionFactor(bool useFactor) { isEmissionFactor = useFactor; }

    inline const FMVector3& GetDiffuseColor() const { return diffuseColor; }

    inline void SetDiffuseColor(const FMVector3& color) { diffuseColor = color; }

    inline const FMVector3& GetAmbientColor() const { return ambientColor; }

    inline void SetAmbientColor(const FMVector3& color) { ambientColor = color; }

    inline const FMVector3& GetSpecularColor() const { return specularColor; }

    inline void SetSpecularColor(const FMVector3& color) { specularColor = color; }

    inline const float& GetSpecularFactor() const { return specularFactor; }

    inline void SetSpecularFactor(float factor) { specularFactor = factor; }

    inline const float& GetShininess() const { return shininess; }

    inline void SetShininess(float _shininess) { shininess = _shininess; }

    inline const FMVector3& GetReflectivityColor() const { return reflectivityColor; }

    inline void SetReflectivityColor(const FMVector3& color) { reflectivityColor = color; }
    
    inline const float& GetReflectivityFactor() const { return reflectivityFactor; }

    inline void SetReflectivityFactor(float factor) { reflectivityFactor = factor; }

    float GetReflectivity() const;

    inline bool GetFacetedFlag() const { return isFaceted; }

    inline void SetFacetedFlag(bool flag) { isFaceted = flag; }

    inline bool GetDoubleSidedFlag() const { return isDoubleSided; }

    inline bool SetDoubleSidedFlag(bool flag) { isDoubleSided = flag; }

    inline bool GetWireframeFlag() const { return isWireframe; }

    inline bool SetWireframeFlag(bool flag) { isWireframe = flag; }

    inline bool GetFaceMapFlag() const { return isFaceMap; }

    inline void SetFaceMapFlag(bool flag) { isFaceMap = flag; }

    virtual FCDEffectParameter* FindParameterBySemantic(const string& semantic);

    virtual void FindParametersBySemantic(const string& semantic, FCDEffectParameterList& parameters);

    virtual void FindParametersByReference(const string& reference, FCDEffectParameterList& parameters);

    virtual FCDEffectProfile* Clone(FCDEffect* newParent);

    virtual void Flatten() {}

    virtual FUStatus LoadFromXML(xmlNode* baseNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;

private:
    xmlNode* WriteColorTextureParameterToXML(xmlNode* parentNode, const char* parameterNodeName, const FMVector3& value, const FCDTextureList& textureBucket) const;
    xmlNode* WriteFloatTextureParameterToXML(xmlNode* parentNode, const char* parameterNodeName, const float& value, const FCDTextureList& textureBucket) const;
    xmlNode* WriteTextureParameterToXML(xmlNode* parentNode, const FCDTextureList& textureBucket) const;

    FUStatus ParseColorTextureParameter(xmlNode* parameterNode, FMVector3& value, FCDTextureList& textureBucket);
    FUStatus ParseFloatTextureParameter(xmlNode* parameterNode, float& value, FCDTextureList& textureBucket);
    FUStatus ParseSimpleTextureParameter(xmlNode* parameterNode, FCDTextureList& textureBucket);
};

#endif //_FCD_MATERIAL_STANDARD_H_

---