FCDocument/FCDTexture.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_TEXTURE_H_
#define _FCD_TEXTURE_H_

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

class FCDocument;
class FCDEffectParameter;
class FCDEffectParameterInt;
class FCDEffectParameterList;
class FCDImage;

class FCOLLADA_EXPORT FCDTexture : public FCDEntity
{
private:
    DeclareObjectType;

    FUDaeTextureChannel::Channel textureChannel; // COLLADA 1.3 backward compatibility
    FCDImage* image;
    string subId;

    // Always preset, this parameter hold the map channel/uv set index
    FCDEffectParameterInt* set;

    // Texture color multiplier
    float multiplier; // Max-specific

    // Placement parameters. Yes, there's a ton of them [Maya-only]
    bool hasProjection3D;
    bool hasPlacement2D;
    FUDaeBlendMode::Mode blendMode;

    // 2D placement [Maya-only]
    float wrapU, wrapV, mirrorU, mirrorV, stagger, fast; // animated, but should really be booleans
    float coverageU, coverageV, translateFrameU, translateFrameV, rotateFrame;
    float repeatU, repeatV, offsetU, offsetV, rotateUV, noiseU, noiseV;

    // 3D projection [Maya-only]
    FMMatrix44 projectionMatrix;
    fstring projectionType;

public:
    FCDTexture(FCDocument* document);

    virtual ~FCDTexture();

    virtual Type GetType() const { return TEXTURE; }

    FUDaeTextureChannel::Channel GetTextureChannel() const { return textureChannel; }

    FCDImage* GetImage() { return image; }
    const FCDImage* GetImage() const { return image; } 
    void SetImage(FCDImage* _image) { image = _image; }

    FCDEffectParameterInt* GetSet() { return set; }
    const FCDEffectParameterInt* GetSet() const { return set; } 
    FUDaeBlendMode::Mode GetBlendMode() const { return blendMode; }

    void SetBlendMode(FUDaeBlendMode::Mode mode) { blendMode = mode; }

    const string& GetSubId() const { return subId; }

    void SetSubId(const string& _subId) { subId = _subId; }

    float& GetMultiplier() { return multiplier; }
    const float& GetMultiplier() const { return multiplier; } 
    void SetMultiplier(float _multiplier) { multiplier = _multiplier; }

    bool HasPlacement2D() const { return hasPlacement2D; }

    void ClearPlacement2D();

    float& GetWrapU() { return wrapU; }
    const float& GetWrapU() const { return wrapU; } 
    void SetWrapU(bool _wrapU) { wrapU = _wrapU ? 1.0f : 0.0f; hasPlacement2D = true; }

    float& GetWrapV() { return wrapV; }
    const float& GetWrapV() const { return wrapV; } 
    void SetWrapV(bool _wrapV) { wrapV = _wrapV ? 1.0f : 0.0f; hasPlacement2D = true; }

    float& GetMirrorU() { return mirrorU; }
    const float& GetMirrorU() const { return mirrorU; } 
    void SetMirrorU(bool _mirrorU) { mirrorU = _mirrorU ? 1.0f : 0.0f; hasPlacement2D = true; }

    float& GetMirrorV() { return mirrorV; }
    const float& GetMirrorV() const { return mirrorV; } 
    void SetMirrorV(bool _mirrorV) { mirrorV = _mirrorV ? 1.0f : 0.0f; hasPlacement2D = true; }

    float& GetStagger() { return stagger; }
    const float& GetStagger() const { return stagger; } 
    void SetStagger(bool _stagger) { stagger = _stagger ? 1.0f : 0.0f; hasPlacement2D = true; }

    float& GetFast() { return fast; }
    const float& GetFast() const { return fast; } 
    void SetFast(bool _fast) { fast = _fast ? 1.0f : 0.0f; hasPlacement2D = true; }

    float& GetCoverageU() { return coverageU; }
    const float& GetCoverageU() const { return coverageU; } 
    void SetCoverageU(float _coverageU) { coverageU = _coverageU; hasPlacement2D = true; }

    float& GetCoverageV() { return coverageV; }
    const float& GetCoverageV() const { return coverageV; } 
    void SetCoverageV(float _coverageV) { coverageV = _coverageV; hasPlacement2D = true; }

    float& GetTranslateFrameU() { return translateFrameU; }
    const float& GetTranslateFrameU() const { return translateFrameU; } 
    void SetTranslateFrameU(float _translateFrameU) { translateFrameU = _translateFrameU; hasPlacement2D = true; }

    float& GetTranslateFrameV() { return translateFrameV; }
    const float& GetTranslateFrameV() const { return translateFrameV; } 
    void SetTranslateFrameV(float _translateFrameV) { translateFrameV = _translateFrameV; hasPlacement2D = true; }

    float& GetRotateFrame() { return rotateFrame; }
    const float& GetRotateFrame() const { return rotateFrame; } 
    void SetRotateFrame(float _rotateFrame) { rotateFrame = _rotateFrame; hasPlacement2D = true; }

    float& GetRepeatU() { return repeatU; }
    const float& GetRepeatU() const { return repeatU; } 
    void SetRepeatU(float _repeatU) { repeatU = _repeatU; hasPlacement2D = true; }

    float& GetRepeatV() { return repeatV; }
    const float& GetRepeatV() const { return repeatV; } 
    void SetRepeatV(float _repeatV) { repeatV = _repeatV; hasPlacement2D = true; }

    float& GetOffsetU() { return offsetU; }
    const float& GetOffsetU() const { return offsetU; } 
    void SetOffsetU(float _offsetU) { offsetU = _offsetU; hasPlacement2D = true; }

    float& GetOffsetV() { return offsetV; }
    const float& GetOffsetV() const { return offsetV; } 
    void SetOffsetV(float _offsetV) { offsetV = _offsetV; hasPlacement2D = true; }

    float& GetRotateUV() { return rotateUV; }
    const float& GetRotateUV() const { return rotateUV; } 
    void SetRotateUV(float _rotateUV) { rotateUV = _rotateUV; hasPlacement2D = true; }

    float& GetNoiseU() { return noiseU; }
    const float& GetNoiseU() const { return noiseU; } 
    void SetNoiseU(float _noiseU) { noiseU = _noiseU; hasPlacement2D = true; }

    float& GetNoiseV() { return noiseV; }
    const float& GetNoiseV() const { return noiseV; } 
    void SetNoiseV(float _noiseV) { noiseV = _noiseV; hasPlacement2D = true; }

    bool HasProjection3D() const { return hasProjection3D; }

    void ClearProjection3D();

    FMMatrix44& GetProjectionMatrix() { return projectionMatrix; }
    const FMMatrix44& GetProjectionMatrix() const { return projectionMatrix; } 
    void SetProjectionMatrix(const FMMatrix44& matrix) { projectionMatrix = matrix; hasProjection3D = true; }
    
    const fstring& GetProjectionType() const { return projectionType; }

    void SetProjectionType(const fstring& type) { projectionType = type; hasProjection3D = true; } 

    FCDEffectParameter* FindParameterBySemantic(const string& semantic);

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

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

    FCDTexture* Clone();

    FUStatus LoadFromTextureXML(xmlNode* textureNode);

    virtual FUStatus LoadFromXML(xmlNode* textureNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode);

private:
    // Read in the Maya-specific texture placement parameters and look for a texture projection program
    FUStatus LoadPlacementXML(xmlNode* techniqueNode);
};

#endif // _FCD_TEXTURE_H_

---