source: NonGTP/FCollada/FCDocument/FCDAnimationCurve.h @ 964

/*
        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
*/

/**
        @file FCDAnimationCurve.h
        This file contains the FCDAnimationCurve class.
*/

#ifndef _FCD_ANIMATION_CURVE_H_
#define _FCD_ANIMATION_CURVE_H_

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

class FCDAnimationClip;
class FCDAnimationChannel;

typedef vector<FCDAnimationClip*> FCDAnimationClipList; /**< A dynamically-sized array of animation clips. */
typedef float (*FCDConversionFunction)(float v); /**< A simple conversion function. */

/**
        A COLLADA single-dimensional animation curve.
        An animation curve holds the keyframes necessary
        to animate an animatable floating-point value.

        There are multiple interpolation mechanisms supported by COLLADA.
        FCollada supports the CONSTANT, LINEAR and BEZIER interpolations.

        @see FUDaeInterpolation FUDaeInfinity
        @ingroup FCDocument
*/
class FCOLLADA_EXPORT FCDAnimationCurve : public FCDObject
{
private:
        DeclareObjectType;
        FCDAnimationChannel* parent;

        // Targeting information
        int32 targetElement;
        string targetQualifier;

        // Input information
        FloatList keys, keyValues;
        FloatList inTangents, outTangents;
        FloatList inTangentWeights, outTangentWeights;
        bool isWeightedCurve;
        FUDaeInfinity::Infinity preInfinity;
        FUDaeInfinity::Infinity postInfinity;

        // Driver information
        const float* inputDriver;
        string driverPointer;

        // The interpolation values follow the FUDaeInterpolation enum (FUDaeEnum.h)
        UInt32List interpolations;

        // Animation clips that depend on this curve
        FCDAnimationClipList clips;

public:
        /** Constructor: do not use directly.
                Instead, use the FCDAnimationChannel::AddCurve function.
                You should also attach the new curve to an animated
                element using the FCDAnimated::SetCurve function.
                @param document The COLLADA document that owns the animation curve.
                @param parent The animation channel that contains the curve. */
        FCDAnimationCurve(FCDocument* document, FCDAnimationChannel* parent);

        /** Destructor: do not release directly.
                Instead, use the FCDAnimationChannel::ReleaseCurve function. */
        virtual ~FCDAnimationCurve();

        /** Retrieves the animation channel that contains this animation curve.
                @return The parent animation channel. */
        inline FCDAnimationChannel* GetParent() { return parent; }
        inline const FCDAnimationChannel* GetParent() const { return parent; } /**< See above. */

        /** Retrieves the list of key inputs for the animation curve.
                @return The list of key inputs. */
        inline FloatList& GetKeys() { return keys; }
        inline const FloatList& GetKeys() const { return keys; } /**< See above. */

        /** Retrieves the list of key outputs for the animation curve.
                @return The list of key outputs. */
        inline FloatList& GetKeyValues() { return keyValues; }
        inline const FloatList& GetKeyValues() const { return keyValues; } /**< See above. */

        /** Retrieves the list of interpolation type for the segments of the animation curve.
                There is always one interpolation type for each key in the curve. The interpolation type
                of a segment of the curve is set at the key at which begins the segment.
                @see FUDaeInterpolation
                @return The list of interpolation types. */
        inline UInt32List& GetInterpolations() { return interpolations; }
        inline const UInt32List& GetInterpolations() const { return interpolations; } /**< See above. */

        /** Retrieves the list of key in-tangent values for the animation curve.
                This list has data only for curves that include segments with the bezier interpolation.
                @return The list of in-tangent values. */
        inline FloatList& GetInTangents() { return inTangents; }
        inline const FloatList& GetInTangents() const { return inTangents; } /**< See above. */

        /** Retrieves the list of key out-tangent values for the animation curve.
                This list has data only for curves that include segments with the bezier interpolation.
                @return The list of out-tangent values. */
        inline FloatList& GetOutTangents() { return outTangents; }
        inline const FloatList& GetOutTangents() const { return outTangents; } /**< See above. */

        /** Retrieves the list of key in-tangent weights for the animation curve.
                This list has data only for curves that are weighted
                and include segments with the bezier interpolation.
                @see IsWeightedCurve
                @return The list of in-tangent weights. */
        inline FloatList& GetInTangentWeights() { return inTangentWeights; }
        inline const FloatList& GetInTangentWeights() const { return inTangentWeights; } /**< See above. */

        /** Retrieves the list of key out-tangent weights for the animation curve.
                This list has data only for curves that are weighted
                and include segments with the bezier interpolation.
                @see IsWeightedCurve
                @return The list of out-tangent weights. */
        inline FloatList& GetOutTangentWeights() { return outTangentWeights; }
        inline const FloatList& GetOutTangentWeights() const { return outTangentWeights; } /**< See above. */

        /** Retrieves whether this curve has weighted tangents. Tangent weights
                give you access to 2D tangents by providing the length of the tangent.
                @return Whether this curve has weighted tangents. */
        inline bool IsWeightedCurve() const { return isWeightedCurve; }

        /** Sets whether this curve has weighted tangents. Tangent weights
                give you access to 2D tangents by providing the length of the tangent.
                @param _isWeightedCurve Whether this curve has weighted tangents. */
        inline void SetWeightedCurveFlag(bool _isWeightedCurve) { isWeightedCurve = _isWeightedCurve; }

        /** Retrieves the type of behavior for the curve if the input value is
                outside the input interval defined by the curve keys and less than any key input value.
                @see FUDaeInfinity
                @return The pre-infinity behavior of the curve. */
        inline FUDaeInfinity::Infinity GetPreInfinity() const { return preInfinity; }

        /** Sets the behavior of the curve if the input value is
                outside the input interval defined by the curve keys and less than any key input value.
                @see FUDaeInfinity
                @param infinity The pre-infinity behavior of the curve. */
        inline void SetPreInfinity(FUDaeInfinity::Infinity infinity) { preInfinity = infinity; }

        /** Retrieves the type of behavior for the curve if the input value is
                outside the input interval defined by the curve keys and greater than any key input value.
                @see FUDaeInfinity
                @return The post-infinity behavior of the curve. */
        inline FUDaeInfinity::Infinity GetPostInfinity() const { return postInfinity; }

        /** Sets the behavior of the curve if the input value is
                outside the input interval defined by the curve keys and greater than any key input value.
                @see FUDaeInfinity
                @param infinity The post-infinity behavior of the curve. */
        inline void SetPostInfinity(FUDaeInfinity::Infinity infinity) { postInfinity = infinity; }

        /** Retrieves the value pointer that drives this animation curve.
                @return The driver value pointer. This pointer will be NULL to indicate
                        that time drives the animation curve. */
        inline const float* GetDriver() const { return inputDriver; }

        /** Sets the value pointer that drives the animation curve.
                @param driver The driver value pointer. Set this pointer to NULL
                        to indicate that time drives the animation curve. */
        inline void SetDriver(const float* driver) { inputDriver = driver; }

        /** Retrieves the list of animation clips that use this animation curve.
                @return The list of animation clips. */
        inline FCDAnimationClipList& GetClips() { return clips; }
        inline const FCDAnimationClipList& GetClips() const { return clips; } /**< See above. */

        /** Readies this curve for evaluation.
                This will create the tangents and the tangent weights, if necessary. */
        void Ready();

        /** Clones the animation curve.
                @return The cloned animation curve. */
        FCDAnimationCurve* Clone();

        /** Applies a conversion function to the keys output values of the animation curve.
                @param valueConversion The conversion function to use on the key outputs.
                @param tangentConversion The conversion function to use on the key tangents. */
        void ConvertValues(FCDConversionFunction valueConversion, FCDConversionFunction tangentConversion);

        /** Applies a conversion function to the keys input values of the animation curve.
                @param timeConversion The conversion function to use on the key inputs.
                @param tangentWeightConversion The conversion function to use on the key tangent weights. */
        void ConvertInputs(FCDConversionFunction timeConversion, FCDConversionFunction tangentWeightConversion);

        /** Evaluates the animation curve.
                @param input An input value.
                @return The sampled value of the curve at the given input value. */
        float Evaluate(float input) const;

        /** [INTERNAL] Adds an animation clip to the list of animation clips that use this curve.
                @param clip An animation clip. */
        inline void RegisterAnimationClip(FCDAnimationClip* clip) { clips.push_back(clip); }

        /** [INTERNAL] Writes out the data sources necessary to import the animation curve
                to a given XML tree node.
                @param parentNode The XML tree node in which to create the data sources.
                @param baseId A COLLADA Id prefix to use when generating the source ids. */
        void WriteSourceToXML(xmlNode* parentNode, const string& baseId) const;

        /** [INTERNAL] Writes out the sampler that puts together the data sources
                and generates a sampling function.
                @param parentNode The XML tree node in which to create the sampler.
                @param baseId The COLLADA id prefix used when generating the source ids.
                        This prefix is also used to generate the sampler COLLADA id.
                @return The created XML tree node. */
        xmlNode* WriteSamplerToXML(xmlNode* parentNode, const string& baseId) const;

        /** [INTERNAL] Writes out the animation channel that attaches the sampling function
                to the animatable value.
                @param parentNode The XML tree node in which to create the sampler.
                @param baseId The COLLADA Id prefix used when generating the source ids
                        and the sampler id.
                @param targetPointer The target pointer prefix for the targeted animated element.
                @return The created XML tree node. */
        xmlNode* WriteChannelToXML(xmlNode* parentNode, const string& baseId, const char* targetPointer) const;

        /** [INTERNAL] Retrieves the target element suffix for the curve.
                This will be -1 if the animated element does not belong to an
                animated element list.
                @return The target element suffix. */
        inline int32 GetTargetElement() const { return targetElement; }

        /** [INTERNAL] Retrieves the target qualifier for the curve.
                This will be the empty string if that the curve affects
                a one-dimensional animated element.
                @return The target qualifier. */
        inline const string& GetTargetQualifier() const { return targetQualifier; }

        /** [INTERNAL] Sets the target element suffix for the curve.
                @param e The target element suffix. Set to value to -1
                        if the animated element does not belong to an animated element list. */
        inline void SetTargetElement(int32 e) { targetElement = e; }

        /** [INTERNAL] Sets the target qualifier for the curve.
                @param q The target qualifier. You may sets this string to the empty string
                        only if that the curve affects a one-dimensional animated element. */
        inline void SetTargetQualifier(const string& q) { targetQualifier = q; }

        /** [INTERNAL] Retrieves the target pointer prefix of the driver.
                @return The driver's target pointer prefix. */
        inline const string& GetDriverPointer() const { return driverPointer; }

        /** [INTERNAL] Sets the target pointer prefix of the driver.
                @param p The driver's target pointer prefix. Set this string to the
                        empty string if the input of the animation curve is the time. */
        inline void SetDriverPointer(const string& p) { driverPointer = p; }
};

#endif // _FCD_ANIMATION_CURVE_H_