FCDocument/FCDEffectParameter.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
*/

#ifndef _FCD_EFFECT_PARAMETER_H_
#define _FCD_EFFECT_PARAMETER_H_

#include "FCDocument/FCDObject.h"

class FCDEffectPass;
class FCDocument;
class FCDEffectParameterSurface;

class FCOLLADA_EXPORT FCDEffectParameter : public FCDObject
{
public:
    enum Type
    {
        SAMPLER, 
        INTEGER, 
        BOOLEAN, 
        FLOAT, 
        FLOAT2, 
        FLOAT3, 
        VECTOR, 
        MATRIX, 
        STRING, 
        SURFACE 
    };

private:
    DeclareObjectType;
    bool isGenerator; // whether this effect parameter structure generates a new value or modifies an existing value (is <newparam>?)
    string reference;
    string semantic; // this is a Collada Semantic, not a Cg semantic
    
    // [glaforte] These two members should be somewhere else
    string bindSymbol; // this can be used in Cg to bind to the correct variable
    bool isFragment; // parameter bound to the fragment program or the vertex one

public:
    FCDEffectParameter(FCDocument* document);

    virtual ~FCDEffectParameter();

    virtual Type GetType() const = 0;

    const string& GetReference() const { return reference; } 

    const string& GetSemantic() const { return semantic; }

    void SetSemantic(const string& _semantic) { semantic = _semantic; } 

    bool IsGenerator() const { return isGenerator; }

    bool IsModifier() const { return !isGenerator; }

    const string& GetBindSymbol() const { return bindSymbol; }

    void SetBindSymbol(const string& _bindSymbol) { bindSymbol = _bindSymbol; }

    bool IsFragment() const { return isFragment; }

    void SetFragment(bool _isFragment) { isFragment = _isFragment;}

    virtual FCDEffectParameter* Clone() = 0;

    virtual void Overwrite(FCDEffectParameter* target);

    virtual FUStatus LoadFromXML(xmlNode* parameterNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;

protected:
    void Clone(FCDEffectParameter* clone);
};

class FCOLLADA_EXPORT FCDEffectParameterSampler : public FCDEffectParameter
{
public:
    enum SamplerType
    {
        SAMPLER1D, 
        SAMPLER2D, 
        SAMPLER3D, 
        SAMPLERCUBE 
    };

private:
    SamplerType samplerType;
    string surfaceSid;

public:
    FCDEffectParameterSampler(FCDocument* document);

    virtual ~FCDEffectParameterSampler();

    virtual Type GetType() const { return SAMPLER; }

    const char* GetSurfaceSid() const { return surfaceSid.c_str(); }

    void SetSurfaceSid(const char* sid) { surfaceSid = sid; }

    SamplerType GetSamplerType() const { return samplerType; }

    void SetSamplerType(SamplerType type) { samplerType = type; }

    virtual FCDEffectParameter* Clone();

    virtual void Overwrite(FCDEffectParameter* target);

    virtual FUStatus LoadFromXML(xmlNode* parameterNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;
};

class FCOLLADA_EXPORT FCDEffectParameterInt : public FCDEffectParameter
{
private:
    int value;

public:
    FCDEffectParameterInt(FCDocument* document);

    virtual ~FCDEffectParameterInt();

    virtual Type GetType() const { return INTEGER; }

    int GetValue() const { return value; }

    void SetValue(int _value) { value = _value; }

    virtual FCDEffectParameter* Clone();

    virtual void Overwrite(FCDEffectParameter* target);

    virtual FUStatus LoadFromXML(xmlNode* parameterNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;
};

class FCOLLADA_EXPORT FCDEffectParameterBool : public FCDEffectParameter
{
private:
    bool value;

public:
    FCDEffectParameterBool(FCDocument* document);

    virtual ~FCDEffectParameterBool();

    virtual Type GetType() const { return BOOLEAN; }

    bool GetValue() const { return value; }

    void SetValue(bool _value) { value = _value; }

    virtual FCDEffectParameter* Clone();

    virtual void Overwrite(FCDEffectParameter* target);

    virtual FUStatus LoadFromXML(xmlNode* parameterNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;
};

class FCOLLADA_EXPORT FCDEffectParameterString : public FCDEffectParameter
{
private:
    string value;

public:
    FCDEffectParameterString(FCDocument* document);

    virtual ~FCDEffectParameterString();

    virtual Type GetType() const { return STRING; }

    const string& GetValue() const { return value; }

    void SetValue(const string& _value) { value = _value; }

    virtual FCDEffectParameter* Clone();

    virtual void Overwrite(FCDEffectParameter* target);

    virtual FUStatus LoadFromXML(xmlNode* parameterNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;
};

class FCOLLADA_EXPORT FCDEffectParameterFloat : public FCDEffectParameter
{
public:
    enum FloatType
    {
        FLOAT, 
        HALF 
    };

private:
    FloatType floatType;
    float value;
    float min;
    float max;

public:
    FCDEffectParameterFloat(FCDocument* document);

    virtual ~FCDEffectParameterFloat();

    virtual FCDEffectParameter::Type GetType() const { return FCDEffectParameter::FLOAT; }

    FloatType GetFloatType() const { return floatType; }

    void SetFloatType(FloatType type) { floatType = type; }

    float& GetValue() { return value; }
    const float& GetValue() const { return value; } 
    void SetValue(float _value) { value = _value; }

    float GetMin() const { return min; }

    void SetMin(float _min) { min = _min; }

    float GetMax() const { return max; }

    void SetMax(float _max) { max = _max; }

    virtual FCDEffectParameter* Clone();

    virtual void Overwrite(FCDEffectParameter* target);

    virtual FUStatus LoadFromXML(xmlNode* parameterNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;
};

class FCOLLADA_EXPORT FCDEffectParameterFloat2 : public FCDEffectParameter
{
public:
    enum FloatType
    {
        FLOAT, 
        HALF 
    };

private:
    FloatType floatType;
    float value_x;
    float value_y;

public:
    FCDEffectParameterFloat2(FCDocument* document);

    virtual ~FCDEffectParameterFloat2();

    virtual Type GetType() const { return FLOAT2; }

    FloatType GetFloatType() const { return floatType; }

    void SetFloatType(FloatType type) { floatType = type; }

    float& GetValueX() { return value_x; }
    const float& GetValueX() const { return value_x; } 
    void SetValueX(float value) { value_x = value; }

    float& GetValueY() { return value_y; }
    const float& GetValueY() const { return value_y; } 
    void SetValueY(float value) { value_y = value; }

    virtual FCDEffectParameter* Clone();

    virtual void Overwrite(FCDEffectParameter* target);

    virtual FUStatus LoadFromXML(xmlNode* parameterNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;
};

class FCOLLADA_EXPORT FCDEffectParameterFloat3 : public FCDEffectParameter
{
public:
    enum FloatType
    {
        FLOAT, 
        HALF 
    };

private:
    FloatType floatType;
    FMVector3 value;

public:
    FCDEffectParameterFloat3(FCDocument* document);

    virtual ~FCDEffectParameterFloat3();

    virtual Type GetType() const { return FLOAT3; }

    FloatType GetFloatType() const { return floatType; }

    void SetFloatType(FloatType type) { floatType = type; }

    float& GetValueX() { return value.x; }
    const float& GetValueX() const { return value.x; } 
    void SetValueX(float _value) { value.x = _value; }

    float& GetValueY() { return value.y; }
    const float& GetValueY() const { return value.y; } 
    void SetValueY(float _value) { value.y = _value; }

    float& GetValueZ() { return value.z; }
    const float& GetValueZ() const { return value.z; } 
    void SetValueZ(float _value) { value.z = _value; }

    virtual FCDEffectParameter* Clone();

    virtual void Overwrite(FCDEffectParameter* target);

    virtual FUStatus LoadFromXML(xmlNode* parameterNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;
};

class FCOLLADA_EXPORT FCDEffectParameterVector : public FCDEffectParameter
{
public:
    enum FloatType
    {
        FLOAT, 
        HALF 
    };

private:
    FloatType floatType;
    float vector[4];

public:
    FCDEffectParameterVector(FCDocument* document);

    virtual ~FCDEffectParameterVector();

    virtual Type GetType() const { return VECTOR; }

    FloatType GetFloatType() const { return floatType; }

    void SetFloatType(FloatType type) { floatType = type; }

    float* GetVector() { return vector; }
    const float* GetVector() const { return vector; } 
    float& GetValueX() { return vector[0]; }
    const float& GetValueX() const { return vector[0]; } 
    void SetValueX(float _value) { vector[0] = _value; }

    float& GetValueY() { return vector[1]; }
    const float& GetValueY() const { return vector[1]; } 
    void SetValueY(float _value) { vector[1] = _value; }

    float& GetValueZ() { return vector[2]; }
    const float& GetValueZ() const { return vector[2]; } 
    void SetValueZ(float _value) { vector[2] = _value; }

    float& GetValueW() { return vector[3]; }
    const float& GetValueW() const { return vector[3]; } 
    void SetValueW(float _value) { vector[3] = _value; }

    virtual FCDEffectParameter* Clone();

    virtual void Overwrite(FCDEffectParameter* target);

    virtual FUStatus LoadFromXML(xmlNode* parameterNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;
};

class FCOLLADA_EXPORT FCDEffectParameterMatrix : public FCDEffectParameter
{
public:
    enum FloatType
    {
        FLOAT, 
        HALF 
    };

private:
    FloatType floatType;
    FMMatrix44 matrix;

public:
    FCDEffectParameterMatrix(FCDocument* document);

    virtual ~FCDEffectParameterMatrix();

    virtual Type GetType() const { return MATRIX; }

    FloatType GetFloatType() const { return floatType; }

    void SetFloatType(FloatType type) { floatType = type; }

    FMMatrix44& GetMatrix() { return matrix; }
    const FMMatrix44& GetMatrix() const { return matrix; } 
    void SetMatrix(const FMMatrix44& mx) { matrix = mx; }

    virtual FCDEffectParameter* Clone();

    virtual void Overwrite(FCDEffectParameter* target);

    virtual FUStatus LoadFromXML(xmlNode* parameterNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;
};

#endif // _FCD_EFFECT_PARAMETER_H_

---