PhaseSpace.h

/***************************************************************************
 *   This file is part of OpenCAL: Open Computer Animation Library         *
 *   I created OpenCAL as my master's thesis Computer Science (multimedia) *
 *   at the tUL university in Diepenbeek, Belgium                          *
 *                                                                         *
 *   Copyright (C) 2003-2004 by Jeroen Dierckx                             *
 *   jeroen.dierckx@student.luc.ac.be                                      *
 *                                                                         *
 ***************************************************************************/

#ifndef OPENCAL_PHASESPACE_H
#define OPENCAL_PHASESPACE_H

// Includes
#include <OpenCAL/global.h>

#include <vector>
using std::vector;

namespace OpenCAL
{
    // Forward declarations
    namespace Utils { class Vector3; class Quaternion; }
    using Utils::Vector3;
    using Utils::Quaternion;


    class OPENCAL_API PhaseSpace
    {
    protected:
        // Member variables
        vector<float> m_values;
        unsigned int m_position;

    public:
        // Constructors and destructor
        PhaseSpace(unsigned int reserve = 0);
        PhaseSpace(const float *values, unsigned int size);
        //PhaseSpace(const PhaseSpace &source);
        virtual ~PhaseSpace();

        // Essential functions
        void clear(unsigned int reserve = 0) { m_values.clear(); m_values.reserve(reserve); m_position = 0; }
        void reset() { m_position = 0; }
        void skip(unsigned int positions) { m_position += positions; }
        float getNext() { return m_values[m_position++]; }


        // Get functions
        float getValue(unsigned int i) const { return m_values[i]; }
        vector<float> &getVector() { return m_values; }
        unsigned int getSize() const { return m_values.size(); }

        // Set functions
        void setValue(unsigned int i, float value) { m_values[i] = value; }
        void setValues(const float *values, unsigned int size);

        // Information functions
        bool isEmpty() const { return m_values.empty(); }

        // Concatenation functions
        void concat(const PhaseSpace &p);
        void concatZeros(unsigned int positions) { for(unsigned int i = 0; i < positions; ++i) m_values.push_back(0); }
        void concat(float value) { m_values.push_back(value); }
        void concat(const Vector3 &v);
        void concat(const Quaternion &q);

        // Operator functions
        float operator[](unsigned int i) const { return m_values[i]; }
        float &operator[](unsigned int i) { return m_values[i]; }

        void operator+=(const PhaseSpace &p);
        PhaseSpace operator+(const PhaseSpace &p);
        PhaseSpace operator*(float value);

        /*
        void operator +=(const PhaseSpace &p);
        PhaseSpace operator*(float value);
        */

        // Cast operators

        // Other functions
        void add(const PhaseSpace &p, float scale = 1.0f);

        // Friend functions
    friend PhaseSpace operator*(float value, const PhaseSpace &p);
    };
}

#endif // OPENCAL_PHASESPACE_H

---