FCDocument/FCDLight.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_LIGHT_H_
#define _FCD_LIGHT_H_

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

class FCDocument;
class FCDSceneNode;

class FCOLLADA_EXPORT FCDLight : public FCDTargetedEntity
{
public:
    enum LightType
    {
        POINT, 
        SPOT, 
        AMBIENT, 
        DIRECTIONAL 
    };

private:
    DeclareObjectType;

    // Common Light parameters
    FMVector3 color;    
    float intensity; // Max and Maya
    LightType lightType;

    // Point and spot light parameters
    float constantAttenuationFactor;
    float linearAttenuationFactor;
    float quadracticAttenuationFactor;

    // Spot-specific light parameters
    float fallOffExponent;
    float fallOffAngle;
    float outerAngle; // Max-specific
    float penumbraAngle; // Maya-specifc: these last two are are related as 'penumbra = outerAngle - fallOffAngle'.
    float aspectRatio; // Max-specific, for rectangle lights
    float dropoff; // Maya-specific

    // Directional light parameters
    // Overshoot is a Max-specific flag that sets a directional light to cover everything,
    // rather than to be restricted to a cylinder defined by the fallOffAngle/outerAngle.
    bool overshoots; // Max-specific

public:
    FCDLight(FCDocument* document);

    virtual ~FCDLight();

    virtual Type GetType() const { return LIGHT; }

    FMVector3& GetColor() { return color; }
    const FMVector3& GetColor() const { return color; } 
    void SetColor(const FMVector3& col) { color = col; }

    float& GetIntensity() { return intensity; }
    const float& GetIntensity() const { return intensity; } 
    void SetIntensity(float _intensity) { intensity = _intensity; }

    LightType GetLightType() const { return lightType; }

    void SetLightType(LightType type) { lightType = type; }

    float& GetConstantAttenuationFactor() { return constantAttenuationFactor; }
    const float& GetConstantAttenuationFactor() const { return constantAttenuationFactor; } 
    void SetConstantAttenuationFactor(float factor) { constantAttenuationFactor = factor; }

    float& GetLinearAttenuationFactor() { return linearAttenuationFactor; }
    const float& GetLinearAttenuationFactor() const { return linearAttenuationFactor; } 
    void SetLinearAttenuationFactor(float factor) { linearAttenuationFactor = factor; }

    float& GetQuadraticAttenuationFactor() { return quadracticAttenuationFactor; }
    const float& GetQuadraticAttenuationFactor() const { return quadracticAttenuationFactor; } 
    void SetQuadraticAttenuationFactor(float factor) { quadracticAttenuationFactor = factor; }

    float& GetFallOffExponent() { return fallOffExponent; }
    const float& GetFallOffExponent() const { return fallOffExponent; } 
    void SetFallOffExponent(float exponent) { fallOffExponent = exponent; }

    float& GetFallOffAngle() { return fallOffAngle; }
    const float& GetFallOffAngle() const { return fallOffAngle; } 
    void SetFallOffAngle(float angle) { fallOffAngle = angle; }

    float& GetOuterAngle() { return outerAngle; }
    const float& GetOuterAngle() const { return outerAngle; } 
    void SetOuterAngle(float angle) { outerAngle = angle; }

    float& GetPenumbraAngle() { return penumbraAngle; }
    const float& GetPenumbraAngle() const { return penumbraAngle; } 
    void SetPenumbraAngle(float angle) { penumbraAngle = angle; }

    float& GetAspectRatio() { return aspectRatio; }
    const float& GetAspectRatio() const { return aspectRatio; } 
    void SetAspectRatio(float ratio) { aspectRatio = ratio; }
    
    float& GetDropoff() { return dropoff; }
    const float& GetDropoff() const { return dropoff; } 
    void SetDropoff(float factor) { dropoff = factor; }

    bool DoesOvershoot() const { return overshoots; }

    void SetOvershoot(bool _overshoots) { overshoots = _overshoots; }

    FUStatus LoadFromXML(xmlNode* lightNode);

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

#endif // _FCD_LIGHT_H_

---