1
0
mirror of https://github.com/clementine-player/Clementine synced 2024-12-25 01:02:37 +01:00
Clementine-audio-player-Mac.../3rdparty/libprojectm/Renderer/RenderItemMergeFunction.hpp
2010-06-06 21:43:45 +00:00

237 lines
7.6 KiB
C++

/*
* RenderItemMergeFunction.hpp
*
* Created on: Feb 16, 2009
* Author: struktured
*/
#ifndef RenderItemMergeFunction_HPP_
#define RenderItemMergeFunction_HPP_
#include "Common.hpp"
#include "Renderable.hpp"
#include "Waveform.hpp"
#include <limits>
#include <functional>
#include <map>
template <class T>
inline T interpolate(T a, T b, float ratio)
{
return (ratio*a + (1-ratio)*b) * 0.5;
}
template <>
inline int interpolate(int a, int b, float ratio)
{
return (int)(ratio*(float)a + (1-ratio)*(float)b) * 0.5;
}
template <>
inline bool interpolate(bool a, bool b, float ratio)
{
return (ratio >= 0.5) ? a : b;
}
/// Merges two render items and returns zero if they are virtually equivalent and large values
/// when they are dissimilar. If two render items cannot be compared, NOT_COMPARABLE_VALUE is returned.
class RenderItemMergeFunction {
public:
virtual RenderItem * operator()(const RenderItem * r1, const RenderItem * r2, double ratio) const = 0;
virtual TypeIdPair typeIdPair() const = 0;
};
/// A base class to construct render item distance mergeFunctions. Just specify your two concrete
/// render item types as template parameters and override the computeMerge() function.
template <class R1, class R2=R1, class R3=R2>
class RenderItemMerge : public RenderItemMergeFunction {
protected:
/// Override to create your own distance mergeFunction for your specified custom types.
virtual R3 * computeMerge(const R1 * r1, const R2 * r2, double ratio) const = 0;
public:
inline virtual R3 * operator()(const RenderItem * r1, const RenderItem * r2, double ratio) const {
if (supported(r1, r2))
return computeMerge(dynamic_cast<const R1*>(r1), dynamic_cast<const R2*>(r2), ratio);
else if (supported(r2,r1))
return computeMerge(dynamic_cast<const R1*>(r2), dynamic_cast<const R2*>(r1), ratio);
else
return 0;
}
/// Returns true if and only if r1 and r2 are of type R1 and R2 respectively.
inline bool supported(const RenderItem * r1, const RenderItem * r2) const {
return typeid(r1) == typeid(const R1 *) && typeid(r2) == typeid(const R2 *);
}
inline TypeIdPair typeIdPair() const {
return TypeIdPair(typeid(const R1*).name(), typeid(const R2*).name());
}
};
class ShapeMerge : public RenderItemMerge<Shape> {
public:
ShapeMerge() {}
virtual ~ShapeMerge() {}
protected:
virtual inline Shape * computeMerge(const Shape * lhs, const Shape * rhs, double ratio) const {
Shape * ret = new Shape();
Shape & target = *ret;
target.x = interpolate(lhs->x, rhs->x, ratio);
target.y = interpolate(lhs->y, rhs->y, ratio);
target.a = interpolate(lhs->a, rhs->a, ratio);
target.a2 = interpolate(lhs->a2, rhs->a2, ratio);
target.r = interpolate(lhs->r, rhs->r, ratio);
target.r2 = interpolate(lhs->r2, rhs->r2, ratio);
target.g = interpolate(lhs->g, rhs->g, ratio);
target.g2 = interpolate(lhs->g2, rhs->g2, ratio);
target.b = interpolate(lhs->b, rhs->b, ratio);
target.b2 = interpolate(lhs->b2, rhs->b2, ratio);
target.ang = interpolate(lhs->ang, rhs->ang, ratio);
target.radius = interpolate(lhs->radius, rhs->radius, ratio);
target.tex_ang = interpolate(lhs->tex_ang, rhs->tex_ang, ratio);
target.tex_zoom = interpolate(lhs->tex_zoom, rhs->tex_zoom, ratio);
target.border_a = interpolate(lhs->border_a, rhs->border_a, ratio);
target.border_r = interpolate(lhs->border_r, rhs->border_r, ratio);
target.border_g = interpolate(lhs->border_g, rhs->border_g, ratio);
target.border_b = interpolate(lhs->border_b, rhs->border_b, ratio);
target.sides = interpolate(lhs->sides, rhs->sides, ratio);
target.additive = interpolate(lhs->additive, rhs->additive, ratio);
target.textured = interpolate(lhs->textured, rhs->textured, ratio);
target.thickOutline = interpolate(lhs->thickOutline, rhs->thickOutline, ratio);
target.enabled = interpolate(lhs->enabled, rhs->enabled, ratio);
target.masterAlpha = interpolate(lhs->masterAlpha, rhs->masterAlpha, ratio);
target.imageUrl = (ratio > 0.5) ? lhs->imageUrl : rhs->imageUrl, ratio;
return ret;
}
};
class BorderMerge : public RenderItemMerge<Border> {
public:
BorderMerge() {}
virtual ~BorderMerge() {}
protected:
virtual inline Border * computeMerge(const Border * lhs, const Border * rhs, double ratio) const
{
Border * ret = new Border();
Border & target = *ret;
target.inner_a = interpolate(lhs->inner_a, rhs->inner_a, ratio);
target.inner_r = interpolate(lhs->inner_r, rhs->inner_r, ratio);
target.inner_g = interpolate(lhs->inner_g, rhs->inner_g, ratio);
target.inner_b = interpolate(lhs->inner_b, rhs->inner_b, ratio);
target.inner_size = interpolate(lhs->inner_size, rhs->inner_size, ratio);
target.outer_a = interpolate(lhs->outer_a, rhs->outer_a, ratio);
target.outer_r = interpolate(lhs->outer_r, rhs->outer_r, ratio);
target.outer_g = interpolate(lhs->outer_g, rhs->outer_g, ratio);
target.outer_b = interpolate(lhs->outer_b, rhs->outer_b, ratio);
target.outer_size = interpolate(lhs->outer_size, rhs->outer_size, ratio);
target.masterAlpha = interpolate(lhs->masterAlpha, rhs->masterAlpha, ratio);
return ret;
}
};
class WaveformMerge : public RenderItemMerge<Waveform> {
public:
WaveformMerge() {}
virtual ~WaveformMerge() {}
protected:
/// @BUG unimplemented
virtual inline Waveform * computeMerge(const Waveform * lhs, const Waveform * rhs, double ratio) const
{
return 0;
/*
Waveform * ret = new Waveform();
Waveform & target = *ret;
target.additive = interpolate(lhs->additive, rhs->additive, ratio);
target.dots = interpolate(lhs->dots, rhs->dots, ratio);
target.samples = (rhs->samples > lhs-> samples) ? lhs->samples : rhs->samples;
target.scaling = interpolate(lhs->scaling, rhs->scaling, ratio);
target.sep = interpolate(lhs->sep, rhs->sep, ratio);
target.smoothing = interpolate(lhs->smoothing, rhs->smoothing, ratio);
target.spectrum = interpolate(lhs->spectrum, rhs->spectrum, ratio);
target.thick = interpolate(lhs->thick, rhs->thick, ratio);
target.masterAlpha = interpolate(lhs->masterAlpha, rhs->masterAlpha, ratio);
return ret;
*/
}
};
/// Use as the top level merge function. It stores a map of all other
/// merge functions, using the function that fits best with the
/// incoming type parameters.
class MasterRenderItemMerge : public RenderItemMerge<RenderItem> {
typedef std::map<TypeIdPair, RenderItemMergeFunction*> MergeFunctionMap;
public:
MasterRenderItemMerge() {}
virtual ~MasterRenderItemMerge() {}
inline void add(RenderItemMergeFunction * fun) {
_mergeFunctionMap[fun->typeIdPair()] = fun;
}
protected:
virtual inline RenderItem * computeMerge(const RenderItem * lhs, const RenderItem * rhs, double ratio) const {
RenderItemMergeFunction * mergeFunction;
TypeIdPair pair(typeid(lhs), typeid(rhs));
if (_mergeFunctionMap.count(pair)) {
mergeFunction = _mergeFunctionMap[pair];
} else if (_mergeFunctionMap.count(pair = TypeIdPair(typeid(rhs), typeid(lhs)))) {
mergeFunction = _mergeFunctionMap[pair];
} else {
mergeFunction = 0;
}
// If specialized mergeFunction exists, use it to get higher granularity
// of correctness
if (mergeFunction)
return (*mergeFunction)(lhs, rhs, ratio);
else
return 0;
}
private:
mutable MergeFunctionMap _mergeFunctionMap;
};
#endif /* RenderItemMergeFunction_HPP_ */