colorInterpolationManager.h

Go to the documentation of this file.

/**
 * PANDA 3D SOFTWARE
 * Copyright (c) Carnegie Mellon University.  All rights reserved.
 *
 * All use of this software is subject to the terms of the revised BSD
 * license.  You should have received a copy of this license along
 * with this source code in a file named "LICENSE."
 *
 * @file colorInterpolationManager.h
 * @author joswilso
 * @date 2005-06-02
 */

#ifndef COLORINTERPOLATIONMANAGER_H
#define COLORINTERPOLATIONMANAGER_H

#include "luse.h"
#include "pvector.h"
#include "typedObject.h"
#include "typedReferenceCount.h"

/**
 * Abstract class from which all other functions should inherit.  Defines the
 * virtual interpolate() function.
 */

class EXPCL_PANDA_PARTICLESYSTEM ColorInterpolationFunction : public TypedReferenceCount {
PUBLISHED:
// virtual string get_type();

public:
  ColorInterpolationFunction();
  virtual ~ColorInterpolationFunction();

  virtual LColor interpolate(const PN_stdfloat t = 0) const = 0;

public:
  static TypeHandle get_class_type() {
    return _type_handle;
  }

  static void init_type() {
    TypedReferenceCount::init_type();
    register_type(_type_handle, "ColorInterpolationFunction",
                  TypedReferenceCount::get_class_type());
  }

  virtual TypeHandle get_type() const {
    return get_class_type();
  }
  virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
private:
  static TypeHandle _type_handle;
};

/**
 * Defines a constant color over the lifetime of the segment.
 */

class EXPCL_PANDA_PARTICLESYSTEM ColorInterpolationFunctionConstant : public ColorInterpolationFunction {
PUBLISHED:
  INLINE LColor get_color_a() const;

  INLINE void set_color_a(const LColor &c);

public:
  ColorInterpolationFunctionConstant();
  ColorInterpolationFunctionConstant(const LColor &color_a);

protected:
  virtual LColor interpolate(const PN_stdfloat t = 0) const;
  // virtual string get_type();

  LColor _c_a;

public:
  static TypeHandle get_class_type() {
    return _type_handle;
  }

  static void init_type() {
    ColorInterpolationFunction::init_type();
    register_type(_type_handle, "ColorInterpolationFunctionConstant",
                  ColorInterpolationFunction::get_class_type());
  }

  virtual TypeHandle get_type() const {
    return get_class_type();
  }
  virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
private:
  static TypeHandle _type_handle;
};

/**
 * Defines a linear interpolation over the lifetime of the segment.
 */

class EXPCL_PANDA_PARTICLESYSTEM ColorInterpolationFunctionLinear : public ColorInterpolationFunctionConstant {
PUBLISHED:
  INLINE LColor get_color_b() const;

  INLINE void set_color_b(const LColor &c);

public:
  ColorInterpolationFunctionLinear();
  ColorInterpolationFunctionLinear(const LColor &color_a, const LColor &color_b);

protected:
  LColor interpolate(const PN_stdfloat t = 0) const;
  // virtual string get_type();

  LColor _c_b;

public:
  static TypeHandle get_class_type() {
    return _type_handle;
  }

  static void init_type() {
    ColorInterpolationFunctionConstant::init_type();
    register_type(_type_handle, "ColorInterpolationFunctionLinear",
                  ColorInterpolationFunctionConstant::get_class_type());
  }

  virtual TypeHandle get_type() const {
    return get_class_type();
  }
  virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
private:
  static TypeHandle _type_handle;
};

/**
 * Defines a discrete cyclical transition between two colors.  The widths
 * describe a portion of the segment's lifetime for which the corresponding
 * color should be selected.  If their sum is less than 1, the function
 * repeats until the end of the segment.
 */

class EXPCL_PANDA_PARTICLESYSTEM ColorInterpolationFunctionStepwave : public ColorInterpolationFunctionLinear {
PUBLISHED:
  INLINE PN_stdfloat get_width_a() const;
  INLINE PN_stdfloat get_width_b() const;

  INLINE void set_width_a(const PN_stdfloat w);
  INLINE void set_width_b(const PN_stdfloat w);

public:
  ColorInterpolationFunctionStepwave();
  ColorInterpolationFunctionStepwave(const LColor &color_a, const LColor &color_b, const PN_stdfloat width_a, const PN_stdfloat width_b);

protected:
  LColor interpolate(const PN_stdfloat t = 0) const;
  // virtual string get_type();

  PN_stdfloat _w_a;
  PN_stdfloat _w_b;

public:
  static TypeHandle get_class_type() {
    return _type_handle;
  }

  static void init_type() {
    ColorInterpolationFunctionLinear::init_type();
    register_type(_type_handle, "ColorInterpolationFunctionStepwave",
                  ColorInterpolationFunctionLinear::get_class_type());
  }

  virtual TypeHandle get_type() const {
    return get_class_type();
  }
  virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
private:
  static TypeHandle _type_handle;
};

/**
 * Defines a sinusoidal blending between two colors.  A period of "1"
 * corresponds to a single transition from color_a to color_b and then back to
 * color_a over the course of the segment's lifetime.  A shorter period will
 * result in a higher frequency cycle.
 */

class EXPCL_PANDA_PARTICLESYSTEM ColorInterpolationFunctionSinusoid : public ColorInterpolationFunctionLinear {
PUBLISHED:
  INLINE PN_stdfloat get_period() const;

  INLINE void set_period(const PN_stdfloat p);

public:
  ColorInterpolationFunctionSinusoid();
  ColorInterpolationFunctionSinusoid(const LColor &color_a, const LColor &color_b, const PN_stdfloat period);

protected:
  LColor interpolate(const PN_stdfloat t = 0) const;
  // virtual string get_type();

  PN_stdfloat _period;

public:
  static TypeHandle get_class_type() {
    return _type_handle;
  }

  static void init_type() {
    ColorInterpolationFunctionLinear::init_type();
    register_type(_type_handle, "ColorInterpolationFunctionSinusoid",
                  ColorInterpolationFunctionLinear::get_class_type());
  }

  virtual TypeHandle get_type() const {
    return get_class_type();
  }
  virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
private:
  static TypeHandle _type_handle;
};

/**
 * A single unit of interpolation.  The begin and end times are interpolated
 * over the lifetime of the particle, thus have the range of [0,1]. Each
 * segment also has a function associated with it.
 */

class EXPCL_PANDA_PARTICLESYSTEM ColorInterpolationSegment : public ReferenceCount {
public:
  ColorInterpolationSegment(ColorInterpolationFunction* function, const PN_stdfloat &time_begin, const PN_stdfloat &time_end, const bool is_modulated, const int id);

PUBLISHED:
  ColorInterpolationSegment(const ColorInterpolationSegment &s);

  virtual ~ColorInterpolationSegment();

  // INLINE ColorInterpolationFunction* get_function() const;
  INLINE TypedReferenceCount* get_function() const;
  INLINE PN_stdfloat get_time_begin() const;
  INLINE PN_stdfloat get_time_end() const;
  INLINE bool is_modulated() const;
  INLINE int get_id() const;
  INLINE bool is_enabled() const;

  INLINE void set_function(ColorInterpolationFunction* function);
  INLINE void set_time_begin(const PN_stdfloat time);
  INLINE void set_time_end(const PN_stdfloat time);
  INLINE void set_is_modulated(const bool flag);
  INLINE void set_enabled(const bool enabled);

public:
  LColor interpolateColor(const PN_stdfloat t) const;

protected:
  PT(ColorInterpolationFunction) _color_inter_func;
  PN_stdfloat _t_begin;
  PN_stdfloat _t_end;
  PN_stdfloat _t_total;
  bool _is_modulated;
  bool _enabled;
  const int _id;
};

/**
 * High level class for color interpolation.  Segments must be added to the
 * manager in order to achieve results using the "add_*****()" functions.
 * Access to these segments is provided but not necessary general use.
 */

class EXPCL_PANDA_PARTICLESYSTEM ColorInterpolationManager : public ReferenceCount {
PUBLISHED:
ColorInterpolationManager();
  ColorInterpolationManager(const LColor &c);
  ColorInterpolationManager(const ColorInterpolationManager& copy);
  virtual ~ColorInterpolationManager();

  int add_constant(const PN_stdfloat time_begin = 0.0f, const PN_stdfloat time_end = 1.0f, const LColor &color = LColor(1.0f,1.0f,1.0f,1.0f), const bool is_modulated = true);
  int add_linear(const PN_stdfloat time_begin = 0.0f, const PN_stdfloat time_end = 1.0f, const LColor &color_a = LColor(1.0f,0.0f,0.0f,1.0f), const LColor &color_b = LColor(0.0f,1.0f,0.0f,1.0f), const bool is_modulated = true);
  int add_stepwave(const PN_stdfloat time_begin = 0.0f, const PN_stdfloat time_end = 1.0f, const LColor &color_a = LColor(1.0f,0.0f,0.0f,1.0f), const LColor &color_b = LColor(0.0f,1.0f,0.0f,1.0f), const PN_stdfloat width_a = 0.5f, const PN_stdfloat width_b = 0.5f, const bool is_modulated = true);
  int add_sinusoid(const PN_stdfloat time_begin = 0.0f, const PN_stdfloat time_end = 1.0f, const LColor &color_a = LColor(1.0f,0.0f,0.0f,1.0f), const LColor &color_b = LColor(0.0f,1.0f,0.0f,1.0f), const PN_stdfloat period = 1.0f, const bool is_modulated = true);

  INLINE void set_default_color(const LColor &c);
  INLINE ColorInterpolationSegment* get_segment(const int seg_id);
  INLINE std::string get_segment_id_list();
  void clear_segment(const int seg_id);
  void clear_to_initial();

public:
  LColor generateColor(const PN_stdfloat interpolated_time);

private:
  LColor _default_color;
  pvector<PT(ColorInterpolationSegment)> _i_segs;
  int _id_generator;
};

#include "colorInterpolationManager.I"

#endif //COLORINTERPOLATIONMANAGER_H