MAValueGenerators.hpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  AiBO+ is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#pragma once

#include "MACoreTypes.hpp"
#include "MASignal.hpp"

#include <MCDefs.hpp>

#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>

#include <vector>

class MADevice;
class MAGeneratorBase;
class MAGeneratorContainer;
class MCTimer;

namespace MA
{
typedef std::vector<MAGeneratorBase*> GeneratorList;
}

class MAGeneratorBase
{
public:
  typedef enum
  {
    FunctionTypeMin = 0,
    Linear = FunctionTypeMin, 
    AcceleratingSines,        
    DeceleratingSines,        
    FunctionTypeMax = DeceleratingSines
  } FunctionType;

protected:

  MAGeneratorBase(float min = MCFloatInfinity(), float max = MCFloatInfinity());

public:
  virtual ~MAGeneratorBase();

  static FunctionType GetRandomFunction();

  bool IsAbsolute() const;

  int GetStartTime() const;

  int GetElapsedTime() const;

  virtual int GetDuration() const;

  virtual void ScaleDuration(float scale);

  float GetMinValue() const;

  virtual void SetMinValue(float min_value);

  float GetMaxValue() const;

  virtual void SetMaxValue(float max_value);

  void SetTransferFunction(FunctionType function);

  bool IsStarted() const;

  virtual void Start();

  virtual void Start(float value);

  virtual void StartFromTime(int start_time);

  bool IsExpired() const;

  virtual float GetCurrentValue() = 0;

  virtual int GetOverTime() const = 0;

protected:

  float GetTransformedValue(float value) const;

  bool CheckValueRange(float value, bool verbose = true);

private:
  float MinValue;
  float MaxValue;
protected:
  int Duration;
  boost::scoped_ptr<MCTimer> Timer;
  FunctionType Function;
};


class MADelayGenerator : public MAGeneratorBase
{
public:
  // This declaration is needed to have overloaded member functions with different
  // parameter signature visible.
  using MAGeneratorBase::Start;

  explicit MADelayGenerator(int duration);

  virtual void SetMinValue(float min_value) override;
  virtual void SetMaxValue(float max_value) override;
  virtual void Start() override;
  virtual void Start(float value) override;
  virtual void StartFromTime(int start_time) override;
  virtual float GetCurrentValue() override;
  virtual int GetOverTime() const override;
};

class MASimpleGenerator : public MAGeneratorBase
{
public:
  // This declaration is needed to have overloaded member functions with different
  // parameter signature visible.
  using MAGeneratorBase::Start;

  MASimpleGenerator(float min, float max, int duration);

  MASimpleGenerator(float max, int duration);

  virtual float GetCurrentValue() override;
  virtual int GetOverTime() const override;
};

class MAPeriodicGenerator : public MAGeneratorBase
{
public:
  // This declaration is needed to have overloaded member functions with different
  // parameter signature visible.
  using MAGeneratorBase::Start;

  MAPeriodicGenerator(float min, float max, int dur1, int dur2, int dur3, int dur4,
                      int dur5, bool loop = false);

  MAPeriodicGenerator(float max, int dur1, int dur2, int dur3, int dur4, int dur5,
                      bool loop = false);

  virtual void Start(float value) override;
  virtual void ScaleDuration(float scale) override;
  virtual float GetCurrentValue() override;
  virtual int GetOverTime() const override;

protected:
  int Duration1;
  int Duration2;
  int Duration3;
  int Duration4;
  int Duration5;
  bool Loop;
};

class MAGeneratorContainer
{
public:
  typedef MASignal<MAGeneratorContainer&> ExpiredSignalType;

  explicit MAGeneratorContainer(MAGeneratorBase& generator);

  ~MAGeneratorContainer();

  static void DumpAllContainers();

  static void SetVerbose(bool new_state);

  void SetOwnerDevice(MADevice& owner);

  void BlockExpiredSignal();

  void UnblockExpiredSignal();

  bool IsExpiredSignalBlocked() const;

  void SetTransitionName(const std::string& name);

  std::string GetTransitionName() const;

  bool IsAbsolute() const;

  int GetDuration() const;

  void ScaleDuration(float scale);

  bool IsFinite() const;

  bool IsPermanent() const;

  bool IsStarted() const;

  bool IsExpired();

  bool HasOneGenerator() const;

  bool HasRealGenerator() const;

  void AddGenerator(MAGeneratorBase& generator, bool in_front = false);

  void ScaleGenerators(float min, float max, float new_max);

  void Start(float device_value);

  void CalculateCurrentValue(float device_value);

  float GetCurrentValue();

  float GetStartingValue() const;

  float GetDesiredStartingValue() const;

  float GetTargetValue() const;

  void MakePermanent();

  void Dump();

  boost::shared_ptr<ExpiredSignalType> ExpiredSignal;
private:
  MA::GeneratorList Generators;
  MADevice* Device;
  float StartingValue;
  float CurrentValue;
  std::string TransitionName;
  bool AlreadyExpired;
  int ExpiredSignalBlockRefCount;
};