sij/mapnik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix all files

Browse source 
format files
This commit is contained in:
Mathis Logemann 2022-08-11 22:54:50 +02:00
parent 88052447b9
commit eb16e7a647
214 changed files with 58865 additions and 58183 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

122
deps/agg/include/agg_alpha_mask_u8.h vendored
View file

@ -23,23 +23,18 @@
#include "agg_basics.h"
#include "agg_rendering_buffer.h"
namespace agg
{
namespace agg {
//===================================================one_component_mask_u8
struct one_component_mask_u8
{
static unsigned calculate(const int8u* p) { return *p; }
};
//=====================================================rgb_to_gray_mask_u8
template<unsigned R, unsigned G, unsigned B>
struct rgb_to_gray_mask_u8
{
static unsigned calculate(const int8u* p)
{
return (p[R]*77 + p[G]*150 + p[B]*29) >> 8;
}
static unsigned calculate(const int8u* p) { return (p[R] * 77 + p[G] * 150 + p[B] * 29) >> 8; }
};
//==========================================================alpha_mask_u8
@ -49,31 +44,26 @@ namespace agg
public:
typedef int8u cover_type;
typedef alpha_mask_u8<Step, Offset, MaskF> self_type;
enum cover_scale_e
{
cover_shift = 8,
cover_none = 0,
cover_full = 255
};
enum cover_scale_e { cover_shift = 8, cover_none = 0, cover_full = 255 };
alpha_mask_u8() : m_rbuf(0) {}
explicit alpha_mask_u8(rendering_buffer& rbuf) : m_rbuf(&rbuf) {}
alpha_mask_u8()
: m_rbuf(0)
{}
explicit alpha_mask_u8(rendering_buffer& rbuf)
: m_rbuf(&rbuf)
{}
void attach(rendering_buffer& rbuf) { m_rbuf = &rbuf; }
MaskF& mask_function() { return m_mask_function; }
const MaskF& mask_function() const { return m_mask_function; }
//--------------------------------------------------------------------
cover_type pixel(int x, int y) const
{
if(x >= 0 && y >= 0 &&
x < (int)m_rbuf->width() &&
y < (int)m_rbuf->height())
if (x >= 0 && y >= 0 && x < (int)m_rbuf->width() && y < (int)m_rbuf->height())
{
return (cover_type)m_mask_function.calculate(
m_rbuf->row_ptr(y) + x * Step + Offset);
return (cover_type)m_mask_function.calculate(m_rbuf->row_ptr(y) + x * Step + Offset);
}
return 0;
}
@ -81,19 +71,15 @@ namespace agg
//--------------------------------------------------------------------
cover_type combine_pixel(int x, int y, cover_type val) const
{
if(x >= 0 && y >= 0 &&
x < (int)m_rbuf->width() &&
y < (int)m_rbuf->height())
if (x >= 0 && y >= 0 && x < (int)m_rbuf->width() && y < (int)m_rbuf->height())
{
return (cover_type)((cover_full + val *
m_mask_function.calculate(
m_rbuf->row_ptr(y) + x * Step + Offset)) >>
return (
cover_type)((cover_full + val * m_mask_function.calculate(m_rbuf->row_ptr(y) + x * Step + Offset)) >>
cover_shift);
}
return 0;
}
//--------------------------------------------------------------------
void fill_hspan(int x, int y, cover_type* dst, int num_pix) const
{
@ -139,10 +125,8 @@ namespace agg
{
*covers++ = (cover_type)m_mask_function.calculate(mask);
mask += Step;
} while (--count);
}
while(--count);
}
//--------------------------------------------------------------------
void combine_hspan(int x, int y, cover_type* dst, int num_pix) const
@ -187,13 +171,10 @@ namespace agg
const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
do
{
*covers = (cover_type)((cover_full + (*covers) *
m_mask_function.calculate(mask)) >>
cover_shift);
*covers = (cover_type)((cover_full + (*covers) * m_mask_function.calculate(mask)) >> cover_shift);
++covers;
mask += Step;
}
while(--count);
} while (--count);
}
//--------------------------------------------------------------------
@ -241,8 +222,7 @@ namespace agg
{
*covers++ = (cover_type)m_mask_function.calculate(mask);
mask += m_rbuf->stride();
}
while(--count);
} while (--count);
}
//--------------------------------------------------------------------
@ -288,15 +268,11 @@ namespace agg
const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
do
{
*covers = (cover_type)((cover_full + (*covers) *
m_mask_function.calculate(mask)) >>
cover_shift);
*covers = (cover_type)((cover_full + (*covers) * m_mask_function.calculate(mask)) >> cover_shift);
++covers;
mask += m_rbuf->stride();
} while (--count);
}
while(--count);
}
private:
alpha_mask_u8(const self_type&);
@ -306,7 +282,6 @@ namespace agg
MaskF m_mask_function;
};
typedef alpha_mask_u8<1, 0> alpha_mask_gray8; //----alpha_mask_gray8
typedef alpha_mask_u8<3, 0> alpha_mask_rgb24r; //----alpha_mask_rgb24r
@ -344,8 +319,6 @@ namespace agg
typedef alpha_mask_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0>> alpha_mask_bgra32gray; //----alpha_mask_bgra32gray
typedef alpha_mask_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0>> alpha_mask_abgr32gray; //----alpha_mask_abgr32gray
//==========================================================amask_no_clip_u8
template<unsigned Step = 1, unsigned Offset = 0, class MaskF = one_component_mask_u8>
class amask_no_clip_u8
@ -353,40 +326,33 @@ namespace agg
public:
typedef int8u cover_type;
typedef amask_no_clip_u8<Step, Offset, MaskF> self_type;
enum cover_scale_e
{
cover_shift = 8,
cover_none = 0,
cover_full = 255
};
enum cover_scale_e { cover_shift = 8, cover_none = 0, cover_full = 255 };
amask_no_clip_u8() : m_rbuf(0) {}
explicit amask_no_clip_u8(rendering_buffer& rbuf) : m_rbuf(&rbuf) {}
amask_no_clip_u8()
: m_rbuf(0)
{}
explicit amask_no_clip_u8(rendering_buffer& rbuf)
: m_rbuf(&rbuf)
{}
void attach(rendering_buffer& rbuf) { m_rbuf = &rbuf; }
MaskF& mask_function() { return m_mask_function; }
const MaskF& mask_function() const { return m_mask_function; }
//--------------------------------------------------------------------
cover_type pixel(int x, int y) const
{
return (cover_type)m_mask_function.calculate(
m_rbuf->row_ptr(y) + x * Step + Offset);
return (cover_type)m_mask_function.calculate(m_rbuf->row_ptr(y) + x * Step + Offset);
}
//--------------------------------------------------------------------
cover_type combine_pixel(int x, int y, cover_type val) const
{
return (cover_type)((cover_full + val *
m_mask_function.calculate(
m_rbuf->row_ptr(y) + x * Step + Offset)) >>
return (cover_type)((cover_full + val * m_mask_function.calculate(m_rbuf->row_ptr(y) + x * Step + Offset)) >>
cover_shift);
}
//--------------------------------------------------------------------
void fill_hspan(int x, int y, cover_type* dst, int num_pix) const
{
@ -395,11 +361,8 @@ namespace agg
{
*dst++ = (cover_type)m_mask_function.calculate(mask);
mask += Step;
} while (--num_pix);
}
while(--num_pix);
}
//--------------------------------------------------------------------
void combine_hspan(int x, int y, cover_type* dst, int num_pix) const
@ -407,15 +370,11 @@ namespace agg
const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
do
{
*dst = (cover_type)((cover_full + (*dst) *
m_mask_function.calculate(mask)) >>
cover_shift);
*dst = (cover_type)((cover_full + (*dst) * m_mask_function.calculate(mask)) >> cover_shift);
++dst;
mask += Step;
} while (--num_pix);
}
while(--num_pix);
}
//--------------------------------------------------------------------
void fill_vspan(int x, int y, cover_type* dst, int num_pix) const
@ -425,10 +384,8 @@ namespace agg
{
*dst++ = (cover_type)m_mask_function.calculate(mask);
mask += m_rbuf->stride();
} while (--num_pix);
}
while(--num_pix);
}
//--------------------------------------------------------------------
void combine_vspan(int x, int y, cover_type* dst, int num_pix) const
@ -436,13 +393,10 @@ namespace agg
const int8u* mask = m_rbuf->row_ptr(y) + x * Step + Offset;
do
{
*dst = (cover_type)((cover_full + (*dst) *
m_mask_function.calculate(mask)) >>
cover_shift);
*dst = (cover_type)((cover_full + (*dst) * m_mask_function.calculate(mask)) >> cover_shift);
++dst;
mask += m_rbuf->stride();
}
while(--num_pix);
} while (--num_pix);
}
private:
@ -453,7 +407,6 @@ namespace agg
MaskF m_mask_function;
};
typedef amask_no_clip_u8<1, 0> amask_no_clip_gray8; //----amask_no_clip_gray8
typedef amask_no_clip_u8<3, 0> amask_no_clip_rgb24r; //----amask_no_clip_rgb24r
@ -491,9 +444,6 @@ namespace agg
typedef amask_no_clip_u8<4, 0, rgb_to_gray_mask_u8<2, 1, 0>> amask_no_clip_bgra32gray; //----amask_no_clip_bgra32gray
typedef amask_no_clip_u8<4, 1, rgb_to_gray_mask_u8<2, 1, 0>> amask_no_clip_abgr32gray; //----amask_no_clip_abgr32gray
}
} // namespace agg
#endif

22
deps/agg/include/agg_arc.h vendored
View file

@ -23,8 +23,7 @@
#include <cmath>
#include "agg_basics.h"
namespace agg
{
namespace agg {
//=====================================================================arc
//
@ -33,16 +32,13 @@ namespace agg
class arc
{
public:
arc() : m_scale(1.0), m_initialized(false) {}
arc(double x, double y,
double rx, double ry,
double a1, double a2,
bool ccw=true);
arc()
: m_scale(1.0)
, m_initialized(false)
{}
arc(double x, double y, double rx, double ry, double a1, double a2, bool ccw = true);
void init(double x, double y,
double rx, double ry,
double a1, double a2,
bool ccw=true);
void init(double x, double y, double rx, double ry, double a1, double a2, bool ccw = true);
void approximation_scale(double s);
double approximation_scale() const { return m_scale; }
@ -67,8 +63,6 @@ namespace agg
unsigned m_path_cmd;
};
}
} // namespace agg
#endif

437
deps/agg/include/agg_array.h vendored
View file

@ -19,16 +19,18 @@
#include <cstring>
#include "agg_basics.h"
namespace agg
{
namespace agg {
//-------------------------------------------------------pod_array_adaptor
template<class T> class pod_array_adaptor
template<class T>
class pod_array_adaptor
{
public:
typedef T value_type;
pod_array_adaptor(T* array, unsigned _size) :
m_array(array), m_size(_size) {}
pod_array_adaptor(T* array, unsigned _size)
: m_array(array)
, m_size(_size)
{}
unsigned size() const { return m_size; }
const T& operator[](unsigned i) const { return m_array[i]; }
@ -42,19 +44,16 @@ namespace agg
unsigned m_size;
};
//---------------------------------------------------------pod_auto_array
template<class T, unsigned Size> class pod_auto_array
template<class T, unsigned Size>
class pod_auto_array
{
public:
typedef T value_type;
typedef pod_auto_array<T, Size> self_type;
pod_auto_array() {}
explicit pod_auto_array(const T* c)
{
memcpy(m_array, c, sizeof(T) * Size);
}
explicit pod_auto_array(const T* c) { memcpy(m_array, c, sizeof(T) * Size); }
const self_type& operator=(const T* c)
{
@ -73,15 +72,17 @@ namespace agg
T m_array[Size];
};
//--------------------------------------------------------pod_auto_vector
template<class T, unsigned Size> class pod_auto_vector
template<class T, unsigned Size>
class pod_auto_vector
{
public:
typedef T value_type;
typedef pod_auto_vector<T, Size> self_type;
pod_auto_vector() : m_size(0) {}
pod_auto_vector()
: m_size(0)
{}
void remove_all() { m_size = 0; }
void clear() { m_size = 0; }
@ -101,32 +102,35 @@ namespace agg
unsigned m_size;
};
//---------------------------------------------------------------pod_array
template<class T> class pod_array
template<class T>
class pod_array
{
public:
typedef T value_type;
typedef pod_array<T> self_type;
~pod_array() { pod_allocator<T>::deallocate(m_array, m_size); }
pod_array() : m_array(0), m_size(0) {}
pod_array(unsigned _size) :
m_array(pod_allocator<T>::allocate(_size)),
m_size(_size)
pod_array()
: m_array(0)
, m_size(0)
{}
pod_array(const self_type& v) :
m_array(pod_allocator<T>::allocate(v.m_size)),
m_size(v.m_size)
pod_array(unsigned _size)
: m_array(pod_allocator<T>::allocate(_size))
, m_size(_size)
{}
pod_array(const self_type& v)
: m_array(pod_allocator<T>::allocate(v.m_size))
, m_size(v.m_size)
{
memcpy(m_array, v.m_array, sizeof(T) * m_size);
}
pod_array(self_type && rhs) :
m_array(rhs.m_array),
m_size(rhs.m_size)
pod_array(self_type&& rhs)
: m_array(rhs.m_array)
, m_size(rhs.m_size)
{
rhs.m_array = nullptr;
rhs.m_size = 0;
@ -156,24 +160,28 @@ namespace agg
const T* data() const { return m_array; }
T* data() { return m_array; }
private:
T* m_array;
unsigned m_size;
};
//--------------------------------------------------------------pod_vector
// A simple class template to store Plain Old Data, a vector
// of a fixed size. The data is continous in memory
//------------------------------------------------------------------------
template<class T> class pod_vector
template<class T>
class pod_vector
{
public:
typedef T value_type;
~pod_vector() { pod_allocator<T>::deallocate(m_array, m_capacity); }
pod_vector() : m_size(0), m_capacity(0), m_array(0) {}
pod_vector()
: m_size(0)
, m_capacity(0)
, m_array(0)
{}
pod_vector(unsigned cap, unsigned extra_tail = 0);
// Copying
@ -193,10 +201,7 @@ namespace agg
// Resize keeping the content.
void resize(unsigned new_size);
void zero()
{
memset(m_array, 0, sizeof(T) * m_size);
}
void zero() { memset(m_array, 0, sizeof(T) * m_size); }
void add(const T& v) { m_array[m_size++] = v; }
void push_back(const T& v) { m_array[m_size++] = v; }
@ -217,7 +222,11 @@ namespace agg
void remove_all() { m_size = 0; }
void clear() { m_size = 0; }
void cut_at(unsigned num) { if(num < m_size) m_size = num; }
void cut_at(unsigned num)
{
if (num < m_size)
m_size = num;
}
private:
unsigned m_size;
@ -246,7 +255,6 @@ namespace agg
m_size = _size;
}
//------------------------------------------------------------------------
template<class T>
void pod_vector<T>::resize(unsigned new_size)
@ -268,25 +276,29 @@ namespace agg
}
//------------------------------------------------------------------------
template<class T> pod_vector<T>::pod_vector(unsigned cap, unsigned extra_tail) :
m_size(0),
m_capacity(cap + extra_tail),
m_array(pod_allocator<T>::allocate(m_capacity)) {}
template<class T>
pod_vector<T>::pod_vector(unsigned cap, unsigned extra_tail)
: m_size(0)
, m_capacity(cap + extra_tail)
, m_array(pod_allocator<T>::allocate(m_capacity))
{}
//------------------------------------------------------------------------
template<class T> pod_vector<T>::pod_vector(const pod_vector<T>& v) :
m_size(v.m_size),
m_capacity(v.m_capacity),
m_array(v.m_capacity ? pod_allocator<T>::allocate(v.m_capacity) : 0)
template<class T>
pod_vector<T>::pod_vector(const pod_vector<T>& v)
: m_size(v.m_size)
, m_capacity(v.m_capacity)
, m_array(v.m_capacity ? pod_allocator<T>::allocate(v.m_capacity) : 0)
{
memcpy(m_array, v.m_array, sizeof(T) * v.m_size);
}
//------------------------------------------------------------------------
template<class T> pod_vector<T>::pod_vector(pod_vector<T> && rhs) :
m_size(rhs.m_size),
m_capacity(rhs.m_capacity),
m_array(rhs.m_array)
template<class T>
pod_vector<T>::pod_vector(pod_vector<T>&& rhs)
: m_size(rhs.m_size)
, m_capacity(rhs.m_capacity)
, m_array(rhs.m_array)
{
rhs.m_size = 0;
rhs.m_capacity = 0;
@ -294,18 +306,21 @@ namespace agg
}
//------------------------------------------------------------------------
template<class T> const pod_vector<T>&
pod_vector<T>::operator = (const pod_vector<T>&v)
template<class T>
const pod_vector<T>& pod_vector<T>::operator=(const pod_vector<T>& v)
{
allocate(v.m_size);
if(v.m_size) memcpy(m_array, v.m_array, sizeof(T) * v.m_size);
if (v.m_size)
memcpy(m_array, v.m_array, sizeof(T) * v.m_size);
return *this;
}
//------------------------------------------------------------------------
template<class T> void pod_vector<T>::serialize(int8u* ptr) const
template<class T>
void pod_vector<T>::serialize(int8u* ptr) const
{
if(m_size) memcpy(ptr, m_array, m_size * sizeof(T));
if (m_size)
memcpy(ptr, m_array, m_size * sizeof(T));
}
//------------------------------------------------------------------------
@ -314,7 +329,8 @@ namespace agg
{
_byte_size /= sizeof(T);
allocate(_byte_size);
if(_byte_size) memcpy(m_array, _data, _byte_size * sizeof(T));
if (_byte_size)
memcpy(m_array, _data, _byte_size * sizeof(T));
}
//------------------------------------------------------------------------
@ -344,15 +360,11 @@ namespace agg
// of increment to reallocate the pointer buffer. See the second constructor.
// By default, the incremeent value equals (1 << S), i.e., the block size.
//------------------------------------------------------------------------
template<class T, unsigned S=6> class pod_bvector
template<class T, unsigned S = 6>
class pod_bvector
{
public:
enum block_scale_e
{
block_shift = S,
block_size = 1 << block_shift,
block_mask = block_size - 1
};
enum block_scale_e { block_shift = S, block_size = 1 << block_shift, block_mask = block_size - 1 };
typedef T value_type;
@ -383,7 +395,8 @@ namespace agg
}
}
template<class DataAccessor> void add_data(DataAccessor& data)
template<class DataAccessor>
void add_data(DataAccessor& data)
{
while (data.size())
{
@ -394,81 +407,42 @@ namespace agg
void cut_at(unsigned _size)
{
if(_size < m_size) m_size = _size;
if (_size < m_size)
m_size = _size;
}
unsigned size() const { return m_size; }
const T& operator [] (unsigned i) const
{
return m_blocks[i >> block_shift][i & block_mask];
}
const T& operator[](unsigned i) const { return m_blocks[i >> block_shift][i & block_mask]; }
T& operator [] (unsigned i)
{
return m_blocks[i >> block_shift][i & block_mask];
}
T& operator[](unsigned i) { return m_blocks[i >> block_shift][i & block_mask]; }
const T& at(unsigned i) const
{
return m_blocks[i >> block_shift][i & block_mask];
}
const T& at(unsigned i) const { return m_blocks[i >> block_shift][i & block_mask]; }
T& at(unsigned i)
{
return m_blocks[i >> block_shift][i & block_mask];
}
T& at(unsigned i) { return m_blocks[i >> block_shift][i & block_mask]; }
T value_at(unsigned i) const
{
return m_blocks[i >> block_shift][i & block_mask];
}
T value_at(unsigned i) const { return m_blocks[i >> block_shift][i & block_mask]; }
const T& curr(unsigned idx) const
{
return (*this)[idx];
}
const T& curr(unsigned idx) const { return (*this)[idx]; }
T& curr(unsigned idx)
{
return (*this)[idx];
}
T& curr(unsigned idx) { return (*this)[idx]; }
const T& prev(unsigned idx) const
{
return (*this)[(idx + m_size - 1) % m_size];
}
const T& prev(unsigned idx) const { return (*this)[(idx + m_size - 1) % m_size]; }
T& prev(unsigned idx)
{
return (*this)[(idx + m_size - 1) % m_size];
}
T& prev(unsigned idx) { return (*this)[(idx + m_size - 1) % m_size]; }
const T& next(unsigned idx) const
{
return (*this)[(idx + 1) % m_size];
}
const T& next(unsigned idx) const { return (*this)[(idx + 1) % m_size]; }
T& next(unsigned idx)
{
return (*this)[(idx + 1) % m_size];
}
T& next(unsigned idx) { return (*this)[(idx + 1) % m_size]; }
const T& last() const
{
return (*this)[m_size - 1];
}
const T& last() const { return (*this)[m_size - 1]; }
T& last()
{
return (*this)[m_size - 1];
}
T& last() { return (*this)[m_size - 1]; }
unsigned byte_size() const;
void serialize(int8u* ptr) const;
void deserialize(const int8u* data, unsigned byte_size);
void deserialize(unsigned start, const T& empty_val,
const int8u* data, unsigned byte_size);
void deserialize(unsigned start, const T& empty_val, const int8u* data, unsigned byte_size);
template<class ByteAccessor>
void deserialize(ByteAccessor data)
@ -530,9 +504,9 @@ namespace agg
unsigned m_block_ptr_inc;
};
//------------------------------------------------------------------------
template<class T, unsigned S> pod_bvector<T, S>::~pod_bvector()
template<class T, unsigned S>
pod_bvector<T, S>::~pod_bvector()
{
if (m_num_blocks)
{
@ -547,7 +521,6 @@ namespace agg
pod_allocator<T*>::deallocate(m_blocks, m_max_blocks);
}
//------------------------------------------------------------------------
template<class T, unsigned S>
void pod_bvector<T, S>::free_tail(unsigned _size)
@ -569,40 +542,34 @@ namespace agg
}
}
//------------------------------------------------------------------------
template<class T, unsigned S> pod_bvector<T, S>::pod_bvector() :
m_size(0),
m_num_blocks(0),
m_max_blocks(0),
m_blocks(0),
m_block_ptr_inc(block_size)
{
}
template<class T, unsigned S>
pod_bvector<T, S>::pod_bvector()
: m_size(0)
, m_num_blocks(0)
, m_max_blocks(0)
, m_blocks(0)
, m_block_ptr_inc(block_size)
{}
//------------------------------------------------------------------------
template<class T, unsigned S>
pod_bvector<T, S>::pod_bvector(unsigned block_ptr_inc) :
m_size(0),
m_num_blocks(0),
m_max_blocks(0),
m_blocks(0),
m_block_ptr_inc(block_ptr_inc)
{
}
pod_bvector<T, S>::pod_bvector(unsigned block_ptr_inc)
: m_size(0)
, m_num_blocks(0)
, m_max_blocks(0)
, m_blocks(0)
, m_block_ptr_inc(block_ptr_inc)
{}
//------------------------------------------------------------------------
template<class T, unsigned S>
pod_bvector<T, S>::pod_bvector(const pod_bvector<T, S>& v) :
m_size(v.m_size),
m_num_blocks(v.m_num_blocks),
m_max_blocks(v.m_max_blocks),
m_blocks(v.m_max_blocks ?
pod_allocator<T*>::allocate(v.m_max_blocks) :
0),
m_block_ptr_inc(v.m_block_ptr_inc)
pod_bvector<T, S>::pod_bvector(const pod_bvector<T, S>& v)
: m_size(v.m_size)
, m_num_blocks(v.m_num_blocks)
, m_max_blocks(v.m_max_blocks)
, m_blocks(v.m_max_blocks ? pod_allocator<T*>::allocate(v.m_max_blocks) : 0)
, m_block_ptr_inc(v.m_block_ptr_inc)
{
unsigned i;
for (i = 0; i < v.m_num_blocks; ++i)
@ -612,11 +579,9 @@ namespace agg
}
}
//------------------------------------------------------------------------
template<class T, unsigned S>
const pod_bvector<T, S>&
pod_bvector<T, S>::operator = (const pod_bvector<T, S>& v)
const pod_bvector<T, S>& pod_bvector<T, S>::operator=(const pod_bvector<T, S>& v)
{
unsigned i;
for (i = m_num_blocks; i < v.m_num_blocks; ++i)
@ -631,7 +596,6 @@ namespace agg
return *this;
}
//------------------------------------------------------------------------
template<class T, unsigned S>
void pod_bvector<T, S>::allocate_block(unsigned nb)
@ -642,9 +606,7 @@ namespace agg
if (m_blocks)
{
memcpy(new_blocks,
m_blocks,
m_num_blocks * sizeof(T*));
memcpy(new_blocks, m_blocks, m_num_blocks * sizeof(T*));
pod_allocator<T*>::deallocate(m_blocks, m_max_blocks);
}
@ -655,8 +617,6 @@ namespace agg
m_num_blocks++;
}
//------------------------------------------------------------------------
template<class T, unsigned S>
inline T* pod_bvector<T, S>::data_ptr()
@ -669,8 +629,6 @@ namespace agg
return m_blocks[nb] + (m_size & block_mask);
}
//------------------------------------------------------------------------
template<class T, unsigned S>
inline void pod_bvector<T, S>::add(const T& val)
@ -679,15 +637,14 @@ namespace agg
++m_size;
}
//------------------------------------------------------------------------
template<class T, unsigned S>
inline void pod_bvector<T, S>::remove_last()
{
if(m_size) --m_size;
if (m_size)
--m_size;
}
//------------------------------------------------------------------------
template<class T, unsigned S>
void pod_bvector<T, S>::modify_last(const T& val)
@ -696,7 +653,6 @@ namespace agg
add(val);
}
//------------------------------------------------------------------------
template<class T, unsigned S>
int pod_bvector<T, S>::allocate_continuous_block(unsigned num_elements)
@ -726,7 +682,6 @@ namespace agg
return -1; // Impossible to allocate
}
//------------------------------------------------------------------------
template<class T, unsigned S>
unsigned pod_bvector<T, S>::byte_size() const
@ -734,7 +689,6 @@ namespace agg
return m_size * sizeof(T);
}
//------------------------------------------------------------------------
template<class T, unsigned S>
void pod_bvector<T, S>::serialize(int8u* ptr) const
@ -762,12 +716,10 @@ namespace agg
}
}
// Replace or add a number of elements starting from "start" position
//------------------------------------------------------------------------
template<class T, unsigned S>
void pod_bvector<T, S>::deserialize(unsigned start, const T& empty_val,
const int8u* _data, unsigned _byte_size)
void pod_bvector<T, S>::deserialize(unsigned start, const T& empty_val, const int8u* _data, unsigned _byte_size)
{
while (m_size < start)
{
@ -791,7 +743,6 @@ namespace agg
}
}
//---------------------------------------------------------block_allocator
// Allocator for arbitrary POD data. Most usable in different cache
// systems for efficient memory allocations.
@ -828,33 +779,28 @@ namespace agg
m_rest = 0;
}
~block_allocator()
{
remove_all();
}
block_allocator(unsigned block_size, unsigned block_ptr_inc=256-8) :
m_block_size(block_size),
m_block_ptr_inc(block_ptr_inc),
m_num_blocks(0),
m_max_blocks(0),
m_blocks(0),
m_buf_ptr(0),
m_rest(0)
{
}
~block_allocator() { remove_all(); }
block_allocator(unsigned block_size, unsigned block_ptr_inc = 256 - 8)
: m_block_size(block_size)
, m_block_ptr_inc(block_ptr_inc)
, m_num_blocks(0)
, m_max_blocks(0)
, m_blocks(0)
, m_buf_ptr(0)
, m_rest(0)
{}
int8u* allocate(unsigned size, unsigned alignment = 1)
{
if(size == 0) return 0;
if (size == 0)
return 0;
if (size <= m_rest)
{
int8u* ptr = m_buf_ptr;
if (alignment > 1)
{
unsigned align =
(alignment - unsigned((size_t)ptr) % alignment) % alignment;
unsigned align = (alignment - unsigned((size_t)ptr) % alignment) % alignment;
size += align;
ptr += align;
@ -875,21 +821,18 @@ namespace agg
return allocate(size, alignment);
}
private:
void allocate_block(unsigned size)
{
if(size < m_block_size) size = m_block_size;
if (size < m_block_size)
size = m_block_size;
if (m_num_blocks >= m_max_blocks)
{
block_type* new_blocks =
pod_allocator<block_type>::allocate(m_max_blocks + m_block_ptr_inc);
block_type* new_blocks = pod_allocator<block_type>::allocate(m_max_blocks + m_block_ptr_inc);
if (m_blocks)
{
memcpy(new_blocks,
m_blocks,
m_num_blocks * sizeof(block_type));
memcpy(new_blocks, m_blocks, m_num_blocks * sizeof(block_type));
pod_allocator<block_type>::deallocate(m_blocks, m_max_blocks);
}
m_blocks = new_blocks;
@ -897,9 +840,7 @@ namespace agg
}
m_blocks[m_num_blocks].size = size;
m_blocks[m_num_blocks].data =
m_buf_ptr =
pod_allocator<int8u>::allocate(size);
m_blocks[m_num_blocks].data = m_buf_ptr = pod_allocator<int8u>::allocate(size);
m_num_blocks++;
m_rest = size;
@ -914,34 +855,24 @@ namespace agg
unsigned m_rest;
};
//------------------------------------------------------------------------
enum quick_sort_threshold_e
{
quick_sort_threshold = 9
};
enum quick_sort_threshold_e { quick_sort_threshold = 9 };
//-----------------------------------------------------------swap_elements
template<class T> inline void swap_elements(T& a, T& b)
template<class T>
inline void swap_elements(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
//--------------------------------------------------------------quick_sort
template<class Array, class Less>
void quick_sort(Array& arr, Less less)
{
if(arr.size() < 2) return;
if (arr.size() < 2)
return;
typename Array::value_type* e1;
typename Array::value_type* e2;
@ -971,20 +902,27 @@ namespace agg
// now ensure that *i <= *base <= *j
e1 = &(arr[j]);
e2 = &(arr[i]);
if(less(*e1, *e2)) swap_elements(*e1, *e2);
if (less(*e1, *e2))
swap_elements(*e1, *e2);
e1 = &(arr[base]);
e2 = &(arr[i]);
if(less(*e1, *e2)) swap_elements(*e1, *e2);
if (less(*e1, *e2))
swap_elements(*e1, *e2);
e1 = &(arr[j]);
e2 = &(arr[base]);
if(less(*e1, *e2)) swap_elements(*e1, *e2);
if (less(*e1, *e2))
swap_elements(*e1, *e2);
for (;;)
{
do i++; while( less(arr[i], arr[base]) );
do j--; while( less(arr[base], arr[j]) );
do
i++;
while (less(arr[i], arr[base]));
do
j--;
while (less(arr[base], arr[j]));
if (i > j)
{
@ -1042,9 +980,6 @@ namespace agg
}
}
//------------------------------------------------------remove_duplicates
// Remove duplicates from a sorted array. It doesn't cut the
// tail of the array, it just returns the number of remaining elements.
@ -1052,7 +987,8 @@ namespace agg
template<class Array, class Equal>
unsigned remove_duplicates(Array& arr, Equal equal)
{
if(arr.size() < 2) return arr.size();
if (arr.size() < 2)
return arr.size();
unsigned i, j;
for (i = 1, j = 1; i < arr.size(); i++)
@ -1067,7 +1003,8 @@ namespace agg
}
//--------------------------------------------------------invert_container
template<class Array> void invert_container(Array& arr)
template<class Array>
void invert_container(Array& arr)
{
int i = 0;
int j = arr.size() - 1;
@ -1081,19 +1018,24 @@ namespace agg
template<class Array, class Value, class Less>
unsigned binary_search_pos(const Array& arr, const Value& val, Less less)
{
if(arr.size() == 0) return 0;
if (arr.size() == 0)
return 0;
unsigned beg = 0;
unsigned end = arr.size() - 1;
if(less(val, arr[0])) return 0;
if(less(arr[end], val)) return end + 1;
if (less(val, arr[0]))
return 0;
if (less(arr[end], val))
return end + 1;
while (end - beg > 1)
{
unsigned mid = (end + beg) >> 1;
if(less(val, arr[mid])) end = mid;
else beg = mid;
if (less(val, arr[mid]))
end = mid;
else
beg = mid;
}
// if(beg <= 0 && less(val, arr[0])) return 0;
@ -1103,13 +1045,16 @@ namespace agg
}
//----------------------------------------------------------range_adaptor
template<class Array> class range_adaptor
template<class Array>
class range_adaptor
{
public:
typedef typename Array::value_type value_type;
range_adaptor(Array& array, unsigned start, unsigned _size) :
m_array(array), m_start(start), m_size(_size)
range_adaptor(Array& array, unsigned start, unsigned _size)
: m_array(array)
, m_start(start)
, m_size(_size)
{}
unsigned size() const { return m_size; }
@ -1126,16 +1071,28 @@ namespace agg
};
//---------------------------------------------------------------int_less
inline bool int_less(int a, int b) { return a < b; }
//------------------------------------------------------------int_greater
inline bool int_greater(int a, int b) { return a > b; }
//----------------------------------------------------------unsigned_less
inline bool unsigned_less(unsigned a, unsigned b) { return a < b; }
//-------------------------------------------------------unsigned_greater
inline bool unsigned_greater(unsigned a, unsigned b) { return a > b; }
inline bool int_less(int a, int b)
{
return a < b;
}
//------------------------------------------------------------int_greater
inline bool int_greater(int a, int b)
{
return a > b;
}
//----------------------------------------------------------unsigned_less
inline bool unsigned_less(unsigned a, unsigned b)
{
return a < b;
}
//-------------------------------------------------------unsigned_greater
inline bool unsigned_greater(unsigned a, unsigned b)
{
return a > b;
}
} // namespace agg
#endif

5
deps/agg/include/agg_arrowhead.h vendored
View file

@ -21,8 +21,7 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//===============================================================arrowhead
//
@ -77,6 +76,6 @@ namespace agg
unsigned m_curr_coord;
};
}
} // namespace agg
#endif

164
deps/agg/include/agg_basics.h vendored
View file

@ -23,8 +23,7 @@
#ifdef AGG_CUSTOM_ALLOCATOR
#include "agg_allocator.h"
#else
namespace agg
{
namespace agg {
// The policy of all AGG containers and memory allocation strategy
// in general is that no allocated data requires explicit construction.
// It means that the allocator can be really simple; you can even
@ -33,7 +32,8 @@ namespace agg
// The second argument of deallocate() is the size of the allocated
// block. You can use this information if you wish.
//------------------------------------------------------------pod_allocator
template<class T> struct pod_allocator
template<class T>
struct pod_allocator
{
// static T* allocate(unsigned num) { return static_cast<T*>(::operator new(sizeof(T)*num));}
// static void deallocate(T* ptr, unsigned) { ::operator delete(ptr) ;}
@ -49,15 +49,15 @@ namespace agg
// replace these new/delete to malloc/free make sure that the in-place
// new is called and take care of calling the destructor too.
//------------------------------------------------------------obj_allocator
template<class T> struct obj_allocator
template<class T>
struct obj_allocator
{
static T* allocate() { return new T; }
static void deallocate(T* ptr) { delete ptr; }
};
}
} // namespace agg
#endif
//-------------------------------------------------------- Default basic types
//
// If the compiler has different capacity of the basic types you can redefine
@ -107,8 +107,7 @@ namespace agg
#define AGG_INLINE inline
#endif
namespace agg
{
namespace agg {
//-------------------------------------------------------------------------
typedef AGG_INT8 int8; //----int8
typedef AGG_INT8U int8u; //----int8u
@ -137,18 +136,22 @@ namespace agg
}
//---------------------------------------------------------------saturation
template<int Limit> struct saturation
template<int Limit>
struct saturation
{
AGG_INLINE static int iround(double v)
{
if(v < double(-Limit)) return -Limit;
if(v > double( Limit)) return Limit;
if (v < double(-Limit))
return -Limit;
if (v > double(Limit))
return Limit;
return agg::iround(v);
}
};
//------------------------------------------------------------------mul_one
template<unsigned Shift> struct mul_one
template<unsigned Shift>
struct mul_one
{
AGG_INLINE static unsigned mul(unsigned a, unsigned b)
{
@ -159,8 +162,7 @@ namespace agg
//-------------------------------------------------------------------------
typedef unsigned char cover_type; //----cover_type
enum cover_scale_e
{
enum cover_scale_e {
cover_shift = 8, //----cover_shift
cover_size = 1 << cover_shift, //----cover_size
cover_mask = cover_size - 1, //----cover_mask
@ -174,19 +176,14 @@ namespace agg
// The possible coordinate capacity in bits can be calculated by formula:
// sizeof(int) * 8 - poly_subpixel_shift, i.e, for 32-bit integers and
// 8-bits fractional part the capacity is 24 bits.
enum poly_subpixel_scale_e
{
enum poly_subpixel_scale_e {
poly_subpixel_shift = 8, //----poly_subpixel_shift
poly_subpixel_scale = 1 << poly_subpixel_shift, //----poly_subpixel_scale
poly_subpixel_mask = poly_subpixel_scale - 1 //----poly_subpixel_mask
};
//----------------------------------------------------------filling_rule_e
enum filling_rule_e
{
fill_non_zero,
fill_even_odd
};
enum filling_rule_e { fill_non_zero, fill_even_odd };
//-----------------------------------------------------------------------pi
const double pi = 3.14159265358979323846;
@ -204,47 +201,63 @@ namespace agg
}
//----------------------------------------------------------------rect_base
template<class T> struct rect_base
template<class T>
struct rect_base
{
typedef T value_type;
typedef rect_base<T> self_type;
T x1, y1, x2, y2;
rect_base() {}
rect_base(T x1_, T y1_, T x2_, T y2_) :
x1(x1_), y1(y1_), x2(x2_), y2(y2_) {}
rect_base(T x1_, T y1_, T x2_, T y2_)
: x1(x1_)
, y1(y1_)
, x2(x2_)
, y2(y2_)
{}
void init(T x1_, T y1_, T x2_, T y2_)
{
x1 = x1_; y1 = y1_; x2 = x2_; y2 = y2_;
x1 = x1_;
y1 = y1_;
x2 = x2_;
y2 = y2_;
}
const self_type& normalize()
{
T t;
if(x1 > x2) { t = x1; x1 = x2; x2 = t; }
if(y1 > y2) { t = y1; y1 = y2; y2 = t; }
if (x1 > x2)
{
t = x1;
x1 = x2;
x2 = t;
}
if (y1 > y2)
{
t = y1;
y1 = y2;
y2 = t;
}
return *this;
}
bool clip(const self_type& r)
{
if(x2 > r.x2) x2 = r.x2;
if(y2 > r.y2) y2 = r.y2;
if(x1 < r.x1) x1 = r.x1;
if(y1 < r.y1) y1 = r.y1;
if (x2 > r.x2)
x2 = r.x2;
if (y2 > r.y2)
y2 = r.y2;
if (x1 < r.x1)
x1 = r.x1;
if (y1 < r.y1)
y1 = r.y1;
return x1 <= x2 && y1 <= y2;
}
bool is_valid() const
{
return x1 <= x2 && y1 <= y2;
}
bool is_valid() const { return x1 <= x2 && y1 <= y2; }
bool hit_test(T x, T y) const
{
return (x >= x1 && x <= x2 && y >= y1 && y <= y2);
}
bool hit_test(T x, T y) const { return (x >= x1 && x <= x2 && y >= y1 && y <= y2); }
};
//-----------------------------------------------------intersect_rectangles
@ -258,23 +271,30 @@ namespace agg
// Microsoft Visual C++ .NET 2003 69462-335-0000007-18038 in
// case of "Maximize Speed" optimization option.
//-----------------
if(r.x2 > r2.x2) r.x2 = r2.x2;
if(r.y2 > r2.y2) r.y2 = r2.y2;
if(r.x1 < r2.x1) r.x1 = r2.x1;
if(r.y1 < r2.y1) r.y1 = r2.y1;
if (r.x2 > r2.x2)
r.x2 = r2.x2;
if (r.y2 > r2.y2)
r.y2 = r2.y2;
if (r.x1 < r2.x1)
r.x1 = r2.x1;
if (r.y1 < r2.y1)
r.y1 = r2.y1;
return r;
}
//---------------------------------------------------------unite_rectangles
template<class Rect>
inline Rect unite_rectangles(const Rect& r1, const Rect& r2)
{
Rect r = r1;
if(r.x2 < r2.x2) r.x2 = r2.x2;
if(r.y2 < r2.y2) r.y2 = r2.y2;
if(r.x1 > r2.x1) r.x1 = r2.x1;
if(r.y1 > r2.y1) r.y1 = r2.y1;
if (r.x2 < r2.x2)
r.x2 = r2.x2;
if (r.y2 < r2.y2)
r.y2 = r2.y2;
if (r.x1 > r2.x1)
r.x1 = r2.x1;
if (r.y1 > r2.y1)
r.y1 = r2.y1;
return r;
}
@ -283,8 +303,7 @@ namespace agg
typedef rect_base<double> rect_d; //----rect_d
//---------------------------------------------------------path_commands_e
enum path_commands_e
{
enum path_commands_e {
path_cmd_stop = 0, //----path_cmd_stop
path_cmd_move_to = 1, //----path_cmd_move_to
path_cmd_line_to = 2, //----path_cmd_line_to
@ -298,8 +317,7 @@ namespace agg
};
//------------------------------------------------------------path_flags_e
enum path_flags_e
{
enum path_flags_e {
path_flags_none = 0, //----path_flags_none
path_flags_ccw = 0x10, //----path_flags_ccw
path_flags_cw = 0x20, //----path_flags_cw
@ -423,56 +441,74 @@ namespace agg
}
//--------------------------------------------------------------point_base
template<class T> struct point_base
template<class T>
struct point_base
{
typedef T value_type;
T x, y;
point_base() {}
point_base(T x_, T y_) : x(x_), y(y_) {}
point_base(T x_, T y_)
: x(x_)
, y(y_)
{}
};
typedef point_base<int> point_i; //-----point_i
typedef point_base<float> point_f; //-----point_f
typedef point_base<double> point_d; //-----point_d
//-------------------------------------------------------------vertex_base
template<class T> struct vertex_base
template<class T>
struct vertex_base
{
typedef T value_type;
T x, y;
unsigned cmd;
vertex_base() {}
vertex_base(T x_, T y_, unsigned cmd_) : x(x_), y(y_), cmd(cmd_) {}
vertex_base(T x_, T y_, unsigned cmd_)
: x(x_)
, y(y_)
, cmd(cmd_)
{}
};
typedef vertex_base<int> vertex_i; //-----vertex_i
typedef vertex_base<float> vertex_f; //-----vertex_f
typedef vertex_base<double> vertex_d; //-----vertex_d
//----------------------------------------------------------------row_info
template<class T> struct row_info
template<class T>
struct row_info
{
int x1, x2;
T* ptr;
row_info() {}
row_info(int x1_, int x2_, T* ptr_) : x1(x1_), x2(x2_), ptr(ptr_) {}
row_info(int x1_, int x2_, T* ptr_)
: x1(x1_)
, x2(x2_)
, ptr(ptr_)
{}
};
//----------------------------------------------------------const_row_info
template<class T> struct const_row_info
template<class T>
struct const_row_info
{
int x1, x2;
const T* ptr;
const_row_info() {}
const_row_info(int x1_, int x2_, const T* ptr_) :
x1(x1_), x2(x2_), ptr(ptr_) {}
const_row_info(int x1_, int x2_, const T* ptr_)
: x1(x1_)
, x2(x2_)
, ptr(ptr_)
{}
};
//------------------------------------------------------------is_equal_eps
template<class T> inline bool is_equal_eps(T v1, T v2, T epsilon)
template<class T>
inline bool is_equal_eps(T v1, T v2, T epsilon)
{
return std::fabs(v1 - v2) <= double(epsilon);
}
}
} // namespace agg
#endif

76
deps/agg/include/agg_bezier_arc.h vendored
View file

@ -23,14 +23,10 @@
#include "agg_conv_transform.h"
namespace agg
{
namespace agg {
//-----------------------------------------------------------------------
void arc_to_bezier(double cx, double cy, double rx, double ry,
double start_angle, double sweep_angle,
double* curve);
void arc_to_bezier(double cx, double cy, double rx, double ry, double start_angle, double sweep_angle, double* curve);
//==============================================================bezier_arc
//
@ -40,31 +36,27 @@ namespace agg
{
public:
//--------------------------------------------------------------------
bezier_arc() : m_vertex(26), m_num_vertices(0), m_cmd(path_cmd_line_to) {}
bezier_arc(double x, double y,
double rx, double ry,
double start_angle,
double sweep_angle)
bezier_arc()
: m_vertex(26)
, m_num_vertices(0)
, m_cmd(path_cmd_line_to)
{}
bezier_arc(double x, double y, double rx, double ry, double start_angle, double sweep_angle)
{
init(x, y, rx, ry, start_angle, sweep_angle);
}
//--------------------------------------------------------------------
void init(double x, double y,
double rx, double ry,
double start_angle,
double sweep_angle);
void init(double x, double y, double rx, double ry, double start_angle, double sweep_angle);
//--------------------------------------------------------------------
void rewind(unsigned)
{
m_vertex = 0;
}
void rewind(unsigned) { m_vertex = 0; }
//--------------------------------------------------------------------
unsigned vertex(double* x, double* y)
{
if(m_vertex >= m_num_vertices) return path_cmd_stop;
if (m_vertex >= m_num_vertices)
return path_cmd_stop;
*x = m_vertices[m_vertex];
*y = m_vertices[m_vertex + 1];
m_vertex += 2;
@ -85,8 +77,6 @@ namespace agg
unsigned m_cmd;
};
//==========================================================bezier_arc_svg
// Compute an SVG-style bezier arc.
//
@ -102,41 +92,45 @@ namespace agg
{
public:
//--------------------------------------------------------------------
bezier_arc_svg() : m_arc(), m_radii_ok(false) {}
bezier_arc_svg()
: m_arc()
, m_radii_ok(false)
{}
bezier_arc_svg(double x1, double y1,
double rx, double ry,
bezier_arc_svg(double x1,
double y1,
double rx,
double ry,
double angle,
bool large_arc_flag,
bool sweep_flag,
double x2, double y2) :
m_arc(), m_radii_ok(false)
double x2,
double y2)
: m_arc()
, m_radii_ok(false)
{
init(x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2);
}
//--------------------------------------------------------------------
void init(double x1, double y1,
double rx, double ry,
void init(double x1,
double y1,
double rx,
double ry,
double angle,
bool large_arc_flag,
bool sweep_flag,
double x2, double y2);
double x2,
double y2);
//--------------------------------------------------------------------
bool radii_ok() const { return m_radii_ok; }
//--------------------------------------------------------------------
void rewind(unsigned)
{
m_arc.rewind(0);
}
void rewind(unsigned) { m_arc.rewind(0); }
//--------------------------------------------------------------------
unsigned vertex(double* x, double* y)
{
return m_arc.vertex(x, y);
}
unsigned vertex(double* x, double* y) { return m_arc.vertex(x, y); }
// Supplemantary functions. num_vertices() actually returns doubled
// number of vertices. That is, for 1 vertex it returns 2.
@ -150,10 +144,6 @@ namespace agg
bool m_radii_ok;
};
}
} // namespace agg
#endif

16
deps/agg/include/agg_bitset_iterator.h vendored
View file

@ -18,15 +18,14 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
class bitset_iterator
{
public:
bitset_iterator(const int8u* bits, unsigned offset = 0) :
m_bits(bits + (offset >> 3)),
m_mask(0x80 >> (offset & 7))
bitset_iterator(const int8u* bits, unsigned offset = 0)
: m_bits(bits + (offset >> 3))
, m_mask(0x80 >> (offset & 7))
{}
void operator++()
@ -39,16 +38,13 @@ namespace agg
}
}
unsigned bit() const
{
return (*m_bits) & m_mask;
}
unsigned bit() const { return (*m_bits) & m_mask; }
private:
const int8u* m_bits;
int8u m_mask;
};
}
} // namespace agg
#endif

373
deps/agg/include/agg_blur.h vendored
View file

@ -30,10 +30,10 @@
#include "agg_array.h"
#include "agg_pixfmt_transposer.h"
namespace agg
{
namespace agg {
template<class T> struct stack_blur_tables
template<class T>
struct stack_blur_tables
{
static int16u const g_stack_blur8_mul[255];
static int8u const g_stack_blur8_shr[255];
@ -41,61 +41,47 @@ namespace agg
//------------------------------------------------------------------------
template<class T>
int16u const stack_blur_tables<T>::g_stack_blur8_mul[255] =
{
512,512,456,512,328,456,335,512,405,328,271,456,388,335,292,512,
454,405,364,328,298,271,496,456,420,388,360,335,312,292,273,512,
482,454,428,405,383,364,345,328,312,298,284,271,259,496,475,456,
437,420,404,388,374,360,347,335,323,312,302,292,282,273,265,512,
497,482,468,454,441,428,417,405,394,383,373,364,354,345,337,328,
320,312,305,298,291,284,278,271,265,259,507,496,485,475,465,456,
446,437,428,420,412,404,396,388,381,374,367,360,354,347,341,335,
329,323,318,312,307,302,297,292,287,282,278,273,269,265,261,512,
505,497,489,482,475,468,461,454,447,441,435,428,422,417,411,405,
399,394,389,383,378,373,368,364,359,354,350,345,341,337,332,328,
324,320,316,312,309,305,301,298,294,291,287,284,281,278,274,271,
268,265,262,259,257,507,501,496,491,485,480,475,470,465,460,456,
451,446,442,437,433,428,424,420,416,412,408,404,400,396,392,388,
385,381,377,374,370,367,363,360,357,354,350,347,344,341,338,335,
332,329,326,323,320,318,315,312,310,307,304,302,299,297,294,292,
289,287,285,282,280,278,275,273,271,269,267,265,263,261,259
};
int16u const stack_blur_tables<T>::g_stack_blur8_mul[255] = {
512, 512, 456, 512, 328, 456, 335, 512, 405, 328, 271, 456, 388, 335, 292, 512, 454, 405, 364, 328, 298, 271,
496, 456, 420, 388, 360, 335, 312, 292, 273, 512, 482, 454, 428, 405, 383, 364, 345, 328, 312, 298, 284, 271,
259, 496, 475, 456, 437, 420, 404, 388, 374, 360, 347, 335, 323, 312, 302, 292, 282, 273, 265, 512, 497, 482,
468, 454, 441, 428, 417, 405, 394, 383, 373, 364, 354, 345, 337, 328, 320, 312, 305, 298, 291, 284, 278, 271,
265, 259, 507, 496, 485, 475, 465, 456, 446, 437, 428, 420, 412, 404, 396, 388, 381, 374, 367, 360, 354, 347,
341, 335, 329, 323, 318, 312, 307, 302, 297, 292, 287, 282, 278, 273, 269, 265, 261, 512, 505, 497, 489, 482,
475, 468, 461, 454, 447, 441, 435, 428, 422, 417, 411, 405, 399, 394, 389, 383, 378, 373, 368, 364, 359, 354,
350, 345, 341, 337, 332, 328, 324, 320, 316, 312, 309, 305, 301, 298, 294, 291, 287, 284, 281, 278, 274, 271,
268, 265, 262, 259, 257, 507, 501, 496, 491, 485, 480, 475, 470, 465, 460, 456, 451, 446, 442, 437, 433, 428,
424, 420, 416, 412, 408, 404, 400, 396, 392, 388, 385, 381, 377, 374, 370, 367, 363, 360, 357, 354, 350, 347,
344, 341, 338, 335, 332, 329, 326, 323, 320, 318, 315, 312, 310, 307, 304, 302, 299, 297, 294, 292, 289, 287,
285, 282, 280, 278, 275, 273, 271, 269, 267, 265, 263, 261, 259};
//------------------------------------------------------------------------
template<class T>
int8u const stack_blur_tables<T>::g_stack_blur8_shr[255] =
{
9, 11, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17,
17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19,
19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20,
20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21,
21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22,
22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23,
23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24
};
int8u const stack_blur_tables<T>::g_stack_blur8_shr[255] = {
9, 11, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18,
18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24};
//==============================================================stack_blur
template<class ColorT, class CalculatorT> class stack_blur
template<class ColorT, class CalculatorT>
class stack_blur
{
public:
typedef ColorT color_type;
typedef CalculatorT calculator_type;
//--------------------------------------------------------------------
template<class Img> void blur_x(Img& img, unsigned radius)
template<class Img>
void blur_x(Img& img, unsigned radius)
{
if(radius < 1) return;
if (radius < 1)
return;
unsigned x, y, xp, i;
unsigned stack_ptr;
@ -150,19 +136,23 @@ namespace agg
stack_ptr = radius;
for (x = 0; x < w; x++)
{
if(mul_sum) sum.calc_pix(m_buf[x], mul_sum, shr_sum);
else sum.calc_pix(m_buf[x], div_sum);
if (mul_sum)
sum.calc_pix(m_buf[x], mul_sum, shr_sum);
else
sum.calc_pix(m_buf[x], div_sum);
sum.sub(sum_out);
stack_start = stack_ptr + div - radius;
if(stack_start >= div) stack_start -= div;
if (stack_start >= div)
stack_start -= div;
stack_pix = &m_stack[stack_start];
sum_out.sub(*stack_pix);
xp = x + radius + 1;
if(xp > wm) xp = wm;
if (xp > wm)
xp = wm;
pix = img.pixel(xp, y);
*stack_pix = pix;
@ -171,7 +161,8 @@ namespace agg
sum.add(sum_in);
++stack_ptr;
if(stack_ptr >= div) stack_ptr = 0;
if (stack_ptr >= div)
stack_ptr = 0;
stack_pix = &m_stack[stack_ptr];
sum_out.add(*stack_pix);
@ -182,14 +173,16 @@ namespace agg
}
//--------------------------------------------------------------------
template<class Img> void blur_y(Img& img, unsigned radius)
template<class Img>
void blur_y(Img& img, unsigned radius)
{
pixfmt_transposer<Img> img2(img);
blur_x(img2, radius);
}
//--------------------------------------------------------------------
template<class Img> void blur(Img& img, unsigned radius)
template<class Img>
void blur(Img& img, unsigned radius)
{
blur_x(img, radius);
pixfmt_transposer<Img> img2(img);
@ -202,17 +195,16 @@ namespace agg
};
//====================================================stack_blur_calc_rgba
template<class T=unsigned> struct stack_blur_calc_rgba
template<class T = unsigned>
struct stack_blur_calc_rgba
{
typedef T value_type;
value_type r, g, b, a;
AGG_INLINE void clear()
{
r = g = b = a = 0;
}
AGG_INLINE void clear() { r = g = b = a = 0; }
template<class ArgT> AGG_INLINE void add(const ArgT& v)
template<class ArgT>
AGG_INLINE void add(const ArgT& v)
{
r += v.r;
g += v.g;
@ -220,7 +212,8 @@ namespace agg
a += v.a;
}
template<class ArgT> AGG_INLINE void add(const ArgT& v, unsigned k)
template<class ArgT>
AGG_INLINE void add(const ArgT& v, unsigned k)
{
r += v.r * k;
g += v.g * k;
@ -228,7 +221,8 @@ namespace agg
a += v.a * k;
}
template<class ArgT> AGG_INLINE void sub(const ArgT& v)
template<class ArgT>
AGG_INLINE void sub(const ArgT& v)
{
r -= v.r;
g -= v.g;
@ -236,7 +230,8 @@ namespace agg
a -= v.a;
}
template<class ArgT> AGG_INLINE void calc_pix(ArgT& v, unsigned div)
template<class ArgT>
AGG_INLINE void calc_pix(ArgT& v, unsigned div)
{
typedef typename ArgT::value_type value_type;
v.r = value_type(r / div);
@ -256,40 +251,41 @@ namespace agg
}
};
//=====================================================stack_blur_calc_rgb
template<class T=unsigned> struct stack_blur_calc_rgb
template<class T = unsigned>
struct stack_blur_calc_rgb
{
typedef T value_type;
value_type r, g, b;
AGG_INLINE void clear()
{
r = g = b = 0;
}
AGG_INLINE void clear() { r = g = b = 0; }
template<class ArgT> AGG_INLINE void add(const ArgT& v)
template<class ArgT>
AGG_INLINE void add(const ArgT& v)
{
r += v.r;
g += v.g;
b += v.b;
}
template<class ArgT> AGG_INLINE void add(const ArgT& v, unsigned k)
template<class ArgT>
AGG_INLINE void add(const ArgT& v, unsigned k)
{
r += v.r * k;
g += v.g * k;
b += v.b * k;
}
template<class ArgT> AGG_INLINE void sub(const ArgT& v)
template<class ArgT>
AGG_INLINE void sub(const ArgT& v)
{
r -= v.r;
g -= v.g;
b -= v.b;
}
template<class ArgT> AGG_INLINE void calc_pix(ArgT& v, unsigned div)
template<class ArgT>
AGG_INLINE void calc_pix(ArgT& v, unsigned div)
{
typedef typename ArgT::value_type value_type;
v.r = value_type(r / div);
@ -307,34 +303,35 @@ namespace agg
}
};
//====================================================stack_blur_calc_gray
template<class T=unsigned> struct stack_blur_calc_gray
template<class T = unsigned>
struct stack_blur_calc_gray
{
typedef T value_type;
value_type v;
AGG_INLINE void clear()
{
v = 0;
}
AGG_INLINE void clear() { v = 0; }
template<class ArgT> AGG_INLINE void add(const ArgT& a)
template<class ArgT>
AGG_INLINE void add(const ArgT& a)
{
v += a.v;
}
template<class ArgT> AGG_INLINE void add(const ArgT& a, unsigned k)
template<class ArgT>
AGG_INLINE void add(const ArgT& a, unsigned k)
{
v += a.v * k;
}
template<class ArgT> AGG_INLINE void sub(const ArgT& a)
template<class ArgT>
AGG_INLINE void sub(const ArgT& a)
{
v -= a.v;
}
template<class ArgT> AGG_INLINE void calc_pix(ArgT& a, unsigned div)
template<class ArgT>
AGG_INLINE void calc_pix(ArgT& a, unsigned div)
{
typedef typename ArgT::value_type value_type;
a.v = value_type(v / div);
@ -348,8 +345,6 @@ namespace agg
}
};
//========================================================stack_blur_gray8
template<class Img>
void stack_blur_gray8(Img& img, unsigned rx, unsigned ry)
@ -379,7 +374,8 @@ namespace agg
if (rx > 0)
{
if(rx > 254) rx = 254;
if (rx > 254)
rx = 254;
div = rx * 2 + 1;
mul_sum = stack_blur_tables<int>::g_stack_blur8_mul[rx];
shr_sum = stack_blur_tables<int>::g_stack_blur8_shr[rx];
@ -399,7 +395,8 @@ namespace agg
}
for (i = 1; i <= rx; i++)
{
if(i <= wm) src_pix_ptr += Img::pix_step;
if (i <= wm)
src_pix_ptr += Img::pix_step;
pix = *src_pix_ptr;
stack[i + rx] = pix;
sum += pix * (rx + 1 - i);
@ -408,7 +405,8 @@ namespace agg
stack_ptr = rx;
xp = rx;
if(xp > wm) xp = wm;
if (xp > wm)
xp = wm;
src_pix_ptr = img.pix_ptr(xp, y);
dst_pix_ptr = img.pix_ptr(0, y);
for (x = 0; x < w; x++)
@ -419,7 +417,8 @@ namespace agg
sum -= sum_out;
stack_start = stack_ptr + div - rx;
if(stack_start >= div) stack_start -= div;
if (stack_start >= div)
stack_start -= div;
sum_out -= stack[stack_start];
if (xp < wm)
@ -435,7 +434,8 @@ namespace agg
sum += sum_in;
++stack_ptr;
if(stack_ptr >= div) stack_ptr = 0;
if (stack_ptr >= div)
stack_ptr = 0;
stack_pix = stack[stack_ptr];
sum_out += stack_pix;
@ -446,7 +446,8 @@ namespace agg
if (ry > 0)
{
if(ry > 254) ry = 254;
if (ry > 254)
ry = 254;
div = ry * 2 + 1;
mul_sum = stack_blur_tables<int>::g_stack_blur8_mul[ry];
shr_sum = stack_blur_tables<int>::g_stack_blur8_shr[ry];
@ -467,7 +468,8 @@ namespace agg
}
for (i = 1; i <= ry; i++)
{
if(i <= hm) src_pix_ptr += stride;
if (i <= hm)
src_pix_ptr += stride;
pix = *src_pix_ptr;
stack[i + ry] = pix;
sum += pix * (ry + 1 - i);
@ -476,7 +478,8 @@ namespace agg
stack_ptr = ry;
yp = ry;
if(yp > hm) yp = hm;
if (yp > hm)
yp = hm;
src_pix_ptr = img.pix_ptr(x, yp);
dst_pix_ptr = img.pix_ptr(x, 0);
for (y = 0; y < h; y++)
@ -487,7 +490,8 @@ namespace agg
sum -= sum_out;
stack_start = stack_ptr + div - ry;
if(stack_start >= div) stack_start -= div;
if (stack_start >= div)
stack_start -= div;
sum_out -= stack[stack_start];
if (yp < hm)
@ -503,7 +507,8 @@ namespace agg
sum += sum_in;
++stack_ptr;
if(stack_ptr >= div) stack_ptr = 0;
if (stack_ptr >= div)
stack_ptr = 0;
stack_pix = stack[stack_ptr];
sum_out += stack_pix;
@ -513,20 +518,13 @@ namespace agg
}
}
//========================================================stack_blur_rgb24
template<class Img>
void stack_blur_rgb24(Img& img, unsigned rx, unsigned ry)
{
typedef typename Img::color_type color_type;
typedef typename Img::order_type order_type;
enum order_e
{
R = order_type::R,
G = order_type::G,
B = order_type::B
};
enum order_e { R = order_type::R, G = order_type::G, B = order_type::B };
unsigned x, y, xp, yp, i;
unsigned stack_ptr;
@ -559,7 +557,8 @@ namespace agg
if (rx > 0)
{
if(rx > 254) rx = 254;
if (rx > 254)
rx = 254;
div = rx * 2 + 1;
mul_sum = stack_blur_tables<int>::g_stack_blur8_mul[rx];
shr_sum = stack_blur_tables<int>::g_stack_blur8_shr[rx];
@ -567,15 +566,7 @@ namespace agg
for (y = 0; y < h; y++)
{
sum_r =
sum_g =
sum_b =
sum_in_r =
sum_in_g =
sum_in_b =
sum_out_r =
sum_out_g =
sum_out_b = 0;
sum_r = sum_g = sum_b = sum_in_r = sum_in_g = sum_in_b = sum_out_r = sum_out_g = sum_out_b = 0;
src_pix_ptr = img.pix_ptr(0, y);
for (i = 0; i <= rx; i++)
@ -593,7 +584,8 @@ namespace agg
}
for (i = 1; i <= rx; i++)
{
if(i <= wm) src_pix_ptr += Img::pix_width;
if (i <= wm)
src_pix_ptr += Img::pix_width;
stack_pix_ptr = &stack[i + rx];
stack_pix_ptr->r = src_pix_ptr[R];
stack_pix_ptr->g = src_pix_ptr[G];
@ -608,7 +600,8 @@ namespace agg
stack_ptr = rx;
xp = rx;
if(xp > wm) xp = wm;
if (xp > wm)
xp = wm;
src_pix_ptr = img.pix_ptr(xp, y);
dst_pix_ptr = img.pix_ptr(0, y);
for (x = 0; x < w; x++)
@ -623,7 +616,8 @@ namespace agg
sum_b -= sum_out_b;
stack_start = stack_ptr + div - rx;
if(stack_start >= div) stack_start -= div;
if (stack_start >= div)
stack_start -= div;
stack_pix_ptr = &stack[stack_start];
sum_out_r -= stack_pix_ptr->r;
@ -648,7 +642,8 @@ namespace agg
sum_b += sum_in_b;
++stack_ptr;
if(stack_ptr >= div) stack_ptr = 0;
if (stack_ptr >= div)
stack_ptr = 0;
stack_pix_ptr = &stack[stack_ptr];
sum_out_r += stack_pix_ptr->r;
@ -663,7 +658,8 @@ namespace agg
if (ry > 0)
{
if(ry > 254) ry = 254;
if (ry > 254)
ry = 254;
div = ry * 2 + 1;
mul_sum = stack_blur_tables<int>::g_stack_blur8_mul[ry];
shr_sum = stack_blur_tables<int>::g_stack_blur8_shr[ry];
@ -672,15 +668,7 @@ namespace agg
int stride = img.stride();
for (x = 0; x < w; x++)
{
sum_r =
sum_g =
sum_b =
sum_in_r =
sum_in_g =
sum_in_b =
sum_out_r =
sum_out_g =
sum_out_b = 0;
sum_r = sum_g = sum_b = sum_in_r = sum_in_g = sum_in_b = sum_out_r = sum_out_g = sum_out_b = 0;
src_pix_ptr = img.pix_ptr(x, 0);
for (i = 0; i <= ry; i++)
@ -698,7 +686,8 @@ namespace agg
}
for (i = 1; i <= ry; i++)
{
if(i <= hm) src_pix_ptr += stride;
if (i <= hm)
src_pix_ptr += stride;
stack_pix_ptr = &stack[i + ry];
stack_pix_ptr->r = src_pix_ptr[R];
stack_pix_ptr->g = src_pix_ptr[G];
@ -713,7 +702,8 @@ namespace agg
stack_ptr = ry;
yp = ry;
if(yp > hm) yp = hm;
if (yp > hm)
yp = hm;
src_pix_ptr = img.pix_ptr(x, yp);
dst_pix_ptr = img.pix_ptr(x, 0);
for (y = 0; y < h; y++)
@ -728,7 +718,8 @@ namespace agg
sum_b -= sum_out_b;
stack_start = stack_ptr + div - ry;
if(stack_start >= div) stack_start -= div;
if (stack_start >= div)
stack_start -= div;
stack_pix_ptr = &stack[stack_start];
sum_out_r -= stack_pix_ptr->r;
@ -753,7 +744,8 @@ namespace agg
sum_b += sum_in_b;
++stack_ptr;
if(stack_ptr >= div) stack_ptr = 0;
if (stack_ptr >= div)
stack_ptr = 0;
stack_pix_ptr = &stack[stack_ptr];
sum_out_r += stack_pix_ptr->r;
@ -767,21 +759,13 @@ namespace agg
}
}
//=======================================================stack_blur_rgba32
template<class Img>
void stack_blur_rgba32(Img& img, unsigned rx, unsigned ry)
{
typedef typename Img::color_type color_type;
typedef typename Img::order_type order_type;
enum order_e
{
R = order_type::R,
G = order_type::G,
B = order_type::B,
A = order_type::A
};
enum order_e { R = order_type::R, G = order_type::G, B = order_type::B, A = order_type::A };
unsigned x, y, xp, yp, i;
unsigned stack_ptr;
@ -817,7 +801,8 @@ namespace agg
if (rx > 0)
{
if(rx > 254) rx = 254;
if (rx > 254)
rx = 254;
div = rx * 2 + 1;
mul_sum = stack_blur_tables<int>::g_stack_blur8_mul[rx];
shr_sum = stack_blur_tables<int>::g_stack_blur8_shr[rx];
@ -825,18 +810,8 @@ namespace agg
for (y = 0; y < h; y++)
{
sum_r =
sum_g =
sum_b =
sum_a =
sum_in_r =
sum_in_g =
sum_in_b =
sum_in_a =
sum_out_r =
sum_out_g =
sum_out_b =
sum_out_a = 0;
sum_r = sum_g = sum_b = sum_a = sum_in_r = sum_in_g = sum_in_b = sum_in_a = sum_out_r = sum_out_g =
sum_out_b = sum_out_a = 0;
src_pix_ptr = img.pix_ptr(0, y);
for (i = 0; i <= rx; i++)
@ -857,7 +832,8 @@ namespace agg
}
for (i = 1; i <= rx; i++)
{
if(i <= wm) src_pix_ptr += Img::pix_width;
if (i <= wm)
src_pix_ptr += Img::pix_width;
stack_pix_ptr = &stack[i + rx];
stack_pix_ptr->r = src_pix_ptr[R];
stack_pix_ptr->g = src_pix_ptr[G];
@ -875,7 +851,8 @@ namespace agg
stack_ptr = rx;
xp = rx;
if(xp > wm) xp = wm;
if (xp > wm)
xp = wm;
src_pix_ptr = img.pix_ptr(xp, y);
dst_pix_ptr = img.pix_ptr(0, y);
for (x = 0; x < w; x++)
@ -892,7 +869,8 @@ namespace agg
sum_a -= sum_out_a;
stack_start = stack_ptr + div - rx;
if(stack_start >= div) stack_start -= div;
if (stack_start >= div)
stack_start -= div;
stack_pix_ptr = &stack[stack_start];
sum_out_r -= stack_pix_ptr->r;
@ -921,7 +899,8 @@ namespace agg
sum_a += sum_in_a;
++stack_ptr;
if(stack_ptr >= div) stack_ptr = 0;
if (stack_ptr >= div)
stack_ptr = 0;
stack_pix_ptr = &stack[stack_ptr];
sum_out_r += stack_pix_ptr->r;
@ -938,7 +917,8 @@ namespace agg
if (ry > 0)
{
if(ry > 254) ry = 254;
if (ry > 254)
ry = 254;
div = ry * 2 + 1;
mul_sum = stack_blur_tables<int>::g_stack_blur8_mul[ry];
shr_sum = stack_blur_tables<int>::g_stack_blur8_shr[ry];
@ -947,18 +927,8 @@ namespace agg
int stride = img.stride();
for (x = 0; x < w; x++)
{
sum_r =
sum_g =
sum_b =
sum_a =
sum_in_r =
sum_in_g =
sum_in_b =
sum_in_a =
sum_out_r =
sum_out_g =
sum_out_b =
sum_out_a = 0;
sum_r = sum_g = sum_b = sum_a = sum_in_r = sum_in_g = sum_in_b = sum_in_a = sum_out_r = sum_out_g =
sum_out_b = sum_out_a = 0;
src_pix_ptr = img.pix_ptr(x, 0);
for (i = 0; i <= ry; i++)
@ -979,7 +949,8 @@ namespace agg
}
for (i = 1; i <= ry; i++)
{
if(i <= hm) src_pix_ptr += stride;
if (i <= hm)
src_pix_ptr += stride;
stack_pix_ptr = &stack[i + ry];
stack_pix_ptr->r = src_pix_ptr[R];
stack_pix_ptr->g = src_pix_ptr[G];
@ -997,7 +968,8 @@ namespace agg
stack_ptr = ry;
yp = ry;
if(yp > hm) yp = hm;
if (yp > hm)
yp = hm;
src_pix_ptr = img.pix_ptr(x, yp);
dst_pix_ptr = img.pix_ptr(x, 0);
for (y = 0; y < h; y++)
@ -1014,7 +986,8 @@ namespace agg
sum_a -= sum_out_a;
stack_start = stack_ptr + div - ry;
if(stack_start >= div) stack_start -= div;
if (stack_start >= div)
stack_start -= div;
stack_pix_ptr = &stack[stack_start];
sum_out_r -= stack_pix_ptr->r;
@ -1043,7 +1016,8 @@ namespace agg
sum_a += sum_in_a;
++stack_ptr;
if(stack_ptr >= div) stack_ptr = 0;
if (stack_ptr >= div)
stack_ptr = 0;
stack_pix_ptr = &stack[stack_ptr];
sum_out_r += stack_pix_ptr->r;
@ -1059,10 +1033,9 @@ namespace agg
}
}
//===========================================================recursive_blur
template<class ColorT, class CalculatorT> class recursive_blur
template<class ColorT, class CalculatorT>
class recursive_blur
{
public:
typedef ColorT color_type;
@ -1071,30 +1044,25 @@ namespace agg
typedef typename calculator_type::value_type calc_type;
//--------------------------------------------------------------------
template<class Img> void blur_x(Img& img, double radius)
template<class Img>
void blur_x(Img& img, double radius)
{
if(radius < 0.62) return;
if(img.width() < 3) return;
if (radius < 0.62)
return;
if (img.width() < 3)
return;
calc_type s = calc_type(radius * 0.5);
calc_type q = calc_type((s < 2.5) ?
3.97156 - 4.14554 * sqrt(1 - 0.26891 * s) :
0.98711 * s - 0.96330);
calc_type q = calc_type((s < 2.5) ? 3.97156 - 4.14554 * sqrt(1 - 0.26891 * s) : 0.98711 * s - 0.96330);
calc_type q2 = calc_type(q * q);
calc_type q3 = calc_type(q2 * q);
calc_type b0 = calc_type(1.0 / (1.578250 +
2.444130 * q +
1.428100 * q2 +
0.422205 * q3));
calc_type b0 = calc_type(1.0 / (1.578250 + 2.444130 * q + 1.428100 * q2 + 0.422205 * q3));
calc_type b1 = calc_type( 2.44413 * q +
2.85619 * q2 +
1.26661 * q3);
calc_type b1 = calc_type(2.44413 * q + 2.85619 * q2 + 1.26661 * q3);
calc_type b2 = calc_type(-1.42810 * q2 +
-1.26661 * q3);
calc_type b2 = calc_type(-1.42810 * q2 + -1.26661 * q3);
calc_type b3 = calc_type(0.422205 * q3);
@ -1146,14 +1114,16 @@ namespace agg
}
//--------------------------------------------------------------------
template<class Img> void blur_y(Img& img, double radius)
template<class Img>
void blur_y(Img& img, double radius)
{
pixfmt_transposer<Img> img2(img);
blur_x(img2, radius);
}
//--------------------------------------------------------------------
template<class Img> void blur(Img& img, double radius)
template<class Img>
void blur(Img& img, double radius)
{
blur_x(img, radius);
pixfmt_transposer<Img> img2(img);
@ -1166,9 +1136,9 @@ namespace agg
agg::pod_vector<color_type> m_buf;
};
//=================================================recursive_blur_calc_rgba
template<class T=double> struct recursive_blur_calc_rgba
template<class T = double>
struct recursive_blur_calc_rgba
{
typedef T value_type;
typedef recursive_blur_calc_rgba<T> self_type;
@ -1210,9 +1180,9 @@ namespace agg
}
};
//=================================================recursive_blur_calc_rgb
template<class T=double> struct recursive_blur_calc_rgb
template<class T = double>
struct recursive_blur_calc_rgb
{
typedef T value_type;
typedef recursive_blur_calc_rgb<T> self_type;
@ -1251,9 +1221,9 @@ namespace agg
}
};
//================================================recursive_blur_calc_gray
template<class T=double> struct recursive_blur_calc_gray
template<class T = double>
struct recursive_blur_calc_gray
{
typedef T value_type;
typedef recursive_blur_calc_gray<T> self_type;
@ -1286,9 +1256,6 @@ namespace agg
}
};
}
} // namespace agg
#endif

45
deps/agg/include/agg_bounding_rect.h vendored
View file

@ -21,14 +21,18 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//-----------------------------------------------------------bounding_rect
template<class VertexSource, class GetId, class CoordT>
bool bounding_rect(VertexSource& vs, GetId& gi,
unsigned start, unsigned num,
CoordT* x1, CoordT* y1, CoordT* x2, CoordT* y2)
bool bounding_rect(VertexSource& vs,
GetId& gi,
unsigned start,
unsigned num,
CoordT* x1,
CoordT* y1,
CoordT* x2,
CoordT* y2)
{
unsigned i;
double x;
@ -58,10 +62,14 @@ namespace agg
}
else
{
if(CoordT(x) < *x1) *x1 = CoordT(x);
if(CoordT(y) < *y1) *y1 = CoordT(y);
if(CoordT(x) > *x2) *x2 = CoordT(x);
if(CoordT(y) > *y2) *y2 = CoordT(y);
if (CoordT(x) < *x1)
*x1 = CoordT(x);
if (CoordT(y) < *y1)
*y1 = CoordT(y);
if (CoordT(x) > *x2)
*x2 = CoordT(x);
if (CoordT(y) > *y2)
*y2 = CoordT(y);
}
}
}
@ -69,11 +77,9 @@ namespace agg
return *x1 <= *x2 && *y1 <= *y2;
}
//-----------------------------------------------------bounding_rect_single
template<class VertexSource, class CoordT>
bool bounding_rect_single(VertexSource& vs, unsigned path_id,
CoordT* x1, CoordT* y1, CoordT* x2, CoordT* y2)
bool bounding_rect_single(VertexSource& vs, unsigned path_id, CoordT* x1, CoordT* y1, CoordT* x2, CoordT* y2)
{
double x;
double y;
@ -100,17 +106,20 @@ namespace agg
}
else
{
if(CoordT(x) < *x1) *x1 = CoordT(x);
if(CoordT(y) < *y1) *y1 = CoordT(y);
if(CoordT(x) > *x2) *x2 = CoordT(x);
if(CoordT(y) > *y2) *y2 = CoordT(y);
if (CoordT(x) < *x1)
*x1 = CoordT(x);
if (CoordT(y) < *y1)
*y1 = CoordT(y);
if (CoordT(x) > *x2)
*x2 = CoordT(x);
if (CoordT(y) > *y2)
*y2 = CoordT(y);
}
}
}
return *x1 <= *x2 && *y1 <= *y2;
}
}
} // namespace agg
#endif

6
deps/agg/include/agg_bspline.h vendored
View file

@ -22,8 +22,7 @@
#include "agg_array.h"
namespace agg
{
namespace agg {
//----------------------------------------------------------------bspline
// A very simple class of Bi-cubic Spline interpolation.
// First call init(num, x[], y[]) where num - number of source points,
@ -70,7 +69,6 @@ namespace agg
mutable int m_last_idx;
};
}
} // namespace agg
#endif

35
deps/agg/include/agg_clip_liang_barsky.h vendored
View file

@ -21,12 +21,10 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//------------------------------------------------------------------------
enum clipping_flags_e
{
enum clipping_flags_e {
clipping_flags_x1_clipped = 4,
clipping_flags_x2_clipped = 1,
clipping_flags_y1_clipped = 8,
@ -56,10 +54,7 @@ namespace agg
template<class T>
inline unsigned clipping_flags(T x, T y, const rect_base<T>& clip_box)
{
return (x > clip_box.x2) |
((y > clip_box.y2) << 1) |
((x < clip_box.x1) << 2) |
((y < clip_box.y1) << 3);
return (x > clip_box.x2) | ((y > clip_box.y2) << 1) | ((x < clip_box.x1) << 2) | ((y < clip_box.y1) << 3);
}
//--------------------------------------------------------clipping_flags_x
@ -69,7 +64,6 @@ namespace agg
return (x > clip_box.x2) | ((x < clip_box.x1) << 2);
}
//--------------------------------------------------------clipping_flags_y
template<class T>
inline unsigned clipping_flags_y(T y, const rect_base<T>& clip_box)
@ -77,12 +71,9 @@ namespace agg
return ((y > clip_box.y2) << 1) | ((y < clip_box.y1) << 3);
}
//-------------------------------------------------------clip_liang_barsky
template<class T>
inline unsigned clip_liang_barsky(T x1, T y1, T x2, T y2,
const rect_base<T>& clip_box,
T* x, T* y)
inline unsigned clip_liang_barsky(T x1, T y1, T x2, T y2, const rect_base<T>& clip_box, T* x, T* y)
{
const double nearzero = 1e-30;
@ -228,12 +219,9 @@ namespace agg
return np;
}
//----------------------------------------------------------------------------
template<class T>
bool clip_move_point(T x1, T y1, T x2, T y2,
const rect_base<T>& clip_box,
T* x, T* y, unsigned flags)
bool clip_move_point(T x1, T y1, T x2, T y2, const rect_base<T>& clip_box, T* x, T* y, unsigned flags)
{
T bound;
@ -268,8 +256,7 @@ namespace agg
// (ret & 2) != 0 - Second point has been moved
//
template<class T>
unsigned clip_line_segment(T* x1, T* y1, T* x2, T* y2,
const rect_base<T>& clip_box)
unsigned clip_line_segment(T* x1, T* y1, T* x2, T* y2, const rect_base<T>& clip_box)
{
unsigned f1 = clipping_flags(*x1, *y1, clip_box);
unsigned f2 = clipping_flags(*x2, *y2, clip_box);
@ -281,15 +268,13 @@ namespace agg
return 0;
}
if((f1 & clipping_flags_x_clipped) != 0 &&
(f1 & clipping_flags_x_clipped) == (f2 & clipping_flags_x_clipped))
if ((f1 & clipping_flags_x_clipped) != 0 && (f1 & clipping_flags_x_clipped) == (f2 & clipping_flags_x_clipped))
{
// Fully clipped
return 4;
}
if((f1 & clipping_flags_y_clipped) != 0 &&
(f1 & clipping_flags_y_clipped) == (f2 & clipping_flags_y_clipped))
if ((f1 & clipping_flags_y_clipped) != 0 && (f1 & clipping_flags_y_clipped) == (f2 & clipping_flags_y_clipped))
{
// Fully clipped
return 4;
@ -326,8 +311,6 @@ namespace agg
return ret;
}
}
} // namespace agg
#endif

499
deps/agg/include/agg_color_gray.h vendored
View file

@ -31,8 +31,7 @@
#include "agg_basics.h"
#include "agg_color_rgba.h"
namespace agg
{
namespace agg {
//===================================================================gray8
template<class Colorspace>
@ -41,8 +40,7 @@ struct gray8T
typedef int8u value_type;
typedef int32u calc_type;
typedef int32 long_type;
enum base_scale_e
{
enum base_scale_e {
base_shift = 8,
base_scale = 1 << base_shift,
base_mask = base_scale - 1,
@ -105,17 +103,22 @@ struct gray8T
gray8T() {}
//--------------------------------------------------------------------
gray8T(unsigned v_, unsigned a_=base_mask) :
v(int8u(v_)), a(int8u(a_)) {}
gray8T(unsigned v_, unsigned a_ = base_mask)
: v(int8u(v_))
, a(int8u(a_))
{}
//--------------------------------------------------------------------
gray8T(const self_type& c, unsigned a_) :
v(c.v), a(value_type(a_)) {}
gray8T(const self_type& c, unsigned a_)
: v(c.v)
, a(value_type(a_))
{}
//--------------------------------------------------------------------
gray8T(const rgba& c) :
v(luminance(c)),
a(value_type(uround(c.a * base_mask))) {}
gray8T(const rgba& c)
: v(luminance(c))
, a(value_type(uround(c.a * base_mask)))
{}
//--------------------------------------------------------------------
template<class T>
@ -147,36 +150,18 @@ struct gray8T
}
//--------------------------------------------------------------------
rgba8 make_rgba8(const linear&) const
{
return rgba8(v, v, v, a);
}
rgba8 make_rgba8(const linear&) const { return rgba8(v, v, v, a); }
rgba8 make_rgba8(const sRGB&) const
{
return convert_from_sRGB<srgba8>();
}
rgba8 make_rgba8(const sRGB&) const { return convert_from_sRGB<srgba8>(); }
operator rgba8() const
{
return make_rgba8(Colorspace());
}
operator rgba8() const { return make_rgba8(Colorspace()); }
//--------------------------------------------------------------------
srgba8 make_srgba8(const linear&) const
{
return convert_to_sRGB<rgba8>();
}
srgba8 make_srgba8(const linear&) const { return convert_to_sRGB<rgba8>(); }
srgba8 make_srgba8(const sRGB&) const
{
return srgba8(v, v, v, a);
}
srgba8 make_srgba8(const sRGB&) const { return srgba8(v, v, v, a); }
operator srgba8() const
{
return make_rgba8(Colorspace());
}
operator srgba8() const { return make_rgba8(Colorspace()); }
//--------------------------------------------------------------------
rgba16 make_rgba16(const linear&) const
@ -185,15 +170,9 @@ struct gray8T
return rgba16(rgb, rgb, rgb, (a << 8) | a);
}
rgba16 make_rgba16(const sRGB&) const
{
return convert_from_sRGB<rgba16>();
}
rgba16 make_rgba16(const sRGB&) const { return convert_from_sRGB<rgba16>(); }
operator rgba16() const
{
return make_rgba16(Colorspace());
}
operator rgba16() const { return make_rgba16(Colorspace()); }
//--------------------------------------------------------------------
rgba32 make_rgba32(const linear&) const
@ -202,51 +181,27 @@ struct gray8T
return rgba32(v32, v32, v32, a / 255.0);
}
rgba32 make_rgba32(const sRGB&) const
{
return convert_from_sRGB<rgba32>();
}
rgba32 make_rgba32(const sRGB&) const { return convert_from_sRGB<rgba32>(); }
operator rgba32() const
{
return make_rgba32(Colorspace());
}
operator rgba32() const { return make_rgba32(Colorspace()); }
//--------------------------------------------------------------------
static AGG_INLINE double to_double(value_type a)
{
return double(a) / base_mask;
}
static AGG_INLINE double to_double(value_type a) { return double(a) / base_mask; }
//--------------------------------------------------------------------
static AGG_INLINE value_type from_double(double a)
{
return value_type(uround(a * base_mask));
}
static AGG_INLINE value_type from_double(double a) { return value_type(uround(a * base_mask)); }
//--------------------------------------------------------------------
static AGG_INLINE value_type empty_value()
{
return 0;
}
static AGG_INLINE value_type empty_value() { return 0; }
//--------------------------------------------------------------------
static AGG_INLINE value_type full_value()
{
return base_mask;
}
static AGG_INLINE value_type full_value() { return base_mask; }
//--------------------------------------------------------------------
AGG_INLINE bool is_transparent() const
{
return a == 0;
}
AGG_INLINE bool is_transparent() const { return a == 0; }
//--------------------------------------------------------------------
AGG_INLINE bool is_opaque() const
{
return a == base_mask;
}
AGG_INLINE bool is_opaque() const { return a == base_mask; }
//--------------------------------------------------------------------
// Fixed-point multiply, exact over int8u.
@ -267,7 +222,8 @@ struct gray8T
{
return base_mask;
}
else return value_type((a * base_mask + (b >> 1)) / b);
else
return value_type((a * base_mask + (b >> 1)) / b);
}
//--------------------------------------------------------------------
@ -287,23 +243,14 @@ struct gray8T
//--------------------------------------------------------------------
// Fixed-point multiply, exact over int8u.
// Specifically for multiplying a color component by a cover.
static AGG_INLINE value_type mult_cover(value_type a, value_type b)
{
return multiply(a, b);
}
static AGG_INLINE value_type mult_cover(value_type a, value_type b) { return multiply(a, b); }
//--------------------------------------------------------------------
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
{
return multiply(b, a);
}
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return multiply(b, a); }
//--------------------------------------------------------------------
// Interpolate p to q by a, assuming q is premultiplied by a.
static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a)
{
return p + q - multiply(p, a);
}
static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a) { return p + q - multiply(p, a); }
//--------------------------------------------------------------------
// Interpolate p to q by a.
@ -330,25 +277,27 @@ struct gray8T
//--------------------------------------------------------------------
self_type& opacity(double a_)
{
if (a_ < 0) a = 0;
else if (a_ > 1) a = 1;
else a = (value_type)uround(a_ * double(base_mask));
if (a_ < 0)
a = 0;
else if (a_ > 1)
a = 1;
else
a = (value_type)uround(a_ * double(base_mask));
return *this;
}
//--------------------------------------------------------------------
double opacity() const
{
return double(a) / double(base_mask);
}
double opacity() const { return double(a) / double(base_mask); }
//--------------------------------------------------------------------
self_type& premultiply()
{
if (a < base_mask)
{
if (a == 0) v = 0;
else v = multiply(v, a);
if (a == 0)
v = 0;
else
v = multiply(v, a);
}
return *this;
}
@ -414,15 +363,13 @@ struct gray8T
typedef gray8T<linear> gray8;
typedef gray8T<sRGB> sgray8;
//==================================================================gray16
struct gray16
{
typedef int16u value_type;
typedef int32u calc_type;
typedef int64 long_type;
enum base_scale_e
{
enum base_scale_e {
base_shift = 16,
base_scale = 1 << base_shift,
base_mask = base_scale - 1,
@ -436,8 +383,7 @@ struct gray16
static value_type luminance(const rgba& c)
{
// Calculate grayscale value as per ITU-R BT.709.
return value_type(uround((0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b)
* static_cast<double>(base_mask)));
return value_type(uround((0.2126 * c.r + 0.7152 * c.g + 0.0722 * c.b) * static_cast<double>(base_mask)));
}
static value_type luminance(const rgba16& c)
@ -446,67 +392,65 @@ struct gray16
return value_type((13933u * c.r + 46872u * c.g + 4732u * c.b) >> 16);
}
static value_type luminance(const rgba8& c)
{
return luminance(rgba16(c));
}
static value_type luminance(const rgba8& c) { return luminance(rgba16(c)); }
static value_type luminance(const srgba8& c)
{
return luminance(rgba16(c));
}
static value_type luminance(const srgba8& c) { return luminance(rgba16(c)); }
static value_type luminance(const rgba32& c)
{
return luminance(rgba(c));
}
static value_type luminance(const rgba32& c) { return luminance(rgba(c)); }
//--------------------------------------------------------------------
gray16() {}
//--------------------------------------------------------------------
gray16(unsigned v_, unsigned a_ = base_mask) :
v(int16u(v_)), a(int16u(a_)) {}
gray16(unsigned v_, unsigned a_ = base_mask)
: v(int16u(v_))
, a(int16u(a_))
{}
//--------------------------------------------------------------------
gray16(const self_type& c, unsigned a_) :
v(c.v), a(value_type(a_)) {}
gray16(const self_type& c, unsigned a_)
: v(c.v)
, a(value_type(a_))
{}
//--------------------------------------------------------------------
gray16(const rgba& c) :
v(luminance(c)),
a((value_type)uround(c.a * double(base_mask))) {}
gray16(const rgba& c)
: v(luminance(c))
, a((value_type)uround(c.a * double(base_mask)))
{}
//--------------------------------------------------------------------
gray16(const rgba8& c) :
v(luminance(c)),
a((value_type(c.a) << 8) | c.a) {}
gray16(const rgba8& c)
: v(luminance(c))
, a((value_type(c.a) << 8) | c.a)
{}
//--------------------------------------------------------------------
gray16(const srgba8& c) :
v(luminance(c)),
a((value_type(c.a) << 8) | c.a) {}
gray16(const srgba8& c)
: v(luminance(c))
, a((value_type(c.a) << 8) | c.a)
{}
//--------------------------------------------------------------------
gray16(const rgba16& c) :
v(luminance(c)),
a(c.a) {}
gray16(const rgba16& c)
: v(luminance(c))
, a(c.a)
{}
//--------------------------------------------------------------------
gray16(const gray8& c) :
v((value_type(c.v) << 8) | c.v),
a((value_type(c.a) << 8) | c.a) {}
gray16(const gray8& c)
: v((value_type(c.v) << 8) | c.v)
, a((value_type(c.a) << 8) | c.a)
{}
//--------------------------------------------------------------------
gray16(const sgray8& c) :
v(sRGB_conv<value_type>::rgb_from_sRGB(c.v)),
a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}
gray16(const sgray8& c)
: v(sRGB_conv<value_type>::rgb_from_sRGB(c.v))
, a(sRGB_conv<value_type>::alpha_from_sRGB(c.a))
{}
//--------------------------------------------------------------------
operator rgba8() const
{
return rgba8(v >> 8, v >> 8, v >> 8, a >> 8);
}
operator rgba8() const { return rgba8(v >> 8, v >> 8, v >> 8, a >> 8); }
//--------------------------------------------------------------------
operator srgba8() const
@ -516,30 +460,19 @@ struct gray16
}
//--------------------------------------------------------------------
operator rgba16() const
{
return rgba16(v, v, v, a);
}
operator rgba16() const { return rgba16(v, v, v, a); }
//--------------------------------------------------------------------
operator gray8() const
{
return gray8(v >> 8, a >> 8);
}
operator gray8() const { return gray8(v >> 8, a >> 8); }
//--------------------------------------------------------------------
operator sgray8() const
{
return sgray8(
sRGB_conv<value_type>::rgb_to_sRGB(v),
sRGB_conv<value_type>::alpha_to_sRGB(a));
return sgray8(sRGB_conv<value_type>::rgb_to_sRGB(v), sRGB_conv<value_type>::alpha_to_sRGB(a));
}
//--------------------------------------------------------------------
static AGG_INLINE double to_double(value_type a)
{
return static_cast<double>(a) / static_cast<double>(base_mask);
}
static AGG_INLINE double to_double(value_type a) { return static_cast<double>(a) / static_cast<double>(base_mask); }
//--------------------------------------------------------------------
static AGG_INLINE value_type from_double(double a)
@ -548,28 +481,16 @@ struct gray16
}
//--------------------------------------------------------------------
static AGG_INLINE value_type empty_value()
{
return 0;
}
static AGG_INLINE value_type empty_value() { return 0; }
//--------------------------------------------------------------------
static AGG_INLINE value_type full_value()
{
return base_mask;
}
static AGG_INLINE value_type full_value() { return base_mask; }
//--------------------------------------------------------------------
AGG_INLINE bool is_transparent() const
{
return a == 0;
}
AGG_INLINE bool is_transparent() const { return a == 0; }
//--------------------------------------------------------------------
AGG_INLINE bool is_opaque() const
{
return a == base_mask;
}
AGG_INLINE bool is_opaque() const { return a == base_mask; }
//--------------------------------------------------------------------
// Fixed-point multiply, exact over int16u.
@ -590,7 +511,8 @@ struct gray16
{
return base_mask;
}
else return value_type((a * base_mask + (b >> 1)) / b);
else
return value_type((a * base_mask + (b >> 1)) / b);
}
//--------------------------------------------------------------------
@ -610,23 +532,14 @@ struct gray16
//--------------------------------------------------------------------
// Fixed-point multiply, almost exact over int16u.
// Specifically for multiplying a color component by a cover.
static AGG_INLINE value_type mult_cover(value_type a, cover_type b)
{
return multiply(a, b << 8 | b);
}
static AGG_INLINE value_type mult_cover(value_type a, cover_type b) { return multiply(a, b << 8 | b); }
//--------------------------------------------------------------------
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
{
return mult_cover(b, a) >> 8;
}
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return mult_cover(b, a) >> 8; }
//--------------------------------------------------------------------
// Interpolate p to q by a, assuming q is premultiplied by a.
static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a)
{
return p + q - multiply(p, a);
}
static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a) { return p + q - multiply(p, a); }
//--------------------------------------------------------------------
// Interpolate p to q by a.
@ -653,26 +566,27 @@ struct gray16
//--------------------------------------------------------------------
self_type& opacity(double a_)
{
if (a_ < 0) a = 0;
else if(a_ > 1) a = 1;
else a = (value_type)uround(a_ * double(base_mask));
if (a_ < 0)
a = 0;
else if (a_ > 1)
a = 1;
else
a = (value_type)uround(a_ * double(base_mask));
return *this;
}
//--------------------------------------------------------------------
double opacity() const
{
return double(a) / double(base_mask);
}
double opacity() const { return double(a) / double(base_mask); }
//--------------------------------------------------------------------
self_type& premultiply()
{
if (a < base_mask)
{
if(a == 0) v = 0;
else v = multiply(v, a);
if (a == 0)
v = 0;
else
v = multiply(v, a);
}
return *this;
}
@ -735,7 +649,6 @@ struct gray16
static self_type no_color() { return self_type(0, 0); }
};
//===================================================================gray32
struct gray32
{
@ -747,8 +660,7 @@ struct gray32
value_type v;
value_type a;
enum base_scale_e
{
enum base_scale_e {
base_shift = 8,
base_scale = 1 << base_shift,
base_mask = base_scale - 1,
@ -760,103 +672,92 @@ struct gray32
return value_type(0.2126 * r + 0.7152 * g + 0.0722 * b);
}
static value_type luminance(const rgba& c)
{
return luminance(c.r, c.g, c.b);
}
static value_type luminance(const rgba& c) { return luminance(c.r, c.g, c.b); }
static value_type luminance(const rgba32& c)
{
return luminance(c.r, c.g, c.b);
}
static value_type luminance(const rgba32& c) { return luminance(c.r, c.g, c.b); }
static value_type luminance(const rgba8& c)
{
return luminance(c.r / 255.0, c.g / 255.0, c.g / 255.0);
}
static value_type luminance(const rgba8& c) { return luminance(c.r / 255.0, c.g / 255.0, c.g / 255.0); }
static value_type luminance(const rgba16& c)
{
return luminance(c.r / 65535.0, c.g / 65535.0, c.g / 65535.0);
}
static value_type luminance(const rgba16& c) { return luminance(c.r / 65535.0, c.g / 65535.0, c.g / 65535.0); }
//--------------------------------------------------------------------
gray32() {}
//--------------------------------------------------------------------
gray32(value_type v_, value_type a_ = 1) :
v(v_), a(a_) {}
gray32(value_type v_, value_type a_ = 1)
: v(v_)
, a(a_)
{}
//--------------------------------------------------------------------
gray32(const self_type& c, value_type a_) :
v(c.v), a(a_) {}
gray32(const self_type& c, value_type a_)
: v(c.v)
, a(a_)
{}
//--------------------------------------------------------------------
gray32(const rgba& c) :
v(luminance(c)),
a(value_type(c.a)) {}
gray32(const rgba& c)
: v(luminance(c))
, a(value_type(c.a))
{}
//--------------------------------------------------------------------
gray32(const rgba8& c) :
v(luminance(c)),
a(value_type(c.a / 255.0)) {}
gray32(const rgba8& c)
: v(luminance(c))
, a(value_type(c.a / 255.0))
{}
//--------------------------------------------------------------------
gray32(const srgba8& c) :
v(luminance(rgba32(c))),
a(value_type(c.a / 255.0)) {}
gray32(const srgba8& c)
: v(luminance(rgba32(c)))
, a(value_type(c.a / 255.0))
{}
//--------------------------------------------------------------------
gray32(const rgba16& c) :
v(luminance(c)),
a(value_type(c.a / 65535.0)) {}
gray32(const rgba16& c)
: v(luminance(c))
, a(value_type(c.a / 65535.0))
{}
//--------------------------------------------------------------------
gray32(const rgba32& c) :
v(luminance(c)),
a(value_type(c.a)) {}
gray32(const rgba32& c)
: v(luminance(c))
, a(value_type(c.a))
{}
//--------------------------------------------------------------------
gray32(const gray8& c) :
v(value_type(c.v / 255.0)),
a(value_type(c.a / 255.0)) {}
gray32(const gray8& c)
: v(value_type(c.v / 255.0))
, a(value_type(c.a / 255.0))
{}
//--------------------------------------------------------------------
gray32(const sgray8& c) :
v(sRGB_conv<value_type>::rgb_from_sRGB(c.v)),
a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}
gray32(const sgray8& c)
: v(sRGB_conv<value_type>::rgb_from_sRGB(c.v))
, a(sRGB_conv<value_type>::alpha_from_sRGB(c.a))
{}
//--------------------------------------------------------------------
gray32(const gray16& c) :
v(value_type(c.v / 65535.0)),
a(value_type(c.a / 65535.0)) {}
gray32(const gray16& c)
: v(value_type(c.v / 65535.0))
, a(value_type(c.a / 65535.0))
{}
//--------------------------------------------------------------------
operator rgba() const
{
return rgba(v, v, v, a);
}
operator rgba() const { return rgba(v, v, v, a); }
//--------------------------------------------------------------------
operator gray8() const
{
return gray8(uround(v * 255.0), uround(a * 255.0));
}
operator gray8() const { return gray8(uround(v * 255.0), uround(a * 255.0)); }
//--------------------------------------------------------------------
operator sgray8() const
{
// Return (non-premultiplied) sRGB values.
return sgray8(
sRGB_conv<value_type>::rgb_to_sRGB(v),
sRGB_conv<value_type>::alpha_to_sRGB(a));
return sgray8(sRGB_conv<value_type>::rgb_to_sRGB(v), sRGB_conv<value_type>::alpha_to_sRGB(a));
}
//--------------------------------------------------------------------
operator gray16() const
{
return gray16(uround(v * 65535.0), uround(a * 65535.0));
}
operator gray16() const { return gray16(uround(v * 65535.0), uround(a * 65535.0)); }
//--------------------------------------------------------------------
operator rgba8() const
@ -880,58 +781,31 @@ struct gray32
}
//--------------------------------------------------------------------
static AGG_INLINE double to_double(value_type a)
{
return a;
}
static AGG_INLINE double to_double(value_type a) { return a; }
//--------------------------------------------------------------------
static AGG_INLINE value_type from_double(double a)
{
return value_type(a);
}
static AGG_INLINE value_type from_double(double a) { return value_type(a); }
//--------------------------------------------------------------------
static AGG_INLINE value_type empty_value()
{
return 0;
}
static AGG_INLINE value_type empty_value() { return 0; }
//--------------------------------------------------------------------
static AGG_INLINE value_type full_value()
{
return 1;
}
static AGG_INLINE value_type full_value() { return 1; }
//--------------------------------------------------------------------
AGG_INLINE bool is_transparent() const
{
return a <= 0;
}
AGG_INLINE bool is_transparent() const { return a <= 0; }
//--------------------------------------------------------------------
AGG_INLINE bool is_opaque() const
{
return a >= 1;
}
AGG_INLINE bool is_opaque() const { return a >= 1; }
//--------------------------------------------------------------------
static AGG_INLINE value_type invert(value_type x)
{
return 1 - x;
}
static AGG_INLINE value_type invert(value_type x) { return 1 - x; }
//--------------------------------------------------------------------
static AGG_INLINE value_type multiply(value_type a, value_type b)
{
return value_type(a * b);
}
static AGG_INLINE value_type multiply(value_type a, value_type b) { return value_type(a * b); }
//--------------------------------------------------------------------
static AGG_INLINE value_type demultiply(value_type a, value_type b)
{
return (b == 0) ? 0 : value_type(a / b);
}
static AGG_INLINE value_type demultiply(value_type a, value_type b) { return (b == 0) ? 0 : value_type(a / b); }
//--------------------------------------------------------------------
template<typename T>
@ -954,10 +828,7 @@ struct gray32
}
//--------------------------------------------------------------------
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
{
return cover_type(uround(a * b));
}
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return cover_type(uround(a * b)); }
//--------------------------------------------------------------------
// Interpolate p to q by a, assuming q is premultiplied by a.
@ -994,49 +865,47 @@ struct gray32
//--------------------------------------------------------------------
self_type& opacity(double a_)
{
if (a_ < 0) a = 0;
else if (a_ > 1) a = 1;
else a = value_type(a_);
if (a_ < 0)
a = 0;
else if (a_ > 1)
a = 1;
else
a = value_type(a_);
return *this;
}
//--------------------------------------------------------------------
double opacity() const
{
return a;
}
double opacity() const { return a; }
//--------------------------------------------------------------------
self_type& premultiply()
{
if (a < 0) v = 0;
else if(a < 1) v *= a;
if (a < 0)
v = 0;
else if (a < 1)
v *= a;
return *this;
}
//--------------------------------------------------------------------
self_type& demultiply()
{
if (a < 0) v = 0;
else if (a < 1) v /= a;
if (a < 0)
v = 0;
else if (a < 1)
v /= a;
return *this;
}
//--------------------------------------------------------------------
self_type gradient(self_type c, double k) const
{
return self_type(
value_type(v + (c.v - v) * k),
value_type(a + (c.a - a) * k));
return self_type(value_type(v + (c.v - v) * k), value_type(a + (c.a - a) * k));
}
//--------------------------------------------------------------------
static self_type no_color() { return self_type(0, 0); }
};
}
} // namespace agg
#endif

477
deps/agg/include/agg_color_rgba.h vendored
View file

@ -28,20 +28,39 @@
#include "agg_basics.h"
#include "agg_gamma_lut.h"
namespace agg
{
namespace agg {
// Supported byte orders for RGB and RGBA pixel formats
//=======================================================================
struct order_rgb { enum rgb_e { R=0, G=1, B=2, rgb_tag, hasAlpha=false }; }; //----order_rgb
struct order_bgr { enum bgr_e { B=0, G=1, R=2, rgb_tag, hasAlpha=false }; }; //----order_bgr
struct order_rgba { enum rgba_e { R=0, G=1, B=2, A=3, rgba_tag, hasAlpha=true }; }; //----order_rgba
struct order_argb { enum argb_e { A=0, R=1, G=2, B=3, rgba_tag, hasAlpha=true }; }; //----order_argb
struct order_abgr { enum abgr_e { A=0, B=1, G=2, R=3, rgba_tag, hasAlpha=true }; }; //----order_abgr
struct order_bgra { enum bgra_e { B=0, G=1, R=2, A=3, rgba_tag, hasAlpha=true }; }; //----order_bgra
struct order_rgb
{
enum rgb_e { R = 0, G = 1, B = 2, rgb_tag, hasAlpha = false };
}; //----order_rgb
struct order_bgr
{
enum bgr_e { B = 0, G = 1, R = 2, rgb_tag, hasAlpha = false };
}; //----order_bgr
struct order_rgba
{
enum rgba_e { R = 0, G = 1, B = 2, A = 3, rgba_tag, hasAlpha = true };
}; //----order_rgba
struct order_argb
{
enum argb_e { A = 0, R = 1, G = 2, B = 3, rgba_tag, hasAlpha = true };
}; //----order_argb
struct order_abgr
{
enum abgr_e { A = 0, B = 1, G = 2, R = 3, rgba_tag, hasAlpha = true };
}; //----order_abgr
struct order_bgra
{
enum bgra_e { B = 0, G = 1, R = 2, A = 3, rgba_tag, hasAlpha = true };
}; //----order_bgra
// Colorspace tag types.
struct linear {};
struct sRGB {};
struct linear
{};
struct sRGB
{};
//====================================================================rgba
struct rgba
@ -57,11 +76,20 @@ struct rgba
rgba() {}
//--------------------------------------------------------------------
rgba(double r_, double g_, double b_, double a_=1.0) :
r(r_), g(g_), b(b_), a(a_) {}
rgba(double r_, double g_, double b_, double a_ = 1.0)
: r(r_)
, g(g_)
, b(b_)
, a(a_)
{}
//--------------------------------------------------------------------
rgba(const rgba& c, double a_) : r(c.r), g(c.g), b(c.b), a(a_) {}
rgba(const rgba& c, double a_)
: r(c.r)
, g(c.g)
, b(c.b)
, a(a_)
{}
//--------------------------------------------------------------------
rgba& clear()
@ -80,17 +108,17 @@ struct rgba
//--------------------------------------------------------------------
rgba& opacity(double a_)
{
if (a_ < 0) a = 0;
else if (a_ > 1) a = 1;
else a = a_;
if (a_ < 0)
a = 0;
else if (a_ > 1)
a = 1;
else
a = a_;
return *this;
}
//--------------------------------------------------------------------
double opacity() const
{
return a;
}
double opacity() const { return a; }
//--------------------------------------------------------------------
rgba& premultiply()
@ -136,7 +164,6 @@ struct rgba
return *this;
}
//--------------------------------------------------------------------
rgba gradient(rgba c, double k) const
{
@ -173,11 +200,7 @@ struct rgba
static rgba from_wavelength(double wl, double gamma = 1.0);
//--------------------------------------------------------------------
explicit rgba(double wavelen, double gamma=1.0)
{
*this = from_wavelength(wavelen, gamma);
}
explicit rgba(double wavelen, double gamma = 1.0) { *this = from_wavelength(wavelen, gamma); }
};
inline rgba operator+(const rgba& a, const rgba& b)
@ -226,8 +249,10 @@ inline rgba rgba::from_wavelength(double wl, double gamma)
}
double s = 1.0;
if (wl > 700.0) s = 0.3 + 0.7 * (780.0 - wl) / (780.0 - 700.0);
else if (wl < 420.0) s = 0.3 + 0.7 * (wl - 380.0) / (420.0 - 380.0);
if (wl > 700.0)
s = 0.3 + 0.7 * (780.0 - wl) / (780.0 - 700.0);
else if (wl < 420.0)
s = 0.3 + 0.7 * (wl - 380.0) / (420.0 - 380.0);
t.r = pow(t.r * s, gamma);
t.g = pow(t.g * s, gamma);
@ -240,7 +265,6 @@ inline rgba rgba_pre(double r, double g, double b, double a)
return rgba(r, g, b, a).premultiply();
}
//===================================================================rgba8
template<class Colorspace>
struct rgba8T
@ -248,8 +272,7 @@ struct rgba8T
typedef int8u value_type;
typedef int32u calc_type;
typedef int32 long_type;
enum base_scale_e
{
enum base_scale_e {
base_shift = 8,
base_scale = 1 << base_shift,
base_mask = base_scale - 1,
@ -257,7 +280,6 @@ struct rgba8T
};
typedef rgba8T self_type;
value_type r;
value_type g;
value_type b;
@ -317,21 +339,23 @@ struct rgba8T
rgba8T() {}
//--------------------------------------------------------------------
rgba8T(unsigned r_, unsigned g_, unsigned b_, unsigned a_ = base_mask) :
r(value_type(r_)),
g(value_type(g_)),
b(value_type(b_)),
a(value_type(a_)) {}
rgba8T(unsigned r_, unsigned g_, unsigned b_, unsigned a_ = base_mask)
: r(value_type(r_))
, g(value_type(g_))
, b(value_type(b_))
, a(value_type(a_))
{}
//--------------------------------------------------------------------
rgba8T(const rgba& c)
{
convert(*this, c);
}
rgba8T(const rgba& c) { convert(*this, c); }
//--------------------------------------------------------------------
rgba8T(const self_type& c, unsigned a_) :
r(c.r), g(c.g), b(c.b), a(value_type(a_)) {}
rgba8T(const self_type& c, unsigned a_)
: r(c.r)
, g(c.g)
, b(c.b)
, a(value_type(a_))
{}
//--------------------------------------------------------------------
template<class T>
@ -349,46 +373,25 @@ struct rgba8T
}
//--------------------------------------------------------------------
static AGG_INLINE double to_double(value_type a)
{
return double(a) / base_mask;
}
static AGG_INLINE double to_double(value_type a) { return double(a) / base_mask; }
//--------------------------------------------------------------------
static AGG_INLINE value_type from_double(double a)
{
return value_type(uround(a * base_mask));
}
static AGG_INLINE value_type from_double(double a) { return value_type(uround(a * base_mask)); }
//--------------------------------------------------------------------
static AGG_INLINE value_type empty_value()
{
return 0;
}
static AGG_INLINE value_type empty_value() { return 0; }
//--------------------------------------------------------------------
static AGG_INLINE value_type full_value()
{
return base_mask;
}
static AGG_INLINE value_type full_value() { return base_mask; }
//--------------------------------------------------------------------
AGG_INLINE bool is_transparent() const
{
return a == 0;
}
AGG_INLINE bool is_transparent() const { return a == 0; }
//--------------------------------------------------------------------
AGG_INLINE bool is_opaque() const
{
return a == base_mask;
}
AGG_INLINE bool is_opaque() const { return a == base_mask; }
//--------------------------------------------------------------------
static AGG_INLINE value_type invert(value_type x)
{
return base_mask - x;
}
static AGG_INLINE value_type invert(value_type x) { return base_mask - x; }
//--------------------------------------------------------------------
// Fixed-point multiply, exact over int8u.
@ -409,7 +412,8 @@ struct rgba8T
{
return base_mask;
}
else return value_type((a * base_mask + (b >> 1)) / b);
else
return value_type((a * base_mask + (b >> 1)) / b);
}
//--------------------------------------------------------------------
@ -429,23 +433,14 @@ struct rgba8T
//--------------------------------------------------------------------
// Fixed-point multiply, exact over int8u.
// Specifically for multiplying a color component by a cover.
static AGG_INLINE value_type mult_cover(value_type a, cover_type b)
{
return multiply(a, b);
}
static AGG_INLINE value_type mult_cover(value_type a, cover_type b) { return multiply(a, b); }
//--------------------------------------------------------------------
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
{
return multiply(b, a);
}
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return multiply(b, a); }
//--------------------------------------------------------------------
// Interpolate p to q by a, assuming q is premultiplied by a.
static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a)
{
return p + q - multiply(p, a);
}
static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a) { return p + q - multiply(p, a); }
//--------------------------------------------------------------------
// Interpolate p to q by a.
@ -472,17 +467,17 @@ struct rgba8T
//--------------------------------------------------------------------
self_type& opacity(double a_)
{
if (a_ < 0) a = 0;
else if (a_ > 1) a = 1;
else a = (value_type)uround(a_ * double(base_mask));
if (a_ < 0)
a = 0;
else if (a_ > 1)
a = 1;
else
a = (value_type)uround(a_ * double(base_mask));
return *this;
}
//--------------------------------------------------------------------
double opacity() const
{
return double(a) / double(base_mask);
}
double opacity() const { return double(a) / double(base_mask); }
//--------------------------------------------------------------------
AGG_INLINE self_type& premultiply()
@ -617,8 +612,7 @@ typedef rgba8T<linear> rgba8;
typedef rgba8T<sRGB> srgba8;
//-------------------------------------------------------------rgba8_pre
inline rgba8 rgba8_pre(unsigned r, unsigned g, unsigned b,
unsigned a = rgba8::base_mask)
inline rgba8 rgba8_pre(unsigned r, unsigned g, unsigned b, unsigned a = rgba8::base_mask)
{
return rgba8(r, g, b, a).premultiply();
}
@ -639,9 +633,6 @@ inline rgba8 rgba8_pre(const rgba& c, double a)
return rgba8(c, a).premultiply();
}
//-------------------------------------------------------------rgb8_packed
inline rgba8 rgb8_packed(unsigned v)
{
@ -674,16 +665,13 @@ rgba8 rgba8_gamma_inv(rgba8 c, const GammaLUT& gamma)
return rgba8(gamma.inv(c.r), gamma.inv(c.g), gamma.inv(c.b), c.a);
}
//==================================================================rgba16
struct rgba16
{
typedef int16u value_type;
typedef int32u calc_type;
typedef int64 long_type;
enum base_scale_e
{
enum base_scale_e {
base_shift = 16,
base_scale = 1 << base_shift,
base_mask = base_scale - 1,
@ -700,69 +688,63 @@ struct rgba16
rgba16() {}
//--------------------------------------------------------------------
rgba16(unsigned r_, unsigned g_, unsigned b_, unsigned a_=base_mask) :
r(value_type(r_)),
g(value_type(g_)),
b(value_type(b_)),
a(value_type(a_)) {}
rgba16(unsigned r_, unsigned g_, unsigned b_, unsigned a_ = base_mask)
: r(value_type(r_))
, g(value_type(g_))
, b(value_type(b_))
, a(value_type(a_))
{}
//--------------------------------------------------------------------
rgba16(const self_type& c, unsigned a_) :
r(c.r), g(c.g), b(c.b), a(value_type(a_)) {}
rgba16(const self_type& c, unsigned a_)
: r(c.r)
, g(c.g)
, b(c.b)
, a(value_type(a_))
{}
//--------------------------------------------------------------------
rgba16(const rgba& c) :
r((value_type)uround(c.r * double(base_mask))),
g((value_type)uround(c.g * double(base_mask))),
b((value_type)uround(c.b * double(base_mask))),
a((value_type)uround(c.a * double(base_mask))) {}
rgba16(const rgba& c)
: r((value_type)uround(c.r * double(base_mask)))
, g((value_type)uround(c.g * double(base_mask)))
, b((value_type)uround(c.b * double(base_mask)))
, a((value_type)uround(c.a * double(base_mask)))
{}
//--------------------------------------------------------------------
rgba16(const rgba8& c) :
r(value_type((value_type(c.r) << 8) | c.r)),
g(value_type((value_type(c.g) << 8) | c.g)),
b(value_type((value_type(c.b) << 8) | c.b)),
a(value_type((value_type(c.a) << 8) | c.a)) {}
rgba16(const rgba8& c)
: r(value_type((value_type(c.r) << 8) | c.r))
, g(value_type((value_type(c.g) << 8) | c.g))
, b(value_type((value_type(c.b) << 8) | c.b))
, a(value_type((value_type(c.a) << 8) | c.a))
{}
//--------------------------------------------------------------------
rgba16(const srgba8& c) :
r(sRGB_conv<value_type>::rgb_from_sRGB(c.r)),
g(sRGB_conv<value_type>::rgb_from_sRGB(c.g)),
b(sRGB_conv<value_type>::rgb_from_sRGB(c.b)),
a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}
rgba16(const srgba8& c)
: r(sRGB_conv<value_type>::rgb_from_sRGB(c.r))
, g(sRGB_conv<value_type>::rgb_from_sRGB(c.g))
, b(sRGB_conv<value_type>::rgb_from_sRGB(c.b))
, a(sRGB_conv<value_type>::alpha_from_sRGB(c.a))
{}
//--------------------------------------------------------------------
operator rgba() const
{
return rgba(
r / 65535.0,
g / 65535.0,
b / 65535.0,
a / 65535.0);
}
operator rgba() const { return rgba(r / 65535.0, g / 65535.0, b / 65535.0, a / 65535.0); }
//--------------------------------------------------------------------
operator rgba8() const
{
return rgba8(r >> 8, g >> 8, b >> 8, a >> 8);
}
operator rgba8() const { return rgba8(r >> 8, g >> 8, b >> 8, a >> 8); }
//--------------------------------------------------------------------
operator srgba8() const
{
// Return (non-premultiplied) sRGB values.
return srgba8(
sRGB_conv<value_type>::rgb_to_sRGB(r),
return srgba8(sRGB_conv<value_type>::rgb_to_sRGB(r),
sRGB_conv<value_type>::rgb_to_sRGB(g),
sRGB_conv<value_type>::rgb_to_sRGB(b),
sRGB_conv<value_type>::alpha_to_sRGB(a));
}
//--------------------------------------------------------------------
static AGG_INLINE double to_double(value_type a)
{
return static_cast<double>(a) / static_cast<double>(base_mask);
}
static AGG_INLINE double to_double(value_type a) { return static_cast<double>(a) / static_cast<double>(base_mask); }
//--------------------------------------------------------------------
static AGG_INLINE value_type from_double(double a)
@ -771,34 +753,19 @@ struct rgba16
}
//--------------------------------------------------------------------
static AGG_INLINE value_type empty_value()
{
return 0;
}
static AGG_INLINE value_type empty_value() { return 0; }
//--------------------------------------------------------------------
static AGG_INLINE value_type full_value()
{
return base_mask;
}
static AGG_INLINE value_type full_value() { return base_mask; }
//--------------------------------------------------------------------
AGG_INLINE bool is_transparent() const
{
return a == 0;
}
AGG_INLINE bool is_transparent() const { return a == 0; }
//--------------------------------------------------------------------
AGG_INLINE bool is_opaque() const
{
return a == base_mask;
}
AGG_INLINE bool is_opaque() const { return a == base_mask; }
//--------------------------------------------------------------------
static AGG_INLINE value_type invert(value_type x)
{
return base_mask - x;
}
static AGG_INLINE value_type invert(value_type x) { return base_mask - x; }
//--------------------------------------------------------------------
// Fixed-point multiply, exact over int16u.
@ -819,7 +786,8 @@ struct rgba16
{
return base_mask;
}
else return value_type((a * base_mask + (b >> 1)) / b);
else
return value_type((a * base_mask + (b >> 1)) / b);
}
//--------------------------------------------------------------------
@ -839,23 +807,14 @@ struct rgba16
//--------------------------------------------------------------------
// Fixed-point multiply, almost exact over int16u.
// Specifically for multiplying a color component by a cover.
static AGG_INLINE value_type mult_cover(value_type a, cover_type b)
{
return multiply(a, (b << 8) | b);
}
static AGG_INLINE value_type mult_cover(value_type a, cover_type b) { return multiply(a, (b << 8) | b); }
//--------------------------------------------------------------------
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
{
return multiply((a << 8) | a, b) >> 8;
}
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return multiply((a << 8) | a, b) >> 8; }
//--------------------------------------------------------------------
// Interpolate p to q by a, assuming q is premultiplied by a.
static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a)
{
return p + q - multiply(p, a);
}
static AGG_INLINE value_type prelerp(value_type p, value_type q, value_type a) { return p + q - multiply(p, a); }
//--------------------------------------------------------------------
// Interpolate p to q by a.
@ -882,17 +841,16 @@ struct rgba16
//--------------------------------------------------------------------
AGG_INLINE self_type& opacity(double a_)
{
if (a_ < 0) a = 0;
if (a_ > 1) a = 1;
if (a_ < 0)
a = 0;
if (a_ > 1)
a = 1;
a = value_type(uround(a_ * double(base_mask)));
return *this;
}
//--------------------------------------------------------------------
double opacity() const
{
return double(a) / double(base_mask);
}
double opacity() const { return double(a) / double(base_mask); }
//--------------------------------------------------------------------
AGG_INLINE self_type& premultiply()
@ -1023,7 +981,6 @@ struct rgba16
}
};
//------------------------------------------------------rgba16_gamma_dir
template<class GammaLUT>
rgba16 rgba16_gamma_dir(rgba16 c, const GammaLUT& gamma)
@ -1055,59 +1012,63 @@ struct rgba32
rgba32() {}
//--------------------------------------------------------------------
rgba32(value_type r_, value_type g_, value_type b_, value_type a_= 1) :
r(r_), g(g_), b(b_), a(a_) {}
rgba32(value_type r_, value_type g_, value_type b_, value_type a_ = 1)
: r(r_)
, g(g_)
, b(b_)
, a(a_)
{}
//--------------------------------------------------------------------
rgba32(const self_type& c, float a_) :
r(c.r), g(c.g), b(c.b), a(a_) {}
rgba32(const self_type& c, float a_)
: r(c.r)
, g(c.g)
, b(c.b)
, a(a_)
{}
//--------------------------------------------------------------------
rgba32(const rgba& c) :
r(value_type(c.r)), g(value_type(c.g)), b(value_type(c.b)), a(value_type(c.a)) {}
rgba32(const rgba& c)
: r(value_type(c.r))
, g(value_type(c.g))
, b(value_type(c.b))
, a(value_type(c.a))
{}
//--------------------------------------------------------------------
rgba32(const rgba8& c) :
r(value_type(c.r / 255.0)),
g(value_type(c.g / 255.0)),
b(value_type(c.b / 255.0)),
a(value_type(c.a / 255.0)) {}
rgba32(const rgba8& c)
: r(value_type(c.r / 255.0))
, g(value_type(c.g / 255.0))
, b(value_type(c.b / 255.0))
, a(value_type(c.a / 255.0))
{}
//--------------------------------------------------------------------
rgba32(const srgba8& c) :
r(sRGB_conv<value_type>::rgb_from_sRGB(c.r)),
g(sRGB_conv<value_type>::rgb_from_sRGB(c.g)),
b(sRGB_conv<value_type>::rgb_from_sRGB(c.b)),
a(sRGB_conv<value_type>::alpha_from_sRGB(c.a)) {}
rgba32(const srgba8& c)
: r(sRGB_conv<value_type>::rgb_from_sRGB(c.r))
, g(sRGB_conv<value_type>::rgb_from_sRGB(c.g))
, b(sRGB_conv<value_type>::rgb_from_sRGB(c.b))
, a(sRGB_conv<value_type>::alpha_from_sRGB(c.a))
{}
//--------------------------------------------------------------------
rgba32(const rgba16& c) :
r(value_type(c.r / 65535.0)),
g(value_type(c.g / 65535.0)),
b(value_type(c.b / 65535.0)),
a(value_type(c.a / 65535.0)) {}
rgba32(const rgba16& c)
: r(value_type(c.r / 65535.0))
, g(value_type(c.g / 65535.0))
, b(value_type(c.b / 65535.0))
, a(value_type(c.a / 65535.0))
{}
//--------------------------------------------------------------------
operator rgba() const
{
return rgba(r, g, b, a);
}
operator rgba() const { return rgba(r, g, b, a); }
//--------------------------------------------------------------------
operator rgba8() const
{
return rgba8(
uround(r * 255.0),
uround(g * 255.0),
uround(b * 255.0),
uround(a * 255.0));
}
operator rgba8() const { return rgba8(uround(r * 255.0), uround(g * 255.0), uround(b * 255.0), uround(a * 255.0)); }
//--------------------------------------------------------------------
operator srgba8() const
{
return srgba8(
sRGB_conv<value_type>::rgb_to_sRGB(r),
return srgba8(sRGB_conv<value_type>::rgb_to_sRGB(r),
sRGB_conv<value_type>::rgb_to_sRGB(g),
sRGB_conv<value_type>::rgb_to_sRGB(b),
sRGB_conv<value_type>::alpha_to_sRGB(a));
@ -1116,66 +1077,35 @@ struct rgba32
//--------------------------------------------------------------------
operator rgba16() const
{
return rgba8(
uround(r * 65535.0),
uround(g * 65535.0),
uround(b * 65535.0),
uround(a * 65535.0));
return rgba8(uround(r * 65535.0), uround(g * 65535.0), uround(b * 65535.0), uround(a * 65535.0));
}
//--------------------------------------------------------------------
static AGG_INLINE double to_double(value_type a)
{
return a;
}
static AGG_INLINE double to_double(value_type a) { return a; }
//--------------------------------------------------------------------
static AGG_INLINE value_type from_double(double a)
{
return value_type(a);
}
static AGG_INLINE value_type from_double(double a) { return value_type(a); }
//--------------------------------------------------------------------
static AGG_INLINE value_type empty_value()
{
return 0;
}
static AGG_INLINE value_type empty_value() { return 0; }
//--------------------------------------------------------------------
static AGG_INLINE value_type full_value()
{
return 1;
}
static AGG_INLINE value_type full_value() { return 1; }
//--------------------------------------------------------------------
AGG_INLINE bool is_transparent() const
{
return a <= 0;
}
AGG_INLINE bool is_transparent() const { return a <= 0; }
//--------------------------------------------------------------------
AGG_INLINE bool is_opaque() const
{
return a >= 1;
}
AGG_INLINE bool is_opaque() const { return a >= 1; }
//--------------------------------------------------------------------
static AGG_INLINE value_type invert(value_type x)
{
return 1 - x;
}
static AGG_INLINE value_type invert(value_type x) { return 1 - x; }
//--------------------------------------------------------------------
static AGG_INLINE value_type multiply(value_type a, value_type b)
{
return value_type(a * b);
}
static AGG_INLINE value_type multiply(value_type a, value_type b) { return value_type(a * b); }
//--------------------------------------------------------------------
static AGG_INLINE value_type demultiply(value_type a, value_type b)
{
return (b == 0) ? 0 : value_type(a / b);
}
static AGG_INLINE value_type demultiply(value_type a, value_type b) { return (b == 0) ? 0 : value_type(a / b); }
//--------------------------------------------------------------------
template<typename T>
@ -1198,10 +1128,7 @@ struct rgba32
}
//--------------------------------------------------------------------
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b)
{
return cover_type(uround(a * b));
}
static AGG_INLINE cover_type scale_cover(cover_type a, value_type b) { return cover_type(uround(a * b)); }
//--------------------------------------------------------------------
// Interpolate p to q by a, assuming q is premultiplied by a.
@ -1238,17 +1165,17 @@ struct rgba32
//--------------------------------------------------------------------
AGG_INLINE self_type& opacity(double a_)
{
if (a_ < 0) a = 0;
else if (a_ > 1) a = 1;
else a = value_type(a_);
if (a_ < 0)
a = 0;
else if (a_ > 1)
a = 1;
else
a = value_type(a_);
return *this;
}
//--------------------------------------------------------------------
double opacity() const
{
return a;
}
double opacity() const { return a; }
//--------------------------------------------------------------------
AGG_INLINE self_type& premultiply()
@ -1324,10 +1251,14 @@ struct rgba32
b += mult_cover(c.b, cover);
a += mult_cover(c.a, cover);
}
if (a > 1) a = 1;
if (r > a) r = a;
if (g > a) g = a;
if (b > a) b = a;
if (a > 1)
a = 1;
if (r > a)
r = a;
if (g > a)
g = a;
if (b > a)
b = a;
}
//--------------------------------------------------------------------
@ -1357,8 +1288,6 @@ struct rgba32
return self_type(rgba::from_wavelength(wl, gamma));
}
};
}
} // namespace agg
#endif

1
deps/agg/include/agg_config.h vendored
View file

@ -26,7 +26,6 @@
// but it won't result any crash and the rest of the library will remain
// fully functional.
//---------------------------------------
// 2. Default rendering_buffer type. Can be:
//

31
deps/agg/include/agg_conv_adaptor_vcgen.h vendored
View file

@ -18,8 +18,7 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//------------------------------------------------------------null_markers
struct null_markers
{
@ -32,23 +31,16 @@ namespace agg
unsigned type() const { return 0; }
};
//------------------------------------------------------conv_adaptor_vcgen
template<class VertexSource,
class Generator,
class Markers=null_markers> class conv_adaptor_vcgen
template<class VertexSource, class Generator, class Markers = null_markers>
class conv_adaptor_vcgen
{
enum status
{
initial,
accumulate,
generate
};
enum status { initial, accumulate, generate };
public:
explicit conv_adaptor_vcgen(VertexSource& source) :
m_source(&source),
m_status(initial)
explicit conv_adaptor_vcgen(VertexSource& source)
: m_source(&source)
, m_status(initial)
{}
conv_adaptor_vcgen(conv_adaptor_vcgen<VertexSource, Generator, Markers>&&) = default;
@ -85,10 +77,6 @@ namespace agg
double m_start_y;
};
//------------------------------------------------------------------------
template<class VertexSource, class Generator, class Markers>
unsigned conv_adaptor_vcgen<VertexSource, Generator, Markers>::vertex(double* x, double* y)
@ -105,7 +93,8 @@ namespace agg
m_status = accumulate;
case accumulate:
if(is_stop(m_last_cmd)) return path_cmd_stop;
if (is_stop(m_last_cmd))
return path_cmd_stop;
m_generator.remove_all();
m_generator.add_vertex(m_start_x, m_start_y, path_cmd_move_to);
@ -157,6 +146,6 @@ namespace agg
return cmd;
}
}
} // namespace agg
#endif

32
deps/agg/include/agg_conv_adaptor_vpgen.h vendored
View file

@ -18,14 +18,16 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//======================================================conv_adaptor_vpgen
template<class VertexSource, class VPGen> class conv_adaptor_vpgen
template<class VertexSource, class VPGen>
class conv_adaptor_vpgen
{
public:
explicit conv_adaptor_vpgen(VertexSource& source) : m_source(&source) {}
explicit conv_adaptor_vpgen(VertexSource& source)
: m_source(&source)
{}
void attach(VertexSource& source) { m_source = &source; }
VPGen& vpgen() { return m_vpgen; }
@ -37,8 +39,7 @@ namespace agg
private:
conv_adaptor_vpgen(const conv_adaptor_vpgen<VertexSource, VPGen>&);
const conv_adaptor_vpgen<VertexSource, VPGen>&
operator = (const conv_adaptor_vpgen<VertexSource, VPGen>&);
const conv_adaptor_vpgen<VertexSource, VPGen>& operator=(const conv_adaptor_vpgen<VertexSource, VPGen>&);
VertexSource* m_source;
VPGen m_vpgen;
@ -48,8 +49,6 @@ namespace agg
int m_vertices;
};
//------------------------------------------------------------------------
template<class VertexSource, class VPGen>
void conv_adaptor_vpgen<VertexSource, VPGen>::rewind(unsigned path_id)
@ -62,7 +61,6 @@ namespace agg
m_vertices = 0;
}
//------------------------------------------------------------------------
template<class VertexSource, class VPGen>
unsigned conv_adaptor_vpgen<VertexSource, VPGen>::vertex(double* x, double* y)
@ -71,7 +69,8 @@ namespace agg
for (;;)
{
cmd = m_vpgen.vertex(x, y);
if(!is_stop(cmd)) break;
if (!is_stop(cmd))
break;
if (m_poly_flags && !m_vpgen.auto_unclose())
{
@ -103,8 +102,7 @@ namespace agg
if (m_vpgen.auto_close() && m_vertices > 2)
{
m_vpgen.line_to(m_start_x, m_start_y);
m_poly_flags = path_cmd_end_poly
| static_cast<path_commands_e>(path_flags_close);
m_poly_flags = path_cmd_end_poly | static_cast<path_commands_e>(path_flags_close);
m_start_x = tx;
m_start_y = ty;
m_vertices = -1;
@ -128,7 +126,8 @@ namespace agg
m_poly_flags = cmd;
if (is_closed(cmd) || m_vpgen.auto_close())
{
if(m_vpgen.auto_close()) m_poly_flags |= path_flags_close;
if (m_vpgen.auto_close())
m_poly_flags |= path_flags_close;
if (m_vertices > 2)
{
m_vpgen.line_to(m_start_x, m_start_y);
@ -142,8 +141,7 @@ namespace agg
if (m_vpgen.auto_close() && m_vertices > 2)
{
m_vpgen.line_to(m_start_x, m_start_y);
m_poly_flags = path_cmd_end_poly
| static_cast<path_commands_e>(path_flags_close);
m_poly_flags = path_cmd_end_poly | static_cast<path_commands_e>(path_flags_close);
m_vertices = -2;
continue;
}
@ -154,8 +152,6 @@ namespace agg
return cmd;
}
}
} // namespace agg
#endif

16
deps/agg/include/agg_conv_bspline.h vendored
View file

@ -19,9 +19,7 @@
#include "agg_vcgen_bspline.h"
#include "agg_conv_adaptor_vcgen.h"
namespace agg
{
namespace agg {
//---------------------------------------------------------conv_bspline
template<class VertexSource>
@ -29,20 +27,18 @@ namespace agg
{
typedef conv_adaptor_vcgen<VertexSource, vcgen_bspline> base_type;
conv_bspline(VertexSource& vs) :
conv_adaptor_vcgen<VertexSource, vcgen_bspline>(vs) {}
conv_bspline(VertexSource& vs)
: conv_adaptor_vcgen<VertexSource, vcgen_bspline>(vs)
{}
void interpolation_step(double v) { base_type::generator().interpolation_step(v); }
double interpolation_step() const { return base_type::generator().interpolation_step(); }
private:
conv_bspline(const conv_bspline<VertexSource>&);
const conv_bspline<VertexSource>&
operator = (const conv_bspline<VertexSource>&);
const conv_bspline<VertexSource>& operator=(const conv_bspline<VertexSource>&);
};
}
} // namespace agg
#endif

18
deps/agg/include/agg_conv_clip_polygon.h vendored
View file

@ -30,8 +30,7 @@
#include "agg_conv_adaptor_vpgen.h"
#include "agg_vpgen_clip_polygon.h"
namespace agg
{
namespace agg {
//=======================================================conv_clip_polygon
template<class VertexSource>
@ -39,13 +38,11 @@ namespace agg
{
typedef conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon> base_type;
conv_clip_polygon(VertexSource& vs) :
conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon>(vs) {}
conv_clip_polygon(VertexSource& vs)
: conv_adaptor_vpgen<VertexSource, vpgen_clip_polygon>(vs)
{}
void clip_box(double _x1, double _y1, double _x2, double _y2)
{
base_type::vpgen().clip_box(_x1, _y1, _x2, _y2);
}
void clip_box(double _x1, double _y1, double _x2, double _y2) { base_type::vpgen().clip_box(_x1, _y1, _x2, _y2); }
double x1() const { return base_type::vpgen().x1(); }
double y1() const { return base_type::vpgen().y1(); }
@ -55,10 +52,9 @@ namespace agg
private:
conv_clip_polygon(const conv_clip_polygon<VertexSource>&);
const conv_clip_polygon<VertexSource>&
operator = (const conv_clip_polygon<VertexSource>&);
const conv_clip_polygon<VertexSource>& operator=(const conv_clip_polygon<VertexSource>&);
};
}
} // namespace agg
#endif

18
deps/agg/include/agg_conv_clip_polyline.h vendored
View file

@ -30,8 +30,7 @@
#include "agg_conv_adaptor_vpgen.h"
#include "agg_vpgen_clip_polyline.h"
namespace agg
{
namespace agg {
//=======================================================conv_clip_polyline
template<class VertexSource>
@ -39,13 +38,11 @@ namespace agg
{
typedef conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline> base_type;
conv_clip_polyline(VertexSource& vs) :
conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline>(vs) {}
conv_clip_polyline(VertexSource& vs)
: conv_adaptor_vpgen<VertexSource, vpgen_clip_polyline>(vs)
{}
void clip_box(double _x1, double _y1, double _x2, double _y2)
{
base_type::vpgen().clip_box(_x1, _y1, _x2, _y2);
}
void clip_box(double _x1, double _y1, double _x2, double _y2) { base_type::vpgen().clip_box(_x1, _y1, _x2, _y2); }
double x1() const { return base_type::vpgen().x1(); }
double y1() const { return base_type::vpgen().y1(); }
@ -55,10 +52,9 @@ namespace agg
private:
conv_clip_polyline(const conv_clip_polyline<VertexSource>&);
const conv_clip_polyline<VertexSource>&
operator = (const conv_clip_polyline<VertexSource>&);
const conv_clip_polyline<VertexSource>& operator=(const conv_clip_polyline<VertexSource>&);
};
}
} // namespace agg
#endif

19
deps/agg/include/agg_conv_close_polygon.h vendored
View file

@ -18,14 +18,16 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//======================================================conv_close_polygon
template<class VertexSource> class conv_close_polygon
template<class VertexSource>
class conv_close_polygon
{
public:
explicit conv_close_polygon(VertexSource& vs) : m_source(&vs) {}
explicit conv_close_polygon(VertexSource& vs)
: m_source(&vs)
{}
void attach(VertexSource& source) { m_source = &source; }
void rewind(unsigned path_id);
@ -33,8 +35,7 @@ namespace agg
private:
conv_close_polygon(const conv_close_polygon<VertexSource>&);
const conv_close_polygon<VertexSource>&
operator = (const conv_close_polygon<VertexSource>&);
const conv_close_polygon<VertexSource>& operator=(const conv_close_polygon<VertexSource>&);
VertexSource* m_source;
unsigned m_cmd[2];
@ -44,8 +45,6 @@ namespace agg
bool m_line_to;
};
//------------------------------------------------------------------------
template<class VertexSource>
void conv_close_polygon<VertexSource>::rewind(unsigned path_id)
@ -55,8 +54,6 @@ namespace agg
m_line_to = false;
}
//------------------------------------------------------------------------
template<class VertexSource>
unsigned conv_close_polygon<VertexSource>::vertex(double* x, double* y)
@ -120,6 +117,6 @@ namespace agg
return cmd;
}
}
} // namespace agg
#endif

27
deps/agg/include/agg_conv_concat.h vendored
View file

@ -18,20 +18,22 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//=============================================================conv_concat
// Concatenation of two paths. Usually used to combine lines or curves
// with markers such as arrowheads
template<class VS1, class VS2> class conv_concat
template<class VS1, class VS2>
class conv_concat
{
public:
conv_concat(VS1& source1, VS2& source2) :
m_source1(&source1), m_source2(&source2), m_status(2) {}
conv_concat(VS1& source1, VS2& source2)
: m_source1(&source1)
, m_source2(&source2)
, m_status(2)
{}
void attach1(VS1& source) { m_source1 = &source; }
void attach2(VS2& source) { m_source2 = &source; }
void rewind(unsigned path_id)
{
m_source1->rewind(path_id);
@ -45,13 +47,15 @@ namespace agg
if (m_status == 0)
{
cmd = m_source1->vertex(x, y);
if(!is_stop(cmd)) return cmd;
if (!is_stop(cmd))
return cmd;
m_status = 1;
}
if (m_status == 1)
{
cmd = m_source2->vertex(x, y);
if(!is_stop(cmd)) return cmd;
if (!is_stop(cmd))
return cmd;
m_status = 2;
}
return path_cmd_stop;
@ -59,15 +63,12 @@ namespace agg
private:
conv_concat(const conv_concat<VS1, VS2>&);
const conv_concat<VS1, VS2>&
operator = (const conv_concat<VS1, VS2>&);
const conv_concat<VS1, VS2>& operator=(const conv_concat<VS1, VS2>&);
VS1* m_source1;
VS2* m_source2;
int m_status;
};
}
} // namespace agg
#endif

15
deps/agg/include/agg_conv_contour.h vendored
View file

@ -23,8 +23,7 @@
#include "agg_vcgen_contour.h"
#include "agg_conv_adaptor_vcgen.h"
namespace agg
{
namespace agg {
//-----------------------------------------------------------conv_contour
template<class VertexSource>
@ -32,10 +31,9 @@ namespace agg
{
typedef conv_adaptor_vcgen<VertexSource, vcgen_contour> base_type;
conv_contour(VertexSource& vs) :
conv_adaptor_vcgen<VertexSource, vcgen_contour>(vs)
{
}
conv_contour(VertexSource& vs)
: conv_adaptor_vcgen<VertexSource, vcgen_contour>(vs)
{}
void line_join(line_join_e lj) { base_type::generator().line_join(lj); }
void inner_join(inner_join_e ij) { base_type::generator().inner_join(ij); }
@ -56,10 +54,9 @@ namespace agg
private:
conv_contour(const conv_contour<VertexSource>&);
const conv_contour<VertexSource>&
operator = (const conv_contour<VertexSource>&);
const conv_contour<VertexSource>& operator=(const conv_contour<VertexSource>&);
};
}
} // namespace agg
#endif

53
deps/agg/include/agg_conv_curve.h vendored
View file

@ -23,9 +23,7 @@
#include "agg_basics.h"
#include "agg_curves.h"
namespace agg
{
namespace agg {
//---------------------------------------------------------------conv_curve
// Curve converter class. Any path storage can have Bezier curves defined
@ -51,17 +49,19 @@ namespace agg
// Class conv_curve recognizes commands path_cmd_curve3 and path_cmd_curve4
// and converts these vertices into a move_to/line_to sequence.
//-----------------------------------------------------------------------
template<class VertexSource,
class Curve3=curve3,
class Curve4=curve4> class conv_curve
template<class VertexSource, class Curve3 = curve3, class Curve4 = curve4>
class conv_curve
{
public:
typedef Curve3 curve3_type;
typedef Curve4 curve4_type;
typedef conv_curve<VertexSource, Curve3, Curve4> self_type;
explicit conv_curve(VertexSource& source) :
m_source(&source), m_last_x(0.0), m_last_y(0.0) {}
explicit conv_curve(VertexSource& source)
: m_source(&source)
, m_last_x(0.0)
, m_last_y(0.0)
{}
conv_curve(self_type&&) = default;
@ -73,10 +73,7 @@ namespace agg
m_curve4.approximation_method(v);
}
curve_approximation_method_e approximation_method() const
{
return m_curve4.approximation_method();
}
curve_approximation_method_e approximation_method() const { return m_curve4.approximation_method(); }
void approximation_scale(double s)
{
@ -84,10 +81,7 @@ namespace agg
m_curve4.approximation_scale(s);
}
double approximation_scale() const
{
return m_curve4.approximation_scale();
}
double approximation_scale() const { return m_curve4.approximation_scale(); }
void angle_tolerance(double v)
{
@ -95,10 +89,7 @@ namespace agg
m_curve4.angle_tolerance(v);
}
double angle_tolerance() const
{
return m_curve4.angle_tolerance();
}
double angle_tolerance() const { return m_curve4.angle_tolerance(); }
void cusp_limit(double v)
{
@ -106,10 +97,7 @@ namespace agg
m_curve4.cusp_limit(v);
}
double cusp_limit() const
{
return m_curve4.cusp_limit();
}
double cusp_limit() const { return m_curve4.cusp_limit(); }
void rewind(unsigned path_id);
unsigned vertex(double* x, double* y);
@ -125,8 +113,6 @@ namespace agg
curve4_type m_curve4;
};
//------------------------------------------------------------------------
template<class VertexSource, class Curve3, class Curve4>
void conv_curve<VertexSource, Curve3, Curve4>::rewind(unsigned path_id)
@ -138,7 +124,6 @@ namespace agg
m_curve4.reset();
}
//------------------------------------------------------------------------
template<class VertexSource, class Curve3, class Curve4>
unsigned conv_curve<VertexSource, Curve3, Curve4>::vertex(double* x, double* y)
@ -168,9 +153,7 @@ namespace agg
case path_cmd_curve3:
m_source->vertex(&end_x, &end_y);
m_curve3.init(m_last_x, m_last_y,
*x, *y,
end_x, end_y);
m_curve3.init(m_last_x, m_last_y, *x, *y, end_x, end_y);
m_curve3.vertex(x, y); // First call returns path_cmd_move_to
m_curve3.vertex(x, y); // This is the first vertex of the curve
@ -181,10 +164,7 @@ namespace agg
m_source->vertex(&ct2_x, &ct2_y);
m_source->vertex(&end_x, &end_y);
m_curve4.init(m_last_x, m_last_y,
*x, *y,
ct2_x, ct2_y,
end_x, end_y);
m_curve4.init(m_last_x, m_last_y, *x, *y, ct2_x, ct2_y, end_x, end_y);
m_curve4.vertex(x, y); // First call returns path_cmd_move_to
m_curve4.vertex(x, y); // This is the first vertex of the curve
@ -196,9 +176,6 @@ namespace agg
return cmd;
}
}
} // namespace agg
#endif

31
deps/agg/include/agg_conv_dash.h vendored
View file

@ -23,8 +23,7 @@
#include "agg_vcgen_dash.h"
#include "agg_conv_adaptor_vcgen.h"
namespace agg
{
namespace agg {
//---------------------------------------------------------------conv_dash
template<class VertexSource, class Markers = null_markers>
@ -33,36 +32,24 @@ namespace agg
typedef Markers marker_type;
typedef conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers> base_type;
conv_dash(VertexSource& vs) :
conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers>(vs)
{
}
conv_dash(VertexSource& vs)
: conv_adaptor_vcgen<VertexSource, vcgen_dash, Markers>(vs)
{}
void remove_all_dashes()
{
base_type::generator().remove_all_dashes();
}
void remove_all_dashes() { base_type::generator().remove_all_dashes(); }
void add_dash(double dash_len, double gap_len)
{
base_type::generator().add_dash(dash_len, gap_len);
}
void add_dash(double dash_len, double gap_len) { base_type::generator().add_dash(dash_len, gap_len); }
void dash_start(double ds)
{
base_type::generator().dash_start(ds);
}
void dash_start(double ds) { base_type::generator().dash_start(ds); }
void shorten(double s) { base_type::generator().shorten(s); }
double shorten() const { return base_type::generator().shorten(); }
private:
conv_dash(const conv_dash<VertexSource, Markers>&);
const conv_dash<VertexSource, Markers>&
operator = (const conv_dash<VertexSource, Markers>&);
const conv_dash<VertexSource, Markers>& operator=(const conv_dash<VertexSource, Markers>&);
};
}
} // namespace agg
#endif

101
deps/agg/include/agg_conv_gpc.h vendored
View file

@ -28,32 +28,18 @@
#include "agg_basics.h"
#include "agg_array.h"
extern "C"
{
extern "C" {
#include "gpc.h"
}
namespace agg
{
enum gpc_op_e
{
gpc_or,
gpc_and,
gpc_xor,
gpc_a_minus_b,
gpc_b_minus_a
};
namespace agg {
enum gpc_op_e { gpc_or, gpc_and, gpc_xor, gpc_a_minus_b, gpc_b_minus_a };
//================================================================conv_gpc
template<class VSA, class VSB> class conv_gpc
template<class VSA, class VSB>
class conv_gpc
{
enum status
{
status_move_to,
status_line_to,
status_stop
};
enum status { status_move_to, status_line_to, status_stop };
struct contour_header_type
{
@ -65,24 +51,20 @@ namespace agg
typedef pod_bvector<gpc_vertex, 8> vertex_array_type;
typedef pod_bvector<contour_header_type, 6> contour_header_array_type;
public:
typedef VSA source_a_type;
typedef VSB source_b_type;
typedef conv_gpc<source_a_type, source_b_type> self_type;
~conv_gpc()
{
free_gpc_data();
}
~conv_gpc() { free_gpc_data(); }
conv_gpc(source_a_type& a, source_b_type& b, gpc_op_e op = gpc_or) :
m_src_a(&a),
m_src_b(&b),
m_status(status_move_to),
m_vertex(-1),
m_contour(-1),
m_operation(op)
conv_gpc(source_a_type& a, source_b_type& b, gpc_op_e op = gpc_or)
: m_src_a(&a)
, m_src_b(&b)
, m_status(status_move_to)
, m_vertex(-1)
, m_contour(-1)
, m_operation(op)
{
memset(&m_poly_a, 0, sizeof(m_poly_a));
memset(&m_poly_b, 0, sizeof(m_poly_b));
@ -114,9 +96,9 @@ namespace agg
bool next_contour();
bool next_vertex(double* x, double* y);
//--------------------------------------------------------------------
template<class VS> void add(VS& src, gpc_polygon& p)
template<class VS>
void add(VS& src, gpc_polygon& p)
{
unsigned cmd;
double x, y;
@ -164,7 +146,6 @@ namespace agg
make_polygon(p);
}
private:
//--------------------------------------------------------------------
source_a_type* m_src_a;
@ -180,10 +161,6 @@ namespace agg
gpc_polygon m_result;
};
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::free_polygon(gpc_polygon& p)
@ -191,14 +168,12 @@ namespace agg
int i;
for (i = 0; i < p.num_contours; i++)
{
pod_allocator<gpc_vertex>::deallocate(p.contour[i].vertex,
p.contour[i].num_vertices);
pod_allocator<gpc_vertex>::deallocate(p.contour[i].vertex, p.contour[i].num_vertices);
}
pod_allocator<gpc_vertex_list>::deallocate(p.contour, p.num_contours);
memset(&p, 0, sizeof(gpc_polygon));
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::free_result()
@ -210,7 +185,6 @@ namespace agg
memset(&m_result, 0, sizeof(m_result));
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::free_gpc_data()
@ -220,7 +194,6 @@ namespace agg
free_result();
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::start_contour()
@ -231,7 +204,6 @@ namespace agg
m_vertex_accumulator.remove_all();
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
inline void conv_gpc<VSA, VSB>::add_vertex(double x, double y)
@ -242,7 +214,6 @@ namespace agg
m_vertex_accumulator.add(v);
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::end_contour(unsigned orientation)
@ -251,8 +222,7 @@ namespace agg
{
if (m_vertex_accumulator.size() > 2)
{
contour_header_type& h =
m_contour_accumulator[m_contour_accumulator.size() - 1];
contour_header_type& h = m_contour_accumulator[m_contour_accumulator.size() - 1];
h.num_vertices = m_vertex_accumulator.size();
h.hole_flag = 0;
@ -278,7 +248,6 @@ namespace agg
}
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::make_polygon(gpc_polygon& p)
@ -303,7 +272,6 @@ namespace agg
}
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::start_extracting()
@ -313,7 +281,6 @@ namespace agg
m_vertex = -1;
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
bool conv_gpc<VSA, VSB>::next_contour()
@ -326,7 +293,6 @@ namespace agg
return false;
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
inline bool conv_gpc<VSA, VSB>::next_vertex(double* x, double* y)
@ -342,7 +308,6 @@ namespace agg
return false;
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
void conv_gpc<VSA, VSB>::rewind(unsigned path_id)
@ -355,44 +320,28 @@ namespace agg
switch (m_operation)
{
case gpc_or:
gpc_polygon_clip(GPC_UNION,
&m_poly_a,
&m_poly_b,
&m_result);
gpc_polygon_clip(GPC_UNION, &m_poly_a, &m_poly_b, &m_result);
break;
case gpc_and:
gpc_polygon_clip(GPC_INT,
&m_poly_a,
&m_poly_b,
&m_result);
gpc_polygon_clip(GPC_INT, &m_poly_a, &m_poly_b, &m_result);
break;
case gpc_xor:
gpc_polygon_clip(GPC_XOR,
&m_poly_a,
&m_poly_b,
&m_result);
gpc_polygon_clip(GPC_XOR, &m_poly_a, &m_poly_b, &m_result);
break;
case gpc_a_minus_b:
gpc_polygon_clip(GPC_DIFF,
&m_poly_a,
&m_poly_b,
&m_result);
gpc_polygon_clip(GPC_DIFF, &m_poly_a, &m_poly_b, &m_result);
break;
case gpc_b_minus_a:
gpc_polygon_clip(GPC_DIFF,
&m_poly_b,
&m_poly_a,
&m_result);
gpc_polygon_clip(GPC_DIFF, &m_poly_b, &m_poly_a, &m_result);
break;
}
start_extracting();
}
//------------------------------------------------------------------------
template<class VSA, class VSB>
unsigned conv_gpc<VSA, VSB>::vertex(double* x, double* y)
@ -425,8 +374,6 @@ namespace agg
return path_cmd_stop;
}
}
} // namespace agg
#endif

36
deps/agg/include/agg_conv_marker.h vendored
View file

@ -22,8 +22,7 @@
#include "agg_basics.h"
#include "agg_trans_affine.h"
namespace agg
{
namespace agg {
//-------------------------------------------------------------conv_marker
template<class MarkerLocator, class MarkerShapes>
class conv_marker
@ -39,16 +38,9 @@ namespace agg
private:
conv_marker(const conv_marker<MarkerLocator, MarkerShapes>&);
const conv_marker<MarkerLocator, MarkerShapes>&
operator = (const conv_marker<MarkerLocator, MarkerShapes>&);
const conv_marker<MarkerLocator, MarkerShapes>& operator=(const conv_marker<MarkerLocator, MarkerShapes>&);
enum status_e
{
initial,
markers,
polygon,
stop
};
enum status_e { initial, markers, polygon, stop };
MarkerLocator* m_marker_locator;
MarkerShapes* m_marker_shapes;
@ -59,18 +51,15 @@ namespace agg
unsigned m_num_markers;
};
//------------------------------------------------------------------------
template<class MarkerLocator, class MarkerShapes>
conv_marker<MarkerLocator, MarkerShapes>::conv_marker(MarkerLocator& ml, MarkerShapes& ms) :
m_marker_locator(&ml),
m_marker_shapes(&ms),
m_status(initial),
m_marker(0),
m_num_markers(1)
{
}
conv_marker<MarkerLocator, MarkerShapes>::conv_marker(MarkerLocator& ml, MarkerShapes& ms)
: m_marker_locator(&ml)
, m_marker_shapes(&ms)
, m_status(initial)
, m_marker(0)
, m_num_markers(1)
{}
//------------------------------------------------------------------------
template<class MarkerLocator, class MarkerShapes>
@ -81,7 +70,6 @@ namespace agg
m_num_markers = 1;
}
//------------------------------------------------------------------------
template<class MarkerLocator, class MarkerShapes>
unsigned conv_marker<MarkerLocator, MarkerShapes>::vertex(double* x, double* y)
@ -141,8 +129,6 @@ namespace agg
return cmd;
}
}
} // namespace agg
#endif

19
deps/agg/include/agg_conv_marker_adaptor.h vendored
View file

@ -20,32 +20,27 @@
#include "agg_conv_adaptor_vcgen.h"
#include "agg_vcgen_vertex_sequence.h"
namespace agg
{
namespace agg {
//=====================================================conv_marker_adaptor
template<class VertexSource, class Markers = null_markers>
struct conv_marker_adaptor :
public conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers>
struct conv_marker_adaptor : public conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers>
{
typedef Markers marker_type;
typedef conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers> base_type;
conv_marker_adaptor(VertexSource& vs) :
conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers>(vs)
{
}
conv_marker_adaptor(VertexSource& vs)
: conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence, Markers>(vs)
{}
void shorten(double s) { base_type::generator().shorten(s); }
double shorten() const { return base_type::generator().shorten(); }
private:
conv_marker_adaptor(const conv_marker_adaptor<VertexSource, Markers>&);
const conv_marker_adaptor<VertexSource, Markers>&
operator = (const conv_marker_adaptor<VertexSource, Markers>&);
const conv_marker_adaptor<VertexSource, Markers>& operator=(const conv_marker_adaptor<VertexSource, Markers>&);
};
}
} // namespace agg
#endif

59
deps/agg/include/agg_conv_offset.h vendored
View file

@ -22,10 +22,10 @@
#include "agg_array.h"
#include "clipper.hpp"
namespace agg
{
namespace agg {
template<class VSA> class conv_offset
template<class VSA>
class conv_offset
{
enum status { status_move_to, status_line_to, status_stop };
typedef VSA source_a_type;
@ -45,36 +45,30 @@ private:
int Round(double val)
{
if ((val < 0)) return (int)(val - 0.5); else return (int)(val + 0.5);
if ((val < 0))
return (int)(val - 0.5);
else
return (int)(val + 0.5);
}
public:
conv_offset(source_a_type &a, double offset = 0.0,
int scaling_factor = 0)
: m_src_a(&a),
m_offset(offset),
m_status(status_move_to),
m_vertex(-1),
m_contour(-1)
conv_offset(source_a_type& a, double offset = 0.0, int scaling_factor = 0)
: m_src_a(&a)
, m_offset(offset)
, m_status(status_move_to)
, m_vertex(-1)
, m_contour(-1)
{
m_scaling_factor = std::max(std::min(scaling_factor, 6), 0);
m_scaling_factor = Round(std::pow((double)10, m_scaling_factor));
}
~conv_offset()
{
}
~conv_offset() {}
void set_offset(double offset) { m_offset = offset; }
unsigned type() const
{
return static_cast<unsigned>(m_src_a->type());
}
unsigned type() const { return static_cast<unsigned>(m_src_a->type()); }
double get_offset() const
{
return m_offset;
}
double get_offset() const { return m_offset; }
void rewind(unsigned path_id);
unsigned vertex(double* x, double* y);
@ -85,10 +79,14 @@ public:
void add_vertex_(double& x, double& y);
void end_contour(ClipperLib::Paths& p);
template<class VS> void add(VS &src, ClipperLib::Paths &p)
template<class VS>
void add(VS& src, ClipperLib::Paths& p)
{
unsigned cmd;
double x; double y; double start_x; double start_y;
double x;
double y;
double start_x;
double start_y;
bool starting_first_line;
start_x = 0.0;
@ -103,7 +101,8 @@ public:
{
if (is_move_to(cmd))
{
if(!starting_first_line ) end_contour(p);
if (!starting_first_line)
end_contour(p);
start_x = x;
start_y = y;
}
@ -153,7 +152,8 @@ void conv_offset<VSA>::end_contour( ClipperLib::Paths &p)
{
unsigned i, len;
if( m_vertex_accumulator.size() < 3 ) return;
if (m_vertex_accumulator.size() < 3)
return;
len = p.size();
p.resize(len + 1);
p[len].resize(m_vertex_accumulator.size());
@ -178,7 +178,8 @@ template<class VSA>
bool conv_offset<VSA>::next_contour()
{
m_contour++;
if(m_contour >= (int)m_result.size()) return false;
if (m_contour >= (int)m_result.size())
return false;
m_vertex = -1;
return true;
}
@ -188,7 +189,8 @@ template<class VSA>
bool conv_offset<VSA>::next_vertex(double* x, double* y)
{
m_vertex++;
if(m_vertex >= (int)m_result[m_contour].size()) return false;
if (m_vertex >= (int)m_result[m_contour].size())
return false;
*x = (double)m_result[m_contour][m_vertex].X / m_scaling_factor;
*y = (double)m_result[m_contour][m_vertex].Y / m_scaling_factor;
return true;
@ -231,6 +233,5 @@ unsigned conv_offset<VSA>::vertex(double *x, double *y)
}
//------------------------------------------------------------------------------
} // namespace agg
#endif // AGG_CONV_OFFSET_INCLUDED

15
deps/agg/include/agg_conv_segmentator.h vendored
View file

@ -20,8 +20,7 @@
#include "agg_conv_adaptor_vpgen.h"
#include "agg_vpgen_segmentator.h"
namespace agg
{
namespace agg {
//========================================================conv_segmentator
template<class VertexSource>
@ -29,20 +28,18 @@ namespace agg
{
typedef conv_adaptor_vpgen<VertexSource, vpgen_segmentator> base_type;
conv_segmentator(VertexSource& vs) :
conv_adaptor_vpgen<VertexSource, vpgen_segmentator>(vs) {}
conv_segmentator(VertexSource& vs)
: conv_adaptor_vpgen<VertexSource, vpgen_segmentator>(vs)
{}
void approximation_scale(double s) { base_type::vpgen().approximation_scale(s); }
double approximation_scale() const { return base_type::vpgen().approximation_scale(); }
private:
conv_segmentator(const conv_segmentator<VertexSource>&);
const conv_segmentator<VertexSource>&
operator = (const conv_segmentator<VertexSource>&);
const conv_segmentator<VertexSource>& operator=(const conv_segmentator<VertexSource>&);
};
}
} // namespace agg
#endif

20
deps/agg/include/agg_conv_shorten_path.h vendored
View file

@ -20,31 +20,27 @@
#include "agg_conv_adaptor_vcgen.h"
#include "agg_vcgen_vertex_sequence.h"
namespace agg
{
namespace agg {
//=======================================================conv_shorten_path
template<class VertexSource> class conv_shorten_path :
public conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence>
template<class VertexSource>
class conv_shorten_path : public conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence>
{
public:
typedef conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence> base_type;
conv_shorten_path(VertexSource& vs) :
conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence>(vs)
{
}
conv_shorten_path(VertexSource& vs)
: conv_adaptor_vcgen<VertexSource, vcgen_vertex_sequence>(vs)
{}
void shorten(double s) { base_type::generator().shorten(s); }
double shorten() const { return base_type::generator().shorten(); }
private:
conv_shorten_path(const conv_shorten_path<VertexSource>&);
const conv_shorten_path<VertexSource>&
operator = (const conv_shorten_path<VertexSource>&);
const conv_shorten_path<VertexSource>& operator=(const conv_shorten_path<VertexSource>&);
};
}
} // namespace agg
#endif

36
deps/agg/include/agg_conv_smooth_poly1.h vendored
View file

@ -24,21 +24,17 @@
#include "agg_conv_adaptor_vcgen.h"
#include "agg_conv_curve.h"
namespace agg
{
namespace agg {
//-------------------------------------------------------conv_smooth
template<class VertexSource, class VertexGenerator>
struct conv_smooth :
public conv_adaptor_vcgen<VertexSource, VertexGenerator>
struct conv_smooth : public conv_adaptor_vcgen<VertexSource, VertexGenerator>
{
typedef conv_adaptor_vcgen<VertexSource, VertexGenerator> base_type;
conv_smooth(VertexSource& vs) :
conv_adaptor_vcgen<VertexSource, VertexGenerator>(vs)
{
}
conv_smooth(VertexSource& vs)
: conv_adaptor_vcgen<VertexSource, VertexGenerator>(vs)
{}
conv_smooth(conv_smooth<VertexSource, VertexGenerator>&&) = default;
@ -56,18 +52,16 @@ namespace agg
//-------------------------------------------------conv_smooth_curve
template<class VertexSource, class VertexGenerator>
struct conv_smooth_curve :
public conv_curve<conv_smooth<VertexSource, VertexGenerator>>
struct conv_smooth_curve : public conv_curve<conv_smooth<VertexSource, VertexGenerator>>
{
conv_smooth_curve(VertexSource& vs) :
conv_curve<conv_smooth<VertexSource, VertexGenerator>>(m_smooth),
m_smooth(vs)
{
}
conv_smooth_curve(VertexSource& vs)
: conv_curve<conv_smooth<VertexSource, VertexGenerator>>(m_smooth)
, m_smooth(vs)
{}
conv_smooth_curve(conv_smooth_curve<VertexSource, VertexGenerator> && rhs) :
conv_curve<conv_smooth<VertexSource, VertexGenerator>>(std::move(rhs)),
m_smooth(std::move(rhs.m_smooth))
conv_smooth_curve(conv_smooth_curve<VertexSource, VertexGenerator>&& rhs)
: conv_curve<conv_smooth<VertexSource, VertexGenerator>>(std::move(rhs))
, m_smooth(std::move(rhs.m_smooth))
{
this->attach(m_smooth);
}
@ -86,8 +80,6 @@ namespace agg
template<class VertexSource>
using conv_smooth_poly1_curve = conv_smooth_curve<VertexSource, vcgen_smooth_poly1>;
}
} // namespace agg
#endif

19
deps/agg/include/agg_conv_stroke.h vendored
View file

@ -23,21 +23,18 @@
#include "agg_vcgen_stroke.h"
#include "agg_conv_adaptor_vcgen.h"
namespace agg
{
namespace agg {
//-------------------------------------------------------------conv_stroke
template<class VertexSource, class Markers = null_markers>
struct conv_stroke :
public conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers>
struct conv_stroke : public conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers>
{
typedef Markers marker_type;
typedef conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers> base_type;
conv_stroke(VertexSource& vs) :
conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers>(vs)
{
}
conv_stroke(VertexSource& vs)
: conv_adaptor_vcgen<VertexSource, vcgen_stroke, Markers>(vs)
{}
void line_cap(line_cap_e lc) { base_type::generator().line_cap(lc); }
void line_join(line_join_e lj) { base_type::generator().line_join(lj); }
@ -63,11 +60,9 @@ namespace agg
private:
conv_stroke(const conv_stroke<VertexSource, Markers>&);
const conv_stroke<VertexSource, Markers>&
operator = (const conv_stroke<VertexSource, Markers>&);
const conv_stroke<VertexSource, Markers>& operator=(const conv_stroke<VertexSource, Markers>&);
};
}
} // namespace agg
#endif

28
deps/agg/include/agg_conv_transform.h vendored
View file

@ -22,22 +22,21 @@
#include "agg_basics.h"
#include "agg_trans_affine.h"
namespace agg
{
namespace agg {
//----------------------------------------------------------conv_transform
template<class VertexSource, class Transformer=trans_affine> class conv_transform
template<class VertexSource, class Transformer = trans_affine>
class conv_transform
{
public:
conv_transform(VertexSource& source, Transformer& tr) :
m_source(&source), m_trans(&tr) {}
conv_transform(VertexSource& source, Transformer& tr)
: m_source(&source)
, m_trans(&tr)
{}
void attach(VertexSource& source) { m_source = &source; }
void rewind(unsigned path_id)
{
m_source->rewind(path_id);
}
void rewind(unsigned path_id) { m_source->rewind(path_id); }
unsigned vertex(double* x, double* y)
{
@ -49,23 +48,18 @@ namespace agg
return cmd;
}
void transformer(Transformer& tr)
{
m_trans = &tr;
}
void transformer(Transformer& tr) { m_trans = &tr; }
unsigned type() const { return m_source->type(); }
private:
conv_transform(const conv_transform<VertexSource>&);
const conv_transform<VertexSource>&
operator = (const conv_transform<VertexSource>&);
const conv_transform<VertexSource>& operator=(const conv_transform<VertexSource>&);
VertexSource* m_source;
const Transformer* m_trans;
};
}
} // namespace agg
#endif

23
deps/agg/include/agg_conv_unclose_polygon.h vendored
View file

@ -18,35 +18,34 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//====================================================conv_unclose_polygon
template<class VertexSource> class conv_unclose_polygon
template<class VertexSource>
class conv_unclose_polygon
{
public:
explicit conv_unclose_polygon(VertexSource& vs) : m_source(&vs) {}
explicit conv_unclose_polygon(VertexSource& vs)
: m_source(&vs)
{}
void attach(VertexSource& source) { m_source = &source; }
void rewind(unsigned path_id)
{
m_source->rewind(path_id);
}
void rewind(unsigned path_id) { m_source->rewind(path_id); }
unsigned vertex(double* x, double* y)
{
unsigned cmd = m_source->vertex(x, y);
if(is_end_poly(cmd)) cmd &= ~path_flags_close;
if (is_end_poly(cmd))
cmd &= ~path_flags_close;
return cmd;
}
private:
conv_unclose_polygon(const conv_unclose_polygon<VertexSource>&);
const conv_unclose_polygon<VertexSource>&
operator = (const conv_unclose_polygon<VertexSource>&);
const conv_unclose_polygon<VertexSource>& operator=(const conv_unclose_polygon<VertexSource>&);
VertexSource* m_source;
};
}
} // namespace agg
#endif

420
deps/agg/include/agg_curves.h vendored
View file

@ -21,37 +21,37 @@
#include <mapnik/config.hpp>
namespace agg
{
namespace agg {
// See Implementation agg_curves.cpp
//--------------------------------------------curve_approximation_method_e
enum curve_approximation_method_e
{
curve_inc,
curve_div
};
enum curve_approximation_method_e { curve_inc, curve_div };
//--------------------------------------------------------------curve3_inc
class MAPNIK_DECL curve3_inc
{
public:
curve3_inc() :
m_num_steps(0), m_step(0), m_scale(1.0) { }
curve3_inc()
: m_num_steps(0)
, m_step(0)
, m_scale(1.0)
{}
curve3_inc(double x1, double y1,
double x2, double y2,
double x3, double y3) :
m_num_steps(0), m_step(0), m_scale(1.0)
curve3_inc(double x1, double y1, double x2, double y2, double x3, double y3)
: m_num_steps(0)
, m_step(0)
, m_scale(1.0)
{
init(x1, y1, x2, y2, x3, y3);
}
void reset() { m_num_steps = 0; m_step = -1; }
void init(double x1, double y1,
double x2, double y2,
double x3, double y3);
void reset()
{
m_num_steps = 0;
m_step = -1;
}
void init(double x1, double y1, double x2, double y2, double x3, double y3);
void approximation_method(curve_approximation_method_e) {}
curve_approximation_method_e approximation_method() const { return curve_inc; }
@ -88,34 +88,30 @@ namespace agg
double m_saved_dfy;
};
//-------------------------------------------------------------curve3_div
class MAPNIK_DECL curve3_div
{
public:
curve3_div() :
m_approximation_scale(1.0),
m_angle_tolerance(0.0),
m_count(0)
curve3_div()
: m_approximation_scale(1.0)
, m_angle_tolerance(0.0)
, m_count(0)
{}
curve3_div(double x1, double y1,
double x2, double y2,
double x3, double y3) :
m_approximation_scale(1.0),
m_angle_tolerance(0.0),
m_count(0)
curve3_div(double x1, double y1, double x2, double y2, double x3, double y3)
: m_approximation_scale(1.0)
, m_angle_tolerance(0.0)
, m_count(0)
{
init(x1, y1, x2, y2, x3, y3);
}
void reset() { m_points.remove_all(); m_count = 0; }
void init(double x1, double y1,
double x2, double y2,
double x3, double y3);
void reset()
{
m_points.remove_all();
m_count = 0;
}
void init(double x1, double y1, double x2, double y2, double x3, double y3);
void approximation_method(curve_approximation_method_e) {}
curve_approximation_method_e approximation_method() const { return curve_div; }
@ -129,14 +125,12 @@ namespace agg
void cusp_limit(double) {}
double cusp_limit() const { return 0.0; }
void rewind(unsigned)
{
m_count = 0;
}
void rewind(unsigned) { m_count = 0; }
unsigned vertex(double* x, double* y)
{
if(m_count >= m_points.size()) return path_cmd_stop;
if (m_count >= m_points.size())
return path_cmd_stop;
const point_d& p = m_points[m_count++];
*x = p.x;
*y = p.y;
@ -144,13 +138,8 @@ namespace agg
}
private:
void bezier(double x1, double y1,
double x2, double y2,
double x3, double y3);
void recursive_bezier(double x1, double y1,
double x2, double y2,
double x3, double y3,
unsigned level);
void bezier(double x1, double y1, double x2, double y2, double x3, double y3);
void recursive_bezier(double x1, double y1, double x2, double y2, double x3, double y3, unsigned level);
double m_approximation_scale;
double m_distance_tolerance_square;
@ -159,71 +148,71 @@ namespace agg
pod_bvector<point_d> m_points;
};
//-------------------------------------------------------------curve4_points
struct MAPNIK_DECL curve4_points
{
double cp[8];
curve4_points() {}
curve4_points(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4)
curve4_points(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
cp[0] = x1; cp[1] = y1; cp[2] = x2; cp[3] = y2;
cp[4] = x3; cp[5] = y3; cp[6] = x4; cp[7] = y4;
cp[0] = x1;
cp[1] = y1;
cp[2] = x2;
cp[3] = y2;
cp[4] = x3;
cp[5] = y3;
cp[6] = x4;
cp[7] = y4;
}
void init(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4)
void init(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
cp[0] = x1; cp[1] = y1; cp[2] = x2; cp[3] = y2;
cp[4] = x3; cp[5] = y3; cp[6] = x4; cp[7] = y4;
cp[0] = x1;
cp[1] = y1;
cp[2] = x2;
cp[3] = y2;
cp[4] = x3;
cp[5] = y3;
cp[6] = x4;
cp[7] = y4;
}
double operator[](unsigned i) const { return cp[i]; }
double& operator[](unsigned i) { return cp[i]; }
};
//-------------------------------------------------------------curve4_inc
class MAPNIK_DECL curve4_inc
{
public:
curve4_inc() :
m_num_steps(0), m_step(0), m_scale(1.0) { }
curve4_inc()
: m_num_steps(0)
, m_step(0)
, m_scale(1.0)
{}
curve4_inc(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4) :
m_num_steps(0), m_step(0), m_scale(1.0)
curve4_inc(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
: m_num_steps(0)
, m_step(0)
, m_scale(1.0)
{
init(x1, y1, x2, y2, x3, y3, x4, y4);
}
curve4_inc(const curve4_points& cp) :
m_num_steps(0), m_step(0), m_scale(1.0)
curve4_inc(const curve4_points& cp)
: m_num_steps(0)
, m_step(0)
, m_scale(1.0)
{
init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
}
void reset() { m_num_steps = 0; m_step = -1; }
void init(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4);
void init(const curve4_points& cp)
void reset()
{
init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
m_num_steps = 0;
m_step = -1;
}
void init(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4);
void init(const curve4_points& cp) { init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]); }
void approximation_method(curve_approximation_method_e) {}
curve_approximation_method_e approximation_method() const { return curve_inc; }
@ -264,13 +253,9 @@ namespace agg
double m_saved_ddfy;
};
//-------------------------------------------------------catrom_to_bezier
inline curve4_points catrom_to_bezier(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4)
inline curve4_points
catrom_to_bezier(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
// Trans. matrix Catmull-Rom to Bezier
//
@ -279,8 +264,7 @@ namespace agg
// 0 1/6 1 -1/6
// 0 0 1 0
//
return curve4_points(
x2,
return curve4_points(x2,
y2,
(-x1 + 6 * x2 + x3) / 6,
(-y1 + 6 * y2 + y3) / 6,
@ -290,22 +274,15 @@ namespace agg
y3);
}
//-----------------------------------------------------------------------
inline curve4_points
catrom_to_bezier(const curve4_points& cp)
inline curve4_points catrom_to_bezier(const curve4_points& cp)
{
return catrom_to_bezier(cp[0], cp[1], cp[2], cp[3],
cp[4], cp[5], cp[6], cp[7]);
return catrom_to_bezier(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
}
//-----------------------------------------------------ubspline_to_bezier
inline curve4_points ubspline_to_bezier(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4)
inline curve4_points
ubspline_to_bezier(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
// Trans. matrix Uniform BSpline to Bezier
//
@ -314,8 +291,7 @@ namespace agg
// 0 2/6 4/6 0
// 0 1/6 4/6 1/6
//
return curve4_points(
(x1 + 4*x2 + x3) / 6,
return curve4_points((x1 + 4 * x2 + x3) / 6,
(y1 + 4 * y2 + y3) / 6,
(4 * x2 + 2 * x3) / 6,
(4 * y2 + 2 * y3) / 6,
@ -325,23 +301,15 @@ namespace agg
(y2 + 4 * y3 + y4) / 6);
}
//-----------------------------------------------------------------------
inline curve4_points
ubspline_to_bezier(const curve4_points& cp)
inline curve4_points ubspline_to_bezier(const curve4_points& cp)
{
return ubspline_to_bezier(cp[0], cp[1], cp[2], cp[3],
cp[4], cp[5], cp[6], cp[7]);
return ubspline_to_bezier(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
}
//------------------------------------------------------hermite_to_bezier
inline curve4_points hermite_to_bezier(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4)
inline curve4_points
hermite_to_bezier(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
// Trans. matrix Hermite to Bezier
//
@ -350,76 +318,55 @@ namespace agg
// 0 1 0 -1/3
// 0 1 0 0
//
return curve4_points(
x1,
y1,
(3*x1 + x3) / 3,
(3*y1 + y3) / 3,
(3*x2 - x4) / 3,
(3*y2 - y4) / 3,
x2,
y2);
return curve4_points(x1, y1, (3 * x1 + x3) / 3, (3 * y1 + y3) / 3, (3 * x2 - x4) / 3, (3 * y2 - y4) / 3, x2, y2);
}
//-----------------------------------------------------------------------
inline curve4_points
hermite_to_bezier(const curve4_points& cp)
inline curve4_points hermite_to_bezier(const curve4_points& cp)
{
return hermite_to_bezier(cp[0], cp[1], cp[2], cp[3],
cp[4], cp[5], cp[6], cp[7]);
return hermite_to_bezier(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
}
//-------------------------------------------------------------curve4_div
class MAPNIK_DECL curve4_div
{
public:
curve4_div() :
m_approximation_scale(1.0),
m_angle_tolerance(0.0),
m_cusp_limit(0.0),
m_count(0)
curve4_div()
: m_approximation_scale(1.0)
, m_angle_tolerance(0.0)
, m_cusp_limit(0.0)
, m_count(0)
{}
curve4_div(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4) :
m_approximation_scale(1.0),
m_angle_tolerance(0.0),
m_cusp_limit(0.0),
m_count(0)
curve4_div(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
: m_approximation_scale(1.0)
, m_angle_tolerance(0.0)
, m_cusp_limit(0.0)
, m_count(0)
{
init(x1, y1, x2, y2, x3, y3, x4, y4);
}
curve4_div(const curve4_points& cp) :
m_approximation_scale(1.0),
m_angle_tolerance(0.0),
m_count(0)
curve4_div(const curve4_points& cp)
: m_approximation_scale(1.0)
, m_angle_tolerance(0.0)
, m_count(0)
{
init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
}
void reset() { m_points.remove_all(); m_count = 0; }
void init(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4);
void init(const curve4_points& cp)
void reset()
{
init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
m_points.remove_all();
m_count = 0;
}
void init(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4);
void init(const curve4_points& cp) { init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]); }
void approximation_method(curve_approximation_method_e) {}
curve_approximation_method_e approximation_method() const
{
return curve_div;
}
curve_approximation_method_e approximation_method() const { return curve_div; }
void approximation_scale(double s) { m_approximation_scale = s; }
double approximation_scale() const { return m_approximation_scale; }
@ -427,24 +374,16 @@ namespace agg
void angle_tolerance(double a) { m_angle_tolerance = a; }
double angle_tolerance() const { return m_angle_tolerance; }
void cusp_limit(double v)
{
m_cusp_limit = (v == 0.0) ? 0.0 : pi - v;
}
void cusp_limit(double v) { m_cusp_limit = (v == 0.0) ? 0.0 : pi - v; }
double cusp_limit() const
{
return (m_cusp_limit == 0.0) ? 0.0 : pi - m_cusp_limit;
}
double cusp_limit() const { return (m_cusp_limit == 0.0) ? 0.0 : pi - m_cusp_limit; }
void rewind(unsigned)
{
m_count = 0;
}
void rewind(unsigned) { m_count = 0; }
unsigned vertex(double* x, double* y)
{
if(m_count >= m_points.size()) return path_cmd_stop;
if (m_count >= m_points.size())
return path_cmd_stop;
const point_d& p = m_points[m_count++];
*x = p.x;
*y = p.y;
@ -452,15 +391,16 @@ namespace agg
}
private:
void bezier(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4);
void bezier(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4);
void recursive_bezier(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4,
void recursive_bezier(double x1,
double y1,
double x2,
double y2,
double x3,
double y3,
double x4,
double y4,
unsigned level);
double m_approximation_scale;
@ -471,16 +411,15 @@ namespace agg
pod_bvector<point_d> m_points;
};
//-----------------------------------------------------------------curve3
class MAPNIK_DECL curve3
{
public:
curve3() : m_approximation_method(curve_div) {}
curve3(double x1, double y1,
double x2, double y2,
double x3, double y3) :
m_approximation_method(curve_div)
curve3()
: m_approximation_method(curve_div)
{}
curve3(double x1, double y1, double x2, double y2, double x3, double y3)
: m_approximation_method(curve_div)
{
init(x1, y1, x2, y2, x3, y3);
}
@ -491,9 +430,7 @@ namespace agg
m_curve_div.reset();
}
void init(double x1, double y1,
double x2, double y2,
double x3, double y3)
void init(double x1, double y1, double x2, double y2, double x3, double y3)
{
if (m_approximation_method == curve_inc)
{
@ -505,15 +442,9 @@ namespace agg
}
}
void approximation_method(curve_approximation_method_e v)
{
m_approximation_method = v;
}
void approximation_method(curve_approximation_method_e v) { m_approximation_method = v; }
curve_approximation_method_e approximation_method() const
{
return m_approximation_method;
}
curve_approximation_method_e approximation_method() const { return m_approximation_method; }
void approximation_scale(double s)
{
@ -521,30 +452,15 @@ namespace agg
m_curve_div.approximation_scale(s);
}
double approximation_scale() const
{
return m_curve_inc.approximation_scale();
}
double approximation_scale() const { return m_curve_inc.approximation_scale(); }
void angle_tolerance(double a)
{
m_curve_div.angle_tolerance(a);
}
void angle_tolerance(double a) { m_curve_div.angle_tolerance(a); }
double angle_tolerance() const
{
return m_curve_div.angle_tolerance();
}
double angle_tolerance() const { return m_curve_div.angle_tolerance(); }
void cusp_limit(double v)
{
m_curve_div.cusp_limit(v);
}
void cusp_limit(double v) { m_curve_div.cusp_limit(v); }
double cusp_limit() const
{
return m_curve_div.cusp_limit();
}
double cusp_limit() const { return m_curve_div.cusp_limit(); }
void rewind(unsigned path_id)
{
@ -573,26 +489,21 @@ namespace agg
curve_approximation_method_e m_approximation_method;
};
//-----------------------------------------------------------------curve4
class MAPNIK_DECL curve4
{
public:
curve4() : m_approximation_method(curve_div) {}
curve4(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4) :
m_approximation_method(curve_div)
curve4()
: m_approximation_method(curve_div)
{}
curve4(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
: m_approximation_method(curve_div)
{
init(x1, y1, x2, y2, x3, y3, x4, y4);
}
curve4(const curve4_points& cp) :
m_approximation_method(curve_div)
curve4(const curve4_points& cp)
: m_approximation_method(curve_div)
{
init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
}
@ -603,10 +514,7 @@ namespace agg
m_curve_div.reset();
}
void init(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x4, double y4)
void init(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
if (m_approximation_method == curve_inc)
{
@ -618,20 +526,11 @@ namespace agg
}
}
void init(const curve4_points& cp)
{
init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
}
void init(const curve4_points& cp) { init(cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]); }
void approximation_method(curve_approximation_method_e v)
{
m_approximation_method = v;
}
void approximation_method(curve_approximation_method_e v) { m_approximation_method = v; }
curve_approximation_method_e approximation_method() const
{
return m_approximation_method;
}
curve_approximation_method_e approximation_method() const { return m_approximation_method; }
void approximation_scale(double s)
{
@ -640,25 +539,13 @@ namespace agg
}
double approximation_scale() const { return m_curve_inc.approximation_scale(); }
void angle_tolerance(double v)
{
m_curve_div.angle_tolerance(v);
}
void angle_tolerance(double v) { m_curve_div.angle_tolerance(v); }
double angle_tolerance() const
{
return m_curve_div.angle_tolerance();
}
double angle_tolerance() const { return m_curve_div.angle_tolerance(); }
void cusp_limit(double v)
{
m_curve_div.cusp_limit(v);
}
void cusp_limit(double v) { m_curve_div.cusp_limit(v); }
double cusp_limit() const
{
return m_curve_div.cusp_limit();
}
double cusp_limit() const { return m_curve_div.cusp_limit(); }
void rewind(unsigned path_id)
{
@ -687,9 +574,6 @@ namespace agg
curve_approximation_method_e m_approximation_method;
};
}
} // namespace agg
#endif

129
deps/agg/include/agg_dda_line.h vendored
View file

@ -23,49 +23,36 @@
#include <cstdlib>
#include "agg_basics.h"
namespace agg
{
namespace agg {
//===================================================dda_line_interpolator
template<int FractionShift, int YShift = 0> class dda_line_interpolator
template<int FractionShift, int YShift = 0>
class dda_line_interpolator
{
static constexpr int factor = 2 << (FractionShift - 1);
public:
//--------------------------------------------------------------------
dda_line_interpolator() {}
//--------------------------------------------------------------------
dda_line_interpolator(int y1, int y2, unsigned count) :
m_y(y1),
m_inc(((y2 - y1) * factor) / static_cast<int>(count)),
m_dy(0)
{
}
dda_line_interpolator(int y1, int y2, unsigned count)
: m_y(y1)
, m_inc(((y2 - y1) * factor) / static_cast<int>(count))
, m_dy(0)
{}
//--------------------------------------------------------------------
void operator ++ ()
{
m_dy += m_inc;
}
void operator++() { m_dy += m_inc; }
//--------------------------------------------------------------------
void operator -- ()
{
m_dy -= m_inc;
}
void operator--() { m_dy -= m_inc; }
//--------------------------------------------------------------------
void operator += (unsigned n)
{
m_dy += m_inc * n;
}
void operator+=(unsigned n) { m_dy += m_inc * n; }
//--------------------------------------------------------------------
void operator -= (unsigned n)
{
m_dy -= m_inc * n;
}
void operator-=(unsigned n) { m_dy -= m_inc * n; }
//--------------------------------------------------------------------
int y() const { return m_y + (m_dy >> (FractionShift - YShift)); }
@ -77,10 +64,6 @@ namespace agg
int m_dy;
};
//=================================================dda2_line_interpolator
class dda2_line_interpolator
{
@ -92,12 +75,12 @@ namespace agg
dda2_line_interpolator() {}
//-------------------------------------------- Forward-adjusted line
dda2_line_interpolator(int y1, int y2, int count) :
m_cnt(count <= 0 ? 1 : count),
m_lft((y2 - y1) / m_cnt),
m_rem((y2 - y1) % m_cnt),
m_mod(m_rem),
m_y(y1)
dda2_line_interpolator(int y1, int y2, int count)
: m_cnt(count <= 0 ? 1 : count)
, m_lft((y2 - y1) / m_cnt)
, m_rem((y2 - y1) % m_cnt)
, m_mod(m_rem)
, m_y(y1)
{
if (m_mod <= 0)
{
@ -109,12 +92,12 @@ namespace agg
}
//-------------------------------------------- Backward-adjusted line
dda2_line_interpolator(int y1, int y2, int count, int) :
m_cnt(count <= 0 ? 1 : count),
m_lft((y2 - y1) / m_cnt),
m_rem((y2 - y1) % m_cnt),
m_mod(m_rem),
m_y(y1)
dda2_line_interpolator(int y1, int y2, int count, int)
: m_cnt(count <= 0 ? 1 : count)
, m_lft((y2 - y1) / m_cnt)
, m_rem((y2 - y1) % m_cnt)
, m_mod(m_rem)
, m_y(y1)
{
if (m_mod <= 0)
{
@ -125,12 +108,12 @@ namespace agg
}
//-------------------------------------------- Backward-adjusted line
dda2_line_interpolator(int y, int count) :
m_cnt(count <= 0 ? 1 : count),
m_lft(y / m_cnt),
m_rem(y % m_cnt),
m_mod(m_rem),
m_y(0)
dda2_line_interpolator(int y, int count)
: m_cnt(count <= 0 ? 1 : count)
, m_lft(y / m_cnt)
, m_rem(y % m_cnt)
, m_mod(m_rem)
, m_y(0)
{
if (m_mod <= 0)
{
@ -140,7 +123,6 @@ namespace agg
}
}
//--------------------------------------------------------------------
void save(save_data_type* data) const
{
@ -180,16 +162,10 @@ namespace agg
}
//--------------------------------------------------------------------
void adjust_forward()
{
m_mod -= m_cnt;
}
void adjust_forward() { m_mod -= m_cnt; }
//--------------------------------------------------------------------
void adjust_backward()
{
m_mod += m_cnt;
}
void adjust_backward() { m_mod += m_cnt; }
//--------------------------------------------------------------------
int mod() const { return m_mod; }
@ -207,18 +183,11 @@ namespace agg
int m_y;
};
//---------------------------------------------line_bresenham_interpolator
class line_bresenham_interpolator
{
public:
enum subpixel_scale_e
{
enum subpixel_scale_e {
subpixel_shift = 8,
subpixel_scale = 1 << subpixel_shift,
subpixel_mask = subpixel_scale - 1
@ -228,20 +197,16 @@ namespace agg
static int line_lr(int v) { return v >> subpixel_shift; }
//--------------------------------------------------------------------
line_bresenham_interpolator(int x1, int y1, int x2, int y2) :
m_x1_lr(line_lr(x1)),
m_y1_lr(line_lr(y1)),
m_x2_lr(line_lr(x2)),
m_y2_lr(line_lr(y2)),
m_ver(std::abs(m_x2_lr - m_x1_lr) < std::abs(m_y2_lr - m_y1_lr)),
m_len(m_ver ? std::abs(m_y2_lr - m_y1_lr) :
std::abs(m_x2_lr - m_x1_lr)),
m_inc(m_ver ? ((y2 > y1) ? 1 : -1) : ((x2 > x1) ? 1 : -1)),
m_interpolator(m_ver ? x1 : y1,
m_ver ? x2 : y2,
m_len)
{
}
line_bresenham_interpolator(int x1, int y1, int x2, int y2)
: m_x1_lr(line_lr(x1))
, m_y1_lr(line_lr(y1))
, m_x2_lr(line_lr(x2))
, m_y2_lr(line_lr(y2))
, m_ver(std::abs(m_x2_lr - m_x1_lr) < std::abs(m_y2_lr - m_y1_lr))
, m_len(m_ver ? std::abs(m_y2_lr - m_y1_lr) : std::abs(m_x2_lr - m_x1_lr))
, m_inc(m_ver ? ((y2 > y1) ? 1 : -1) : ((x2 > x1) ? 1 : -1))
, m_interpolator(m_ver ? x1 : y1, m_ver ? x2 : y2, m_len)
{}
//--------------------------------------------------------------------
bool is_ver() const { return m_ver; }
@ -279,12 +244,8 @@ namespace agg
unsigned m_len;
int m_inc;
dda2_line_interpolator m_interpolator;
};
}
} // namespace agg
#endif

53
deps/agg/include/agg_ellipse.h vendored
View file

@ -23,27 +23,38 @@
#include "agg_basics.h"
#include <cmath>
namespace agg
{
namespace agg {
//----------------------------------------------------------------ellipse
class ellipse
{
public:
ellipse() :
m_x(0.0), m_y(0.0), m_rx(1.0), m_ry(1.0), m_scale(1.0),
m_num(4), m_step(0), m_cw(false) {}
ellipse()
: m_x(0.0)
, m_y(0.0)
, m_rx(1.0)
, m_ry(1.0)
, m_scale(1.0)
, m_num(4)
, m_step(0)
, m_cw(false)
{}
ellipse(double x, double y, double rx, double ry,
unsigned num_steps=0, bool cw=false) :
m_x(x), m_y(y), m_rx(rx), m_ry(ry), m_scale(1.0),
m_num(num_steps), m_step(0), m_cw(cw)
ellipse(double x, double y, double rx, double ry, unsigned num_steps = 0, bool cw = false)
: m_x(x)
, m_y(y)
, m_rx(rx)
, m_ry(ry)
, m_scale(1.0)
, m_num(num_steps)
, m_step(0)
, m_cw(cw)
{
if(m_num == 0) calc_num_steps();
if (m_num == 0)
calc_num_steps();
}
void init(double x, double y, double rx, double ry,
unsigned num_steps=0, bool cw=false);
void init(double x, double y, double rx, double ry, unsigned num_steps = 0, bool cw = false);
void approximation_scale(double scale);
void rewind(unsigned path_id);
@ -64,8 +75,7 @@ namespace agg
};
//------------------------------------------------------------------------
inline void ellipse::init(double x, double y, double rx, double ry,
unsigned num_steps, bool cw)
inline void ellipse::init(double x, double y, double rx, double ry, unsigned num_steps, bool cw)
{
m_x = x;
m_y = y;
@ -74,7 +84,8 @@ namespace agg
m_num = num_steps;
m_step = 0;
m_cw = cw;
if(m_num == 0) calc_num_steps();
if (m_num == 0)
calc_num_steps();
}
//------------------------------------------------------------------------
@ -106,19 +117,17 @@ namespace agg
++m_step;
return path_cmd_end_poly | path_flags_close | path_flags_ccw;
}
if(m_step > m_num) return path_cmd_stop;
if (m_step > m_num)
return path_cmd_stop;
double angle = double(m_step) / double(m_num) * 2.0 * pi;
if(m_cw) angle = 2.0 * pi - angle;
if (m_cw)
angle = 2.0 * pi - angle;
*x = m_x + std::cos(angle) * m_rx;
*y = m_y + std::sin(angle) * m_ry;
m_step++;
return ((m_step == 1) ? path_cmd_move_to : path_cmd_line_to);
}
}
} // namespace agg
#endif

38
deps/agg/include/agg_ellipse_bresenham.h vendored
View file

@ -20,27 +20,24 @@
#ifndef AGG_ELLIPSE_BRESENHAM_INCLUDED
#define AGG_ELLIPSE_BRESENHAM_INCLUDED
#include "agg_basics.h"
namespace agg
{
namespace agg {
//------------------------------------------ellipse_bresenham_interpolator
class ellipse_bresenham_interpolator
{
public:
ellipse_bresenham_interpolator(int rx, int ry) :
m_rx2(rx * rx),
m_ry2(ry * ry),
m_two_rx2(m_rx2 << 1),
m_two_ry2(m_ry2 << 1),
m_dx(0),
m_dy(0),
m_inc_x(0),
m_inc_y(-ry * m_two_rx2),
m_cur_f(0)
ellipse_bresenham_interpolator(int rx, int ry)
: m_rx2(rx * rx)
, m_ry2(ry * ry)
, m_two_rx2(m_rx2 << 1)
, m_two_ry2(m_ry2 << 1)
, m_dx(0)
, m_dy(0)
, m_inc_x(0)
, m_inc_y(-ry * m_two_rx2)
, m_cur_f(0)
{}
int dx() const { return m_dx; }
@ -52,13 +49,16 @@ namespace agg
int fx, fy, fxy;
mx = fx = m_cur_f + m_inc_x + m_ry2;
if(mx < 0) mx = -mx;
if (mx < 0)
mx = -mx;
my = fy = m_cur_f + m_inc_y + m_rx2;
if(my < 0) my = -my;
if (my < 0)
my = -my;
mxy = fxy = m_cur_f + m_inc_x + m_ry2 + m_inc_y + m_rx2;
if(mxy < 0) mxy = -mxy;
if (mxy < 0)
mxy = -mxy;
min_m = mx;
bool flag = true;
@ -104,10 +104,8 @@ namespace agg
int m_inc_x;
int m_inc_y;
int m_cur_f;
};
}
} // namespace agg
#endif

5
deps/agg/include/agg_embedded_raster_fonts.h vendored
View file

@ -18,8 +18,7 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
extern const int8u gse4x6[];
extern const int8u gse4x8[];
extern const int8u gse5x7[];
@ -54,6 +53,6 @@ namespace agg
extern const int8u verdana17_bold[];
extern const int8u verdana18[];
extern const int8u verdana18_bold[];
}
} // namespace agg
#endif

123
deps/agg/include/agg_font_cache_manager.h vendored
View file

@ -19,18 +19,10 @@
#include <cstring>
#include "agg_array.h"
namespace agg
{
namespace agg {
//---------------------------------------------------------glyph_data_type
enum glyph_data_type
{
glyph_data_invalid = 0,
glyph_data_mono = 1,
glyph_data_gray8 = 2,
glyph_data_outline = 3
};
enum glyph_data_type { glyph_data_invalid = 0, glyph_data_mono = 1, glyph_data_gray8 = 2, glyph_data_outline = 3 };
//-------------------------------------------------------------glyph_cache
struct glyph_cache
@ -44,7 +36,6 @@ namespace agg
double advance_y;
};
//--------------------------------------------------------------font_cache
class font_cache
{
@ -52,9 +43,9 @@ namespace agg
enum block_size_e { block_size = 16384 - 16 };
//--------------------------------------------------------------------
font_cache() :
m_allocator(block_size),
m_font_signature(0)
font_cache()
: m_allocator(block_size)
, m_font_signature(0)
{}
//--------------------------------------------------------------------
@ -66,10 +57,7 @@ namespace agg
}
//--------------------------------------------------------------------
bool font_is(const char* font_signature) const
{
return strcmp(font_signature, m_font_signature) == 0;
}
bool font_is(const char* font_signature) const { return strcmp(font_signature, m_font_signature) == 0; }
//--------------------------------------------------------------------
const glyph_cache* find_glyph(unsigned glyph_code) const
@ -94,18 +82,15 @@ namespace agg
unsigned msb = (glyph_code >> 8) & 0xFF;
if (m_glyphs[msb] == 0)
{
m_glyphs[msb] =
(glyph_cache**)m_allocator.allocate(sizeof(glyph_cache*) * 256,
sizeof(glyph_cache*));
m_glyphs[msb] = (glyph_cache**)m_allocator.allocate(sizeof(glyph_cache*) * 256, sizeof(glyph_cache*));
memset(m_glyphs[msb], 0, sizeof(glyph_cache*) * 256);
}
unsigned lsb = glyph_code & 0xFF;
if(m_glyphs[msb][lsb]) return 0; // Already exists, do not overwrite
if (m_glyphs[msb][lsb])
return 0; // Already exists, do not overwrite
glyph_cache* glyph =
(glyph_cache*)m_allocator.allocate(sizeof(glyph_cache),
sizeof(double));
glyph_cache* glyph = (glyph_cache*)m_allocator.allocate(sizeof(glyph_cache), sizeof(double));
glyph->glyph_index = glyph_index;
glyph->data = m_allocator.allocate(data_size);
@ -123,12 +108,6 @@ namespace agg
char* m_font_signature;
};
//---------------------------------------------------------font_cache_pool
class font_cache_pool
{
@ -145,14 +124,13 @@ namespace agg
}
//--------------------------------------------------------------------
font_cache_pool(unsigned max_fonts=32) :
m_fonts(pod_allocator<font_cache*>::allocate(max_fonts)),
m_max_fonts(max_fonts),
m_num_fonts(0),
m_cur_font(0)
font_cache_pool(unsigned max_fonts = 32)
: m_fonts(pod_allocator<font_cache*>::allocate(max_fonts))
, m_max_fonts(max_fonts)
, m_num_fonts(0)
, m_cur_font(0)
{}
//--------------------------------------------------------------------
void font(const char* font_signature, bool reset_cache = false)
{
@ -172,9 +150,7 @@ namespace agg
if (m_num_fonts >= m_max_fonts)
{
obj_allocator<font_cache>::deallocate(m_fonts[0]);
memcpy(m_fonts,
m_fonts + 1,
(m_max_fonts - 1) * sizeof(font_cache*));
memcpy(m_fonts, m_fonts + 1, (m_max_fonts - 1) * sizeof(font_cache*));
m_num_fonts = m_max_fonts - 1;
}
m_fonts[m_num_fonts] = obj_allocator<font_cache>::allocate();
@ -185,15 +161,13 @@ namespace agg
}
//--------------------------------------------------------------------
const font_cache* font() const
{
return m_cur_font;
}
const font_cache* font() const { return m_cur_font; }
//--------------------------------------------------------------------
const glyph_cache* find_glyph(unsigned glyph_code) const
{
if(m_cur_font) return m_cur_font->find_glyph(glyph_code);
if (m_cur_font)
return m_cur_font->find_glyph(glyph_code);
return 0;
}
@ -208,25 +182,19 @@ namespace agg
{
if (m_cur_font)
{
return m_cur_font->cache_glyph(glyph_code,
glyph_index,
data_size,
data_type,
bounds,
advance_x,
advance_y);
return m_cur_font->cache_glyph(glyph_code, glyph_index, data_size, data_type, bounds, advance_x, advance_y);
}
return 0;
}
//--------------------------------------------------------------------
int find_font(const char* font_signature)
{
unsigned i;
for (i = 0; i < m_num_fonts; i++)
{
if(m_fonts[i]->font_is(font_signature)) return int(i);
if (m_fonts[i]->font_is(font_signature))
return int(i);
}
return -1;
}
@ -238,12 +206,8 @@ namespace agg
font_cache* m_cur_font;
};
//------------------------------------------------------------------------
enum glyph_rendering
{
enum glyph_rendering {
glyph_ren_native_mono,
glyph_ren_native_gray8,
glyph_ren_outline,
@ -251,11 +215,9 @@ namespace agg
glyph_ren_agg_gray8
};
//------------------------------------------------------font_cache_manager
template<class FontEngine> class font_cache_manager
template<class FontEngine>
class font_cache_manager
{
public:
typedef FontEngine font_engine_type;
@ -267,19 +229,16 @@ namespace agg
typedef typename mono_adaptor_type::embedded_scanline mono_scanline_type;
//--------------------------------------------------------------------
font_cache_manager(font_engine_type& engine, unsigned max_fonts=32) :
m_fonts(max_fonts),
m_engine(engine),
m_change_stamp(-1),
m_prev_glyph(0),
m_last_glyph(0)
font_cache_manager(font_engine_type& engine, unsigned max_fonts = 32)
: m_fonts(max_fonts)
, m_engine(engine)
, m_change_stamp(-1)
, m_prev_glyph(0)
, m_last_glyph(0)
{}
//--------------------------------------------------------------------
void reset_last_glyph()
{
m_prev_glyph = m_last_glyph = 0;
}
void reset_last_glyph() { m_prev_glyph = m_last_glyph = 0; }
//--------------------------------------------------------------------
const glyph_cache* glyph(unsigned glyph_code)
@ -311,15 +270,14 @@ namespace agg
}
//--------------------------------------------------------------------
void init_embedded_adaptors(const glyph_cache* gl,
double x, double y,
double scale=1.0)
void init_embedded_adaptors(const glyph_cache* gl, double x, double y, double scale = 1.0)
{
if (gl)
{
switch (gl->data_type)
{
default: return;
default:
return;
case glyph_data_mono:
m_mono_adaptor.init(gl->data, gl->data_size, x, y);
break;
@ -335,7 +293,6 @@ namespace agg
}
}
//--------------------------------------------------------------------
path_adaptor_type& path_adaptor() { return m_path_adaptor; }
gray8_adaptor_type& gray8_adaptor() { return m_gray8_adaptor; }
@ -352,9 +309,7 @@ namespace agg
{
if (m_prev_glyph && m_last_glyph)
{
return m_engine.add_kerning(m_prev_glyph->glyph_index,
m_last_glyph->glyph_index,
x, y);
return m_engine.add_kerning(m_prev_glyph->glyph_index, m_last_glyph->glyph_index, x, y);
}
return false;
}
@ -362,7 +317,8 @@ namespace agg
//--------------------------------------------------------------------
void precache(unsigned from, unsigned to)
{
for(; from <= to; ++from) glyph(from);
for (; from <= to; ++from)
glyph(from);
}
//--------------------------------------------------------------------
@ -403,7 +359,6 @@ namespace agg
mono_scanline_type m_mono_scanline;
};
}
} // namespace agg
#endif

69
deps/agg/include/agg_gamma_functions.h vendored
View file

@ -19,28 +19,31 @@
#include <cmath>
#include "agg_basics.h"
namespace agg
{
namespace agg {
//===============================================================gamma_none
struct gamma_none
{
double operator()(double x) const { return x; }
};
//==============================================================gamma_power
class gamma_power
{
public:
gamma_power() : m_gamma(1.0) {}
gamma_power(double g) : m_gamma(g) {}
gamma_power()
: m_gamma(1.0)
{}
gamma_power(double g)
: m_gamma(g)
{}
void gamma(double g) { m_gamma = g; }
double gamma() const { return m_gamma; }
double operator()(double x) const
{
if (x == 0.0) return 0.0;
if (x == 0.0)
return 0.0;
return pow(x, m_gamma);
}
@ -48,35 +51,44 @@ namespace agg
double m_gamma;
};
//==========================================================gamma_threshold
class gamma_threshold
{
public:
gamma_threshold() : m_threshold(0.5) {}
gamma_threshold(double t) : m_threshold(t) {}
gamma_threshold()
: m_threshold(0.5)
{}
gamma_threshold(double t)
: m_threshold(t)
{}
void threshold(double t) { m_threshold = t; }
double threshold() const { return m_threshold; }
double operator() (double x) const
{
return (x < m_threshold) ? 0.0 : 1.0;
}
double operator()(double x) const { return (x < m_threshold) ? 0.0 : 1.0; }
private:
double m_threshold;
};
//============================================================gamma_linear
class gamma_linear
{
public:
gamma_linear() : m_start(0.0), m_end(1.0) {}
gamma_linear(double s, double e) : m_start(s), m_end(e) {}
gamma_linear()
: m_start(0.0)
, m_end(1.0)
{}
gamma_linear(double s, double e)
: m_start(s)
, m_end(e)
{}
void set(double s, double e) { m_start = s; m_end = e; }
void set(double s, double e)
{
m_start = s;
m_end = e;
}
void start(double s) { m_start = s; }
void end(double e) { m_end = e; }
double start() const { return m_start; }
@ -84,12 +96,15 @@ namespace agg
double operator()(double x) const
{
if(x < m_start) return 0.0;
if(x > m_end) return 1.0;
if (x < m_start)
return 0.0;
if (x > m_end)
return 1.0;
double delta = m_end - m_start;
// avoid nan from potential zero division
// https://github.com/mapnik/mapnik/issues/761
if (delta <= 0.0) return 0.0;
if (delta <= 0.0)
return 0.0;
return (x - m_start) / delta;
}
@ -98,13 +113,16 @@ namespace agg
double m_end;
};
//==========================================================gamma_multiply
class gamma_multiply
{
public:
gamma_multiply() : m_mul(1.0) {}
gamma_multiply(double v) : m_mul(v) {}
gamma_multiply()
: m_mul(1.0)
{}
gamma_multiply(double v)
: m_mul(v)
{}
void value(double v) { m_mul = v; }
double value() const { return m_mul; }
@ -112,7 +130,8 @@ namespace agg
double operator()(double x) const
{
double y = x * m_mul;
if(y > 1.0) y = 1.0;
if (y > 1.0)
y = 1.0;
return y;
}
@ -129,6 +148,6 @@ namespace agg
{
return (x <= 0.0031308) ? (x * 12.92) : (1.055 * pow(x, 1 / 2.4) - 0.055);
}
}
} // namespace agg
#endif

139
deps/agg/include/agg_gamma_lut.h vendored
View file

@ -20,29 +20,16 @@
#include "agg_basics.h"
#include "agg_gamma_functions.h"
namespace agg
{
template<class LoResT=int8u,
class HiResT=int8u,
unsigned GammaShift=8,
unsigned HiResShift=8> class gamma_lut
namespace agg {
template<class LoResT = int8u, class HiResT = int8u, unsigned GammaShift = 8, unsigned HiResShift = 8>
class gamma_lut
{
public:
typedef gamma_lut<LoResT, HiResT, GammaShift, HiResShift> self_type;
enum gamma_scale_e
{
gamma_shift = GammaShift,
gamma_size = 1 << gamma_shift,
gamma_mask = gamma_size - 1
};
enum gamma_scale_e { gamma_shift = GammaShift, gamma_size = 1 << gamma_shift, gamma_mask = gamma_size - 1 };
enum hi_res_scale_e
{
hi_res_shift = HiResShift,
hi_res_size = 1 << hi_res_shift,
hi_res_mask = hi_res_size - 1
};
enum hi_res_scale_e { hi_res_shift = HiResShift, hi_res_size = 1 << hi_res_shift, hi_res_mask = hi_res_size - 1 };
~gamma_lut()
{
@ -50,10 +37,10 @@ namespace agg
pod_allocator<HiResT>::deallocate(m_dir_gamma, gamma_size);
}
gamma_lut() :
m_gamma(1.0),
m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size)),
m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
gamma_lut()
: m_gamma(1.0)
, m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size))
, m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
{
unsigned i;
for (i = 0; i < gamma_size; i++)
@ -67,10 +54,10 @@ namespace agg
}
}
gamma_lut(double g) :
m_gamma(1.0),
m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size)),
m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
gamma_lut(double g)
: m_gamma(1.0)
, m_dir_gamma(pod_allocator<HiResT>::allocate(gamma_size))
, m_inv_gamma(pod_allocator<LoResT>::allocate(hi_res_size))
{
gamma(g);
}
@ -82,32 +69,21 @@ namespace agg
unsigned i;
for (i = 0; i < gamma_size; i++)
{
m_dir_gamma[i] = (HiResT)
uround(pow(i / double(gamma_mask), m_gamma) * double(hi_res_mask));
m_dir_gamma[i] = (HiResT)uround(pow(i / double(gamma_mask), m_gamma) * double(hi_res_mask));
}
double inv_g = 1.0 / g;
for (i = 0; i < hi_res_size; i++)
{
m_inv_gamma[i] = (LoResT)
uround(pow(i / double(hi_res_mask), inv_g) * double(gamma_mask));
m_inv_gamma[i] = (LoResT)uround(pow(i / double(hi_res_mask), inv_g) * double(gamma_mask));
}
}
double gamma() const
{
return m_gamma;
}
double gamma() const { return m_gamma; }
HiResT dir(LoResT v) const
{
return m_dir_gamma[unsigned(v)];
}
HiResT dir(LoResT v) const { return m_dir_gamma[unsigned(v)]; }
LoResT inv(HiResT v) const
{
return m_inv_gamma[unsigned(v)];
}
LoResT inv(HiResT v) const { return m_inv_gamma[unsigned(v)]; }
private:
gamma_lut(const self_type&);
@ -129,23 +105,28 @@ namespace agg
class sRGB_lut_base
{
public:
LinearType dir(int8u v) const
{
return m_dir_table[v];
}
LinearType dir(int8u v) const { return m_dir_table[v]; }
int8u inv(LinearType v) const
{
// Unrolled binary search.
int8u x = 0;
if (v > m_inv_table[128]) x = 128;
if (v > m_inv_table[x + 64]) x += 64;
if (v > m_inv_table[x + 32]) x += 32;
if (v > m_inv_table[x + 16]) x += 16;
if (v > m_inv_table[x + 8]) x += 8;
if (v > m_inv_table[x + 4]) x += 4;
if (v > m_inv_table[x + 2]) x += 2;
if (v > m_inv_table[x + 1]) x += 1;
if (v > m_inv_table[128])
x = 128;
if (v > m_inv_table[x + 64])
x += 64;
if (v > m_inv_table[x + 32])
x += 32;
if (v > m_inv_table[x + 16])
x += 16;
if (v > m_inv_table[x + 8])
x += 8;
if (v > m_inv_table[x + 4])
x += 4;
if (v > m_inv_table[x + 2])
x += 2;
if (v > m_inv_table[x + 1])
x += 1;
return x;
}
@ -154,9 +135,7 @@ namespace agg
LinearType m_inv_table[256];
// Only derived classes may instantiate.
sRGB_lut_base()
{
}
sRGB_lut_base() {}
};
// sRGB_lut - implements sRGB conversion for the various types.
@ -230,15 +209,9 @@ namespace agg
class sRGB_conv_base
{
public:
static T rgb_from_sRGB(int8u x)
{
return lut.dir(x);
}
static T rgb_from_sRGB(int8u x) { return lut.dir(x); }
static int8u rgb_to_sRGB(T x)
{
return lut.inv(x);
}
static int8u rgb_to_sRGB(T x) { return lut.inv(x); }
private:
static sRGB_lut<T> lut;
@ -258,16 +231,16 @@ namespace agg
class sRGB_conv<float> : public sRGB_conv_base<float>
{
public:
static float alpha_from_sRGB(int8u x)
{
return float(x / 255.0);
}
static float alpha_from_sRGB(int8u x) { return float(x / 255.0); }
static int8u alpha_to_sRGB(float x)
{
if (x <= 0) return 0;
else if (x >= 1) return 255;
else return int8u(0.5 + x * 255);
if (x <= 0)
return 0;
else if (x >= 1)
return 255;
else
return int8u(0.5 + x * 255);
}
};
@ -275,31 +248,19 @@ namespace agg
class sRGB_conv<int16u> : public sRGB_conv_base<int16u>
{
public:
static int16u alpha_from_sRGB(int8u x)
{
return (x << 8) | x;
}
static int16u alpha_from_sRGB(int8u x) { return (x << 8) | x; }
static int8u alpha_to_sRGB(int16u x)
{
return x >> 8;
}
static int8u alpha_to_sRGB(int16u x) { return x >> 8; }
};
template<>
class sRGB_conv<int8u> : public sRGB_conv_base<int8u>
{
public:
static int8u alpha_from_sRGB(int8u x)
{
return x;
}
static int8u alpha_from_sRGB(int8u x) { return x; }
static int8u alpha_to_sRGB(int8u x)
{
return x;
}
static int8u alpha_to_sRGB(int8u x) { return x; }
};
}
} // namespace agg
#endif

25
deps/agg/include/agg_glyph_raster_bin.h vendored
View file

@ -19,11 +19,11 @@
#include <cstring>
#include "agg_basics.h"
namespace agg
{
namespace agg {
//========================================================glyph_raster_bin
template<class ColorT> class glyph_raster_bin
template<class ColorT>
class glyph_raster_bin
{
public:
typedef ColorT color_type;
@ -36,12 +36,13 @@ namespace agg
};
//--------------------------------------------------------------------
glyph_raster_bin(const int8u* font) :
m_font(font),
m_big_endian(false)
glyph_raster_bin(const int8u* font)
: m_font(font)
, m_big_endian(false)
{
int t = 1;
if(*(char*)&t == 0) m_big_endian = true;
if (*(char*)&t == 0)
m_big_endian = true;
memset(m_span, 0, sizeof(m_span));
}
@ -64,8 +65,7 @@ namespace agg
while (*str)
{
unsigned glyph = *str;
const int8u* bits = m_font + 4 + num_chars * 2 +
value(m_font + 4 + (glyph - start_char) * 2);
const int8u* bits = m_font + 4 + num_chars * 2 + value(m_font + 4 + (glyph - start_char) * 2);
w += *bits;
++str;
}
@ -78,8 +78,7 @@ namespace agg
unsigned start_char = m_font[2];
unsigned num_chars = m_font[3];
m_bits = m_font + 4 + num_chars * 2 +
value(m_font + 4 + (glyph - start_char) * 2);
m_bits = m_font + 4 + num_chars * 2 + value(m_font + 4 + (glyph - start_char) * 2);
m_glyph_width = *m_bits++;
m_glyph_byte_width = (m_glyph_width + 7) >> 3;
@ -139,7 +138,6 @@ namespace agg
return v;
}
//--------------------------------------------------------------------
const int8u* m_font;
bool m_big_endian;
@ -149,7 +147,6 @@ namespace agg
unsigned m_glyph_byte_width;
};
}
} // namespace agg
#endif

122
deps/agg/include/agg_gradient_lut.h vendored
View file

@ -21,33 +21,25 @@
#include "agg_color_rgba.h"
#include "agg_color_gray.h"
namespace agg
{
namespace agg {
//======================================================color_interpolator
template<class ColorT> struct color_interpolator
template<class ColorT>
struct color_interpolator
{
public:
typedef ColorT color_type;
color_interpolator(const color_type& c1,
const color_type& c2,
unsigned len) :
m_c1(c1),
m_c2(c2),
m_len(len),
m_count(0)
color_interpolator(const color_type& c1, const color_type& c2, unsigned len)
: m_c1(c1)
, m_c2(c2)
, m_len(len)
, m_count(0)
{}
void operator ++ ()
{
++m_count;
}
void operator++() { ++m_count; }
color_type color() const
{
return m_c1.gradient(m_c2, double(m_count) / m_len);
}
color_type color() const { return m_c1.gradient(m_c2, double(m_count) / m_len); }
private:
color_type m_c1;
@ -58,29 +50,28 @@ namespace agg
//========================================================================
// Fast specialization for rgba8
template<> struct color_interpolator<rgba8>
template<>
struct color_interpolator<rgba8>
{
public:
typedef rgba8 color_type;
color_interpolator(const color_type& c1,
const color_type& c2,
unsigned len) :
r(c1.r, c2.r, len),
g(c1.g, c2.g, len),
b(c1.b, c2.b, len),
a(c1.a, c2.a, len)
color_interpolator(const color_type& c1, const color_type& c2, unsigned len)
: r(c1.r, c2.r, len)
, g(c1.g, c2.g, len)
, b(c1.b, c2.b, len)
, a(c1.a, c2.a, len)
{}
void operator++()
{
++r; ++g; ++b; ++a;
++r;
++g;
++b;
++a;
}
color_type color() const
{
return color_type(r.y(), g.y(), b.y(), a.y());
}
color_type color() const { return color_type(r.y(), g.y(), b.y(), a.y()); }
private:
agg::dda_line_interpolator<14> r, g, b, a;
@ -88,35 +79,32 @@ namespace agg
//========================================================================
// Fast specialization for gray8
template<> struct color_interpolator<gray8>
template<>
struct color_interpolator<gray8>
{
public:
typedef gray8 color_type;
color_interpolator(const color_type& c1,
const color_type& c2,
unsigned len) :
v(c1.v, c2.v, len),
a(c1.a, c2.a, len)
color_interpolator(const color_type& c1, const color_type& c2, unsigned len)
: v(c1.v, c2.v, len)
, a(c1.a, c2.a, len)
{}
void operator++()
{
++v; ++a;
++v;
++a;
}
color_type color() const
{
return color_type(v.y(), a.y());
}
color_type color() const { return color_type(v.y(), a.y()); }
private:
agg::dda_line_interpolator<14> v, a;
};
//============================================================gradient_lut
template<class ColorInterpolator,
unsigned ColorLutSize=256> class gradient_lut
template<class ColorInterpolator, unsigned ColorLutSize = 256>
class gradient_lut
{
public:
typedef ColorInterpolator interpolator_type;
@ -124,7 +112,9 @@ namespace agg
enum { color_lut_size = ColorLutSize };
//--------------------------------------------------------------------
gradient_lut() : m_color_lut(color_lut_size) {}
gradient_lut()
: m_color_lut(color_lut_size)
{}
// Build Gradient Lut
// First, call remove_all(), then add_color() at least twice,
@ -143,14 +133,8 @@ namespace agg
// ColorF in span_gradient. All it needs is two access methods
// size() and operator [].
//--------------------------------------------------------------------
static unsigned size()
{
return color_lut_size;
}
const color_type& operator [] (unsigned i) const
{
return m_color_lut[i];
}
static unsigned size() { return color_lut_size; }
const color_type& operator[](unsigned i) const { return m_color_lut[i]; }
private:
//--------------------------------------------------------------------
@ -160,32 +144,27 @@ namespace agg
color_type color;
color_point() {}
color_point(double off, const color_type& c) :
offset(off), color(c)
color_point(double off, const color_type& c)
: offset(off)
, color(c)
{
if(offset < 0.0) offset = 0.0;
if(offset > 1.0) offset = 1.0;
if (offset < 0.0)
offset = 0.0;
if (offset > 1.0)
offset = 1.0;
}
};
typedef agg::pod_bvector<color_point, 4> color_profile_type;
typedef agg::pod_array<color_type> color_lut_type;
static bool offset_less(const color_point& a, const color_point& b)
{
return a.offset < b.offset;
}
static bool offset_equal(const color_point& a, const color_point& b)
{
return a.offset == b.offset;
}
static bool offset_less(const color_point& a, const color_point& b) { return a.offset < b.offset; }
static bool offset_equal(const color_point& a, const color_point& b) { return a.offset == b.offset; }
//--------------------------------------------------------------------
color_profile_type m_color_profile;
color_lut_type m_color_lut;
};
//------------------------------------------------------------------------
template<class T, unsigned S>
void gradient_lut<T, S>::remove_all()
@ -219,9 +198,7 @@ namespace agg
for (i = 1; i < m_color_profile.size(); i++)
{
end = uround(m_color_profile[i].offset * color_lut_size);
interpolator_type ci(m_color_profile[i-1].color,
m_color_profile[i ].color,
end - start + 1);
interpolator_type ci(m_color_profile[i - 1].color, m_color_profile[i].color, end - start + 1);
while (start < end)
{
m_color_lut[start] = ci.color();
@ -238,9 +215,6 @@ namespace agg
}
return false;
}
}
} // namespace agg
#endif

47
deps/agg/include/agg_gsv_text.h vendored
View file

@ -24,9 +24,7 @@
#include "agg_conv_stroke.h"
#include "agg_conv_transform.h"
namespace agg
{
namespace agg {
//---------------------------------------------------------------gsv_text
//
@ -34,13 +32,7 @@ namespace agg
//
class gsv_text
{
enum status
{
initial,
next_char,
start_glyph,
glyph
};
enum status { initial, next_char, start_glyph, glyph };
public:
gsv_text();
@ -105,28 +97,19 @@ namespace agg
double m_h;
};
//--------------------------------------------------------gsv_text_outline
template<class Transformer = trans_affine> class gsv_text_outline
template<class Transformer = trans_affine>
class gsv_text_outline
{
public:
gsv_text_outline(gsv_text& text, const Transformer& trans) :
m_polyline(text),
m_trans(m_polyline, trans)
{
}
gsv_text_outline(gsv_text& text, const Transformer& trans)
: m_polyline(text)
, m_trans(m_polyline, trans)
{}
void width(double w)
{
m_polyline.width(w);
}
void width(double w) { m_polyline.width(w); }
void transformer(const Transformer* trans)
{
m_trans->transformer(trans);
}
void transformer(const Transformer* trans) { m_trans->transformer(trans); }
void rewind(unsigned path_id)
{
@ -135,19 +118,13 @@ namespace agg
m_polyline.line_cap(round_cap);
}
unsigned vertex(double* x, double* y)
{
return m_trans.vertex(x, y);
}
unsigned vertex(double* x, double* y) { return m_trans.vertex(x, y); }
private:
conv_stroke<gsv_text> m_polyline;
conv_transform<conv_stroke<gsv_text>, Transformer> m_trans;
};
}
} // namespace agg
#endif

225
deps/agg/include/agg_image_accessors.h vendored
View file

@ -18,11 +18,11 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//-----------------------------------------------------image_accessor_clip
template<class PixFmt> class image_accessor_clip
template<class PixFmt>
class image_accessor_clip
{
public:
typedef PixFmt pixfmt_type;
@ -32,28 +32,20 @@ namespace agg
enum pix_width_e { pix_width = pixfmt_type::pix_width };
image_accessor_clip() {}
explicit image_accessor_clip(const pixfmt_type& pixf,
const color_type& bk) :
m_pixf(&pixf)
explicit image_accessor_clip(const pixfmt_type& pixf, const color_type& bk)
: m_pixf(&pixf)
{
pixfmt_type::make_pix(m_bk_buf, bk);
}
void attach(const pixfmt_type& pixf)
{
m_pixf = &pixf;
}
void attach(const pixfmt_type& pixf) { m_pixf = &pixf; }
void background_color(const color_type& bk)
{
pixfmt_type::make_pix(m_bk_buf, bk);
}
void background_color(const color_type& bk) { pixfmt_type::make_pix(m_bk_buf, bk); }
private:
AGG_INLINE const int8u* pixel() const
{
if(m_y >= 0 && m_y < (int)m_pixf->height() &&
m_x >= 0 && m_x < (int)m_pixf->width())
if (m_y >= 0 && m_y < (int)m_pixf->height() && m_x >= 0 && m_x < (int)m_pixf->width())
{
return m_pixf->pix_ptr(m_x, m_y);
}
@ -65,8 +57,7 @@ namespace agg
{
m_x = m_x0 = x;
m_y = y;
if(y >= 0 && y < (int)m_pixf->height() &&
x >= 0 && x+(int)len <= (int)m_pixf->width())
if (y >= 0 && y < (int)m_pixf->height() && x >= 0 && x + (int)len <= (int)m_pixf->width())
{
return m_pix_ptr = m_pixf->pix_ptr(x, y);
}
@ -76,7 +67,8 @@ namespace agg
AGG_INLINE const int8u* next_x()
{
if(m_pix_ptr) return m_pix_ptr += pix_width;
if (m_pix_ptr)
return m_pix_ptr += pix_width;
++m_x;
return pixel();
}
@ -85,8 +77,7 @@ namespace agg
{
++m_y;
m_x = m_x0;
if(m_pix_ptr &&
m_y >= 0 && m_y < (int)m_pixf->height())
if (m_pix_ptr && m_y >= 0 && m_y < (int)m_pixf->height())
{
return m_pix_ptr = m_pixf->pix_ptr(m_x, m_y);
}
@ -101,11 +92,9 @@ namespace agg
const int8u* m_pix_ptr;
};
//--------------------------------------------------image_accessor_no_clip
template<class PixFmt> class image_accessor_no_clip
template<class PixFmt>
class image_accessor_no_clip
{
public:
typedef PixFmt pixfmt_type;
@ -115,14 +104,11 @@ namespace agg
enum pix_width_e { pix_width = pixfmt_type::pix_width };
image_accessor_no_clip() {}
explicit image_accessor_no_clip(const pixfmt_type& pixf) :
m_pixf(&pixf)
explicit image_accessor_no_clip(const pixfmt_type& pixf)
: m_pixf(&pixf)
{}
void attach(const pixfmt_type& pixf)
{
m_pixf = &pixf;
}
void attach(const pixfmt_type& pixf) { m_pixf = &pixf; }
AGG_INLINE const int8u* span(int x, int y, unsigned)
{
@ -131,10 +117,7 @@ namespace agg
return m_pix_ptr = m_pixf->pix_ptr(x, y);
}
AGG_INLINE const int8u* next_x()
{
return m_pix_ptr += pix_width;
}
AGG_INLINE const int8u* next_x() { return m_pix_ptr += pix_width; }
AGG_INLINE const int8u* next_y()
{
@ -148,11 +131,9 @@ namespace agg
const int8u* m_pix_ptr;
};
//----------------------------------------------------image_accessor_clone
template<class PixFmt> class image_accessor_clone
template<class PixFmt>
class image_accessor_clone
{
public:
typedef PixFmt pixfmt_type;
@ -162,24 +143,25 @@ namespace agg
enum pix_width_e { pix_width = pixfmt_type::pix_width };
image_accessor_clone() {}
explicit image_accessor_clone(const pixfmt_type& pixf) :
m_pixf(&pixf)
explicit image_accessor_clone(const pixfmt_type& pixf)
: m_pixf(&pixf)
{}
void attach(const pixfmt_type& pixf)
{
m_pixf = &pixf;
}
void attach(const pixfmt_type& pixf) { m_pixf = &pixf; }
private:
AGG_INLINE const int8u* pixel() const
{
int x = m_x;
int y = m_y;
if(x < 0) x = 0;
if(y < 0) y = 0;
if(x >= (int)m_pixf->width()) x = m_pixf->width() - 1;
if(y >= (int)m_pixf->height()) y = m_pixf->height() - 1;
if (x < 0)
x = 0;
if (y < 0)
y = 0;
if (x >= (int)m_pixf->width())
x = m_pixf->width() - 1;
if (y >= (int)m_pixf->height())
y = m_pixf->height() - 1;
return m_pixf->pix_ptr(x, y);
}
@ -188,8 +170,7 @@ namespace agg
{
m_x = m_x0 = x;
m_y = y;
if(y >= 0 && y < (int)m_pixf->height() &&
x >= 0 && x+(int)len <= (int)m_pixf->width())
if (y >= 0 && y < (int)m_pixf->height() && x >= 0 && x + (int)len <= (int)m_pixf->width())
{
return m_pix_ptr = m_pixf->pix_ptr(x, y);
}
@ -199,7 +180,8 @@ namespace agg
AGG_INLINE const int8u* next_x()
{
if(m_pix_ptr) return m_pix_ptr += pix_width;
if (m_pix_ptr)
return m_pix_ptr += pix_width;
++m_x;
return pixel();
}
@ -208,8 +190,7 @@ namespace agg
{
++m_y;
m_x = m_x0;
if(m_pix_ptr &&
m_y >= 0 && m_y < (int)m_pixf->height())
if (m_pix_ptr && m_y >= 0 && m_y < (int)m_pixf->height())
{
return m_pix_ptr = m_pixf->pix_ptr(m_x, m_y);
}
@ -223,12 +204,9 @@ namespace agg
const int8u* m_pix_ptr;
};
//-----------------------------------------------------image_accessor_wrap
template<class PixFmt, class WrapX, class WrapY> class image_accessor_wrap
template<class PixFmt, class WrapX, class WrapY>
class image_accessor_wrap
{
public:
typedef PixFmt pixfmt_type;
@ -238,16 +216,13 @@ namespace agg
enum pix_width_e { pix_width = pixfmt_type::pix_width };
image_accessor_wrap() {}
explicit image_accessor_wrap(const pixfmt_type& pixf) :
m_pixf(&pixf),
m_wrap_x(pixf.width()),
m_wrap_y(pixf.height())
explicit image_accessor_wrap(const pixfmt_type& pixf)
: m_pixf(&pixf)
, m_wrap_x(pixf.width())
, m_wrap_y(pixf.height())
{}
void attach(const pixfmt_type& pixf)
{
m_pixf = &pixf;
}
void attach(const pixfmt_type& pixf) { m_pixf = &pixf; }
AGG_INLINE const int8u* span(int x, int y, unsigned)
{
@ -276,86 +251,83 @@ namespace agg
WrapY m_wrap_y;
};
//--------------------------------------------------------wrap_mode_repeat
class wrap_mode_repeat
{
public:
wrap_mode_repeat() {}
wrap_mode_repeat(unsigned size) :
m_size(size),
m_add(size * (0x3FFFFFFF / size)),
m_value(0)
wrap_mode_repeat(unsigned size)
: m_size(size)
, m_add(size * (0x3FFFFFFF / size))
, m_value(0)
{}
AGG_INLINE unsigned operator() (int v)
{
return m_value = (unsigned(v) + m_add) % m_size;
}
AGG_INLINE unsigned operator()(int v) { return m_value = (unsigned(v) + m_add) % m_size; }
AGG_INLINE unsigned operator++()
{
++m_value;
if(m_value >= m_size) m_value = 0;
if (m_value >= m_size)
m_value = 0;
return m_value;
}
private:
unsigned m_size;
unsigned m_add;
unsigned m_value;
};
//---------------------------------------------------wrap_mode_repeat_pow2
class wrap_mode_repeat_pow2
{
public:
wrap_mode_repeat_pow2() {}
wrap_mode_repeat_pow2(unsigned size) : m_value(0)
wrap_mode_repeat_pow2(unsigned size)
: m_value(0)
{
m_mask = 1;
while(m_mask < size) m_mask = (m_mask << 1) | 1;
while (m_mask < size)
m_mask = (m_mask << 1) | 1;
m_mask >>= 1;
}
AGG_INLINE unsigned operator() (int v)
{
return m_value = unsigned(v) & m_mask;
}
AGG_INLINE unsigned operator()(int v) { return m_value = unsigned(v) & m_mask; }
AGG_INLINE unsigned operator++()
{
++m_value;
if(m_value > m_mask) m_value = 0;
if (m_value > m_mask)
m_value = 0;
return m_value;
}
private:
unsigned m_mask;
unsigned m_value;
};
//----------------------------------------------wrap_mode_repeat_auto_pow2
class wrap_mode_repeat_auto_pow2
{
public:
wrap_mode_repeat_auto_pow2() {}
wrap_mode_repeat_auto_pow2(unsigned size) :
m_size(size),
m_add(size * (0x3FFFFFFF / size)),
m_mask((m_size & (m_size-1)) ? 0 : m_size-1),
m_value(0)
wrap_mode_repeat_auto_pow2(unsigned size)
: m_size(size)
, m_add(size * (0x3FFFFFFF / size))
, m_mask((m_size & (m_size - 1)) ? 0 : m_size - 1)
, m_value(0)
{}
AGG_INLINE unsigned operator()(int v)
{
if(m_mask) return m_value = unsigned(v) & m_mask;
if (m_mask)
return m_value = unsigned(v) & m_mask;
return m_value = (unsigned(v) + m_add) % m_size;
}
AGG_INLINE unsigned operator++()
{
++m_value;
if(m_value >= m_size) m_value = 0;
if (m_value >= m_size)
m_value = 0;
return m_value;
}
@ -366,33 +338,36 @@ namespace agg
unsigned m_value;
};
//-------------------------------------------------------wrap_mode_reflect
class wrap_mode_reflect
{
public:
wrap_mode_reflect() {}
wrap_mode_reflect(unsigned size) :
m_size(size),
m_size2(size * 2),
m_add(m_size2 * (0x3FFFFFFF / m_size2)),
m_value(0)
wrap_mode_reflect(unsigned size)
: m_size(size)
, m_size2(size * 2)
, m_add(m_size2 * (0x3FFFFFFF / m_size2))
, m_value(0)
{}
AGG_INLINE unsigned operator()(int v)
{
m_value = (unsigned(v) + m_add) % m_size2;
if(m_value >= m_size) return m_size2 - m_value - 1;
if (m_value >= m_size)
return m_size2 - m_value - 1;
return m_value;
}
AGG_INLINE unsigned operator++()
{
++m_value;
if(m_value >= m_size2) m_value = 0;
if(m_value >= m_size) return m_size2 - m_value - 1;
if (m_value >= m_size2)
m_value = 0;
if (m_value >= m_size)
return m_size2 - m_value - 1;
return m_value;
}
private:
unsigned m_size;
unsigned m_size2;
@ -400,14 +375,13 @@ namespace agg
unsigned m_value;
};
//--------------------------------------------------wrap_mode_reflect_pow2
class wrap_mode_reflect_pow2
{
public:
wrap_mode_reflect_pow2() {}
wrap_mode_reflect_pow2(unsigned size) : m_value(0)
wrap_mode_reflect_pow2(unsigned size)
: m_value(0)
{
m_mask = 1;
m_size = 1;
@ -420,49 +394,52 @@ namespace agg
AGG_INLINE unsigned operator()(int v)
{
m_value = unsigned(v) & m_mask;
if(m_value >= m_size) return m_mask - m_value;
if (m_value >= m_size)
return m_mask - m_value;
return m_value;
}
AGG_INLINE unsigned operator++()
{
++m_value;
m_value &= m_mask;
if(m_value >= m_size) return m_mask - m_value;
if (m_value >= m_size)
return m_mask - m_value;
return m_value;
}
private:
unsigned m_size;
unsigned m_mask;
unsigned m_value;
};
//---------------------------------------------wrap_mode_reflect_auto_pow2
class wrap_mode_reflect_auto_pow2
{
public:
wrap_mode_reflect_auto_pow2() {}
wrap_mode_reflect_auto_pow2(unsigned size) :
m_size(size),
m_size2(size * 2),
m_add(m_size2 * (0x3FFFFFFF / m_size2)),
m_mask((m_size2 & (m_size2-1)) ? 0 : m_size2-1),
m_value(0)
wrap_mode_reflect_auto_pow2(unsigned size)
: m_size(size)
, m_size2(size * 2)
, m_add(m_size2 * (0x3FFFFFFF / m_size2))
, m_mask((m_size2 & (m_size2 - 1)) ? 0 : m_size2 - 1)
, m_value(0)
{}
AGG_INLINE unsigned operator()(int v)
{
m_value = m_mask ? unsigned(v) & m_mask :
(unsigned(v) + m_add) % m_size2;
if(m_value >= m_size) return m_size2 - m_value - 1;
m_value = m_mask ? unsigned(v) & m_mask : (unsigned(v) + m_add) % m_size2;
if (m_value >= m_size)
return m_size2 - m_value - 1;
return m_value;
}
AGG_INLINE unsigned operator++()
{
++m_value;
if(m_value >= m_size2) m_value = 0;
if(m_value >= m_size) return m_size2 - m_value - 1;
if (m_value >= m_size2)
m_value = 0;
if (m_value >= m_size)
return m_size2 - m_value - 1;
return m_value;
}
@ -474,8 +451,6 @@ namespace agg
unsigned m_value;
};
}
} // namespace agg
#endif

293
deps/agg/include/agg_image_filters.h vendored
View file

@ -24,32 +24,28 @@
#include "agg_math.h"
#include <cstdint>
namespace agg
{
namespace agg {
// See Implementation agg_image_filters.cpp
enum image_filter_scale_e
{
enum image_filter_scale_e {
image_filter_shift = 14, //----image_filter_shift
image_filter_scale = 1 << image_filter_shift, //----image_filter_scale
image_filter_mask = image_filter_scale - 1 //----image_filter_mask
};
enum image_subpixel_scale_e
{
enum image_subpixel_scale_e {
image_subpixel_shift = 8, //----image_subpixel_shift
image_subpixel_scale = 1 << image_subpixel_shift, //----image_subpixel_scale
image_subpixel_mask = image_subpixel_scale - 1 //----image_subpixel_mask
};
//-----------------------------------------------------image_filter_lut
class image_filter_lut
{
public:
template<class FilterF> void calculate(const FilterF& filter,
bool normalization=true)
template<class FilterF>
void calculate(const FilterF& filter, bool normalization = true)
{
double r = filter.radius();
realloc_lut(r);
@ -59,8 +55,7 @@ namespace agg
{
double x = double(i) / double(image_subpixel_scale);
double y = filter.calc_weight(x);
m_weight_array[pivot + i] =
m_weight_array[pivot - i] =
m_weight_array[pivot + i] = m_weight_array[pivot - i] =
static_cast<std::int16_t>(iround(y * static_cast<double>(image_filter_scale)));
}
unsigned end = (diameter() << image_subpixel_shift) - 1;
@ -71,10 +66,14 @@ namespace agg
}
}
image_filter_lut() : m_radius(0), m_diameter(0), m_start(0) {}
image_filter_lut()
: m_radius(0)
, m_diameter(0)
, m_start(0)
{}
template<class FilterF> image_filter_lut(const FilterF& filter,
bool normalization=true)
template<class FilterF>
image_filter_lut(const FilterF& filter, bool normalization = true)
{
calculate(filter, normalization);
}
@ -96,61 +95,43 @@ namespace agg
pod_array<std::int16_t> m_weight_array;
};
//--------------------------------------------------------image_filter
template<class FilterF> class image_filter : public image_filter_lut
template<class FilterF>
class image_filter : public image_filter_lut
{
public:
image_filter()
{
calculate(m_filter_function);
}
image_filter() { calculate(m_filter_function); }
private:
FilterF m_filter_function;
};
//-----------------------------------------------image_filter_bilinear
struct image_filter_bilinear
{
static double radius() { return 1.0; }
static double calc_weight(double x)
{
return 1.0 - x;
}
static double calc_weight(double x) { return 1.0 - x; }
};
//-----------------------------------------------image_filter_hanning
struct image_filter_hanning
{
static double radius() { return 1.0; }
static double calc_weight(double x)
{
return 0.5 + 0.5 * std::cos(pi * x);
}
static double calc_weight(double x) { return 0.5 + 0.5 * std::cos(pi * x); }
};
//-----------------------------------------------image_filter_hamming
struct image_filter_hamming
{
static double radius() { return 1.0; }
static double calc_weight(double x)
{
return 0.54 + 0.46 * std::cos(pi * x);
}
static double calc_weight(double x) { return 0.54 + 0.46 * std::cos(pi * x); }
};
//-----------------------------------------------image_filter_hermite
struct image_filter_hermite
{
static double radius() { return 1.0; }
static double calc_weight(double x)
{
return (2.0 * x - 3.0) * x * x + 1.0;
}
static double calc_weight(double x) { return (2.0 * x - 3.0) * x * x + 1.0; }
};
//------------------------------------------------image_filter_quadric
@ -160,8 +141,13 @@ namespace agg
static double calc_weight(double x)
{
double t;
if(x < 0.5) return 0.75 - x * x;
if(x < 1.5) {t = x - 1.5; return 0.5 * t * t;}
if (x < 0.5)
return 0.75 - x * x;
if (x < 1.5)
{
t = x - 1.5;
return 0.5 * t * t;
}
return 0.0;
}
};
@ -169,18 +155,13 @@ namespace agg
//------------------------------------------------image_filter_bicubic
class image_filter_bicubic
{
static double pow3(double x)
{
return (x <= 0.0) ? 0.0 : x * x * x;
}
static double pow3(double x) { return (x <= 0.0) ? 0.0 : x * x * x; }
public:
static double radius() { return 2.0; }
static double calc_weight(double x)
{
return
(1.0/6.0) *
(pow3(x + 2) - 4 * pow3(x + 1) + 6 * pow3(x) - 4 * pow3(x - 1));
return (1.0 / 6.0) * (pow3(x + 2) - 4 * pow3(x + 1) + 6 * pow3(x) - 4 * pow3(x - 1));
}
};
@ -192,17 +173,15 @@ namespace agg
double epsilon;
public:
image_filter_kaiser(double b = 6.33) :
a(b), epsilon(1e-12)
image_filter_kaiser(double b = 6.33)
: a(b)
, epsilon(1e-12)
{
i0a = 1.0 / bessel_i0(b);
}
static double radius() { return 1.0; }
double calc_weight(double x) const
{
return bessel_i0(a * sqrt(1. - x * x)) * i0a;
}
double calc_weight(double x) const { return bessel_i0(a * sqrt(1. - x * x)) * i0a; }
private:
double bessel_i0(double x) const
@ -229,8 +208,10 @@ namespace agg
static double radius() { return 2.0; }
static double calc_weight(double x)
{
if(x < 1.0) return 0.5 * (2.0 + x * x * (-5.0 + x * 3.0));
if(x < 2.0) return 0.5 * (4.0 + x * (-8.0 + x * (5.0 - x)));
if (x < 1.0)
return 0.5 * (2.0 + x * x * (-5.0 + x * 3.0));
if (x < 2.0)
return 0.5 * (4.0 + x * (-8.0 + x * (5.0 - x)));
return 0.;
}
};
@ -242,26 +223,27 @@ namespace agg
double q0, q1, q2, q3;
public:
image_filter_mitchell(double b = 1.0/3.0, double c = 1.0/3.0) :
p0((6.0 - 2.0 * b) / 6.0),
p2((-18.0 + 12.0 * b + 6.0 * c) / 6.0),
p3((12.0 - 9.0 * b - 6.0 * c) / 6.0),
q0((8.0 * b + 24.0 * c) / 6.0),
q1((-12.0 * b - 48.0 * c) / 6.0),
q2((6.0 * b + 30.0 * c) / 6.0),
q3((-b - 6.0 * c) / 6.0)
image_filter_mitchell(double b = 1.0 / 3.0, double c = 1.0 / 3.0)
: p0((6.0 - 2.0 * b) / 6.0)
, p2((-18.0 + 12.0 * b + 6.0 * c) / 6.0)
, p3((12.0 - 9.0 * b - 6.0 * c) / 6.0)
, q0((8.0 * b + 24.0 * c) / 6.0)
, q1((-12.0 * b - 48.0 * c) / 6.0)
, q2((6.0 * b + 30.0 * c) / 6.0)
, q3((-b - 6.0 * c) / 6.0)
{}
static double radius() { return 2.0; }
double calc_weight(double x) const
{
if(x < 1.0) return p0 + x * x * (p2 + x * p3);
if(x < 2.0) return q0 + x * (q1 + x * (q2 + x * q3));
if (x < 1.0)
return p0 + x * x * (p2 + x * p3);
if (x < 2.0)
return q0 + x * (q1 + x * (q2 + x * q3));
return 0.0;
}
};
//----------------------------------------------image_filter_spline16
struct image_filter_spline16
{
@ -276,7 +258,6 @@ namespace agg
}
};
//---------------------------------------------image_filter_spline36
struct image_filter_spline36
{
@ -295,156 +276,248 @@ namespace agg
}
};
//----------------------------------------------image_filter_gaussian
struct image_filter_gaussian
{
static double radius() { return 2.0; }
static double calc_weight(double x)
{
return exp(-2.0 * x * x) * sqrt(2.0 / pi);
}
static double calc_weight(double x) { return exp(-2.0 * x * x) * sqrt(2.0 / pi); }
};
//------------------------------------------------image_filter_bessel
struct image_filter_bessel
{
static double radius() { return 3.2383; }
static double calc_weight(double x)
{
return (x == 0.0) ? pi / 4.0 : besj(pi * x, 1) / (2.0 * x);
}
static double calc_weight(double x) { return (x == 0.0) ? pi / 4.0 : besj(pi * x, 1) / (2.0 * x); }
};
//-------------------------------------------------image_filter_sinc
class image_filter_sinc
{
public:
image_filter_sinc(double r) : m_radius(r < 2.0 ? 2.0 : r) {}
image_filter_sinc(double r)
: m_radius(r < 2.0 ? 2.0 : r)
{}
double radius() const { return m_radius; }
double calc_weight(double x) const
{
if(x == 0.0) return 1.0;
if (x == 0.0)
return 1.0;
x *= pi;
return std::sin(x) / x;
}
private:
double m_radius;
};
//-----------------------------------------------image_filter_lanczos
class image_filter_lanczos
{
public:
image_filter_lanczos(double r) : m_radius(r < 2.0 ? 2.0 : r) {}
image_filter_lanczos(double r)
: m_radius(r < 2.0 ? 2.0 : r)
{}
double radius() const { return m_radius; }
double calc_weight(double x) const
{
if(x == 0.0) return 1.0;
if(x > m_radius) return 0.0;
if (x == 0.0)
return 1.0;
if (x > m_radius)
return 0.0;
x *= pi;
double xr = x / m_radius;
return (std::sin(x) / x) * (std::sin(xr) / xr);
}
private:
double m_radius;
};
//----------------------------------------------image_filter_blackman
class image_filter_blackman
{
public:
image_filter_blackman(double r) : m_radius(r < 2.0 ? 2.0 : r) {}
image_filter_blackman(double r)
: m_radius(r < 2.0 ? 2.0 : r)
{}
double radius() const { return m_radius; }
double calc_weight(double x) const
{
if(x == 0.0) return 1.0;
if(x > m_radius) return 0.0;
if (x == 0.0)
return 1.0;
if (x > m_radius)
return 0.0;
x *= pi;
double xr = x / m_radius;
return (std::sin(x) / x) * (0.42 + 0.5 * std::cos(xr) + 0.08 * std::cos(2 * xr));
}
private:
double m_radius;
};
//------------------------------------------------image_filter_sinc36
class image_filter_sinc36 : public image_filter_sinc
{ public: image_filter_sinc36() : image_filter_sinc(3.0){} };
{
public:
image_filter_sinc36()
: image_filter_sinc(3.0)
{}
};
//------------------------------------------------image_filter_sinc64
class image_filter_sinc64 : public image_filter_sinc
{ public: image_filter_sinc64() : image_filter_sinc(4.0){} };
{
public:
image_filter_sinc64()
: image_filter_sinc(4.0)
{}
};
//-----------------------------------------------image_filter_sinc100
class image_filter_sinc100 : public image_filter_sinc
{ public: image_filter_sinc100() : image_filter_sinc(5.0){} };
{
public:
image_filter_sinc100()
: image_filter_sinc(5.0)
{}
};
//-----------------------------------------------image_filter_sinc144
class image_filter_sinc144 : public image_filter_sinc
{ public: image_filter_sinc144() : image_filter_sinc(6.0){} };
{
public:
image_filter_sinc144()
: image_filter_sinc(6.0)
{}
};
//-----------------------------------------------image_filter_sinc196
class image_filter_sinc196 : public image_filter_sinc
{ public: image_filter_sinc196() : image_filter_sinc(7.0){} };
{
public:
image_filter_sinc196()
: image_filter_sinc(7.0)
{}
};
//-----------------------------------------------image_filter_sinc256
class image_filter_sinc256 : public image_filter_sinc
{ public: image_filter_sinc256() : image_filter_sinc(8.0){} };
{
public:
image_filter_sinc256()
: image_filter_sinc(8.0)
{}
};
//---------------------------------------------image_filter_lanczos36
class image_filter_lanczos36 : public image_filter_lanczos
{ public: image_filter_lanczos36() : image_filter_lanczos(3.0){} };
{
public:
image_filter_lanczos36()
: image_filter_lanczos(3.0)
{}
};
//---------------------------------------------image_filter_lanczos64
class image_filter_lanczos64 : public image_filter_lanczos
{ public: image_filter_lanczos64() : image_filter_lanczos(4.0){} };
{
public:
image_filter_lanczos64()
: image_filter_lanczos(4.0)
{}
};
//--------------------------------------------image_filter_lanczos100
class image_filter_lanczos100 : public image_filter_lanczos
{ public: image_filter_lanczos100() : image_filter_lanczos(5.0){} };
{
public:
image_filter_lanczos100()
: image_filter_lanczos(5.0)
{}
};
//--------------------------------------------image_filter_lanczos144
class image_filter_lanczos144 : public image_filter_lanczos
{ public: image_filter_lanczos144() : image_filter_lanczos(6.0){} };
{
public:
image_filter_lanczos144()
: image_filter_lanczos(6.0)
{}
};
//--------------------------------------------image_filter_lanczos196
class image_filter_lanczos196 : public image_filter_lanczos
{ public: image_filter_lanczos196() : image_filter_lanczos(7.0){} };
{
public:
image_filter_lanczos196()
: image_filter_lanczos(7.0)
{}
};
//--------------------------------------------image_filter_lanczos256
class image_filter_lanczos256 : public image_filter_lanczos
{ public: image_filter_lanczos256() : image_filter_lanczos(8.0){} };
{
public:
image_filter_lanczos256()
: image_filter_lanczos(8.0)
{}
};
//--------------------------------------------image_filter_blackman36
class image_filter_blackman36 : public image_filter_blackman
{ public: image_filter_blackman36() : image_filter_blackman(3.0){} };
{
public:
image_filter_blackman36()
: image_filter_blackman(3.0)
{}
};
//--------------------------------------------image_filter_blackman64
class image_filter_blackman64 : public image_filter_blackman
{ public: image_filter_blackman64() : image_filter_blackman(4.0){} };
{
public:
image_filter_blackman64()
: image_filter_blackman(4.0)
{}
};
//-------------------------------------------image_filter_blackman100
class image_filter_blackman100 : public image_filter_blackman
{ public: image_filter_blackman100() : image_filter_blackman(5.0){} };
{
public:
image_filter_blackman100()
: image_filter_blackman(5.0)
{}
};
//-------------------------------------------image_filter_blackman144
class image_filter_blackman144 : public image_filter_blackman
{ public: image_filter_blackman144() : image_filter_blackman(6.0){} };
{
public:
image_filter_blackman144()
: image_filter_blackman(6.0)
{}
};
//-------------------------------------------image_filter_blackman196
class image_filter_blackman196 : public image_filter_blackman
{ public: image_filter_blackman196() : image_filter_blackman(7.0){} };
{
public:
image_filter_blackman196()
: image_filter_blackman(7.0)
{}
};
//-------------------------------------------image_filter_blackman256
class image_filter_blackman256 : public image_filter_blackman
{ public: image_filter_blackman256() : image_filter_blackman(8.0){} };
{
public:
image_filter_blackman256()
: image_filter_blackman(8.0)
{}
};
}
} // namespace agg
#endif

63
deps/agg/include/agg_line_aa_basics.h vendored
View file

@ -18,14 +18,12 @@
#include <cstdlib>
#include "agg_basics.h"
namespace agg
{
namespace agg {
// See Implementation agg_line_aa_basics.cpp
//-------------------------------------------------------------------------
enum line_subpixel_scale_e
{
enum line_subpixel_scale_e {
line_subpixel_shift = 8, //----line_subpixel_shift
line_subpixel_scale = 1 << line_subpixel_shift, //----line_subpixel_scale
line_subpixel_mask = line_subpixel_scale - 1, //----line_subpixel_mask
@ -34,8 +32,7 @@ namespace agg
};
//-------------------------------------------------------------------------
enum line_mr_subpixel_scale_e
{
enum line_mr_subpixel_scale_e {
line_mr_subpixel_shift = 4, //----line_mr_subpixel_shift
line_mr_subpixel_scale = 1 << line_mr_subpixel_shift, //----line_mr_subpixel_scale
line_mr_subpixel_mask = line_mr_subpixel_scale - 1 //----line_mr_subpixel_mask
@ -62,10 +59,7 @@ namespace agg
//---------------------------------------------------------------line_coord
struct line_coord
{
AGG_INLINE static int conv(double x)
{
return iround(x * static_cast<double>(line_subpixel_scale));
}
AGG_INLINE static int conv(double x) { return iround(x * static_cast<double>(line_subpixel_scale)); }
};
//-----------------------------------------------------------line_coord_sat
@ -82,18 +76,20 @@ namespace agg
{
//---------------------------------------------------------------------
line_parameters() {}
line_parameters(int x1_, int y1_, int x2_, int y2_, int len_) :
x1(x1_), y1(y1_), x2(x2_), y2(y2_),
dx(std::abs(x2_ - x1_)),
dy(std::abs(y2_ - y1_)),
sx((x2_ > x1_) ? 1 : -1),
sy((y2_ > y1_) ? 1 : -1),
vertical(dy >= dx),
inc(vertical ? sy : sx),
len(len_),
octant((sy & 4) | (sx & 2) | int(vertical))
{
}
line_parameters(int x1_, int y1_, int x2_, int y2_, int len_)
: x1(x1_)
, y1(y1_)
, x2(x2_)
, y2(y2_)
, dx(std::abs(x2_ - x1_))
, dy(std::abs(y2_ - y1_))
, sx((x2_ > x1_) ? 1 : -1)
, sy((y2_ > y1_) ? 1 : -1)
, vertical(dy >= dx)
, inc(vertical ? sy : sx)
, len(len_)
, octant((sy & 4) | (sx & 2) | int(vertical))
{}
//---------------------------------------------------------------------
unsigned orthogonal_quadrant() const { return s_orthogonal_quadrant[octant]; }
@ -146,22 +142,15 @@ namespace agg
static const int8u s_diagonal_quadrant[8];
};
// See Implementation agg_line_aa_basics.cpp
//----------------------------------------------------------------bisectrix
void bisectrix(const line_parameters& l1,
const line_parameters& l2,
int* x, int* y);
void bisectrix(const line_parameters& l1, const line_parameters& l2, int* x, int* y);
//-------------------------------------------fix_degenerate_bisectrix_start
void inline fix_degenerate_bisectrix_start(const line_parameters& lp,
int* x, int* y)
void inline fix_degenerate_bisectrix_start(const line_parameters& lp, int* x, int* y)
{
int d = iround((double(*x - lp.x2) * double(lp.y2 - lp.y1) -
double(*y - lp.y2) * double(lp.x2 - lp.x1)) / lp.len);
int d = iround((double(*x - lp.x2) * double(lp.y2 - lp.y1) - double(*y - lp.y2) * double(lp.x2 - lp.x1)) / lp.len);
if (d < line_subpixel_scale / 2)
{
*x = lp.x1 + (lp.y2 - lp.y1);
@ -169,13 +158,10 @@ namespace agg
}
}
//---------------------------------------------fix_degenerate_bisectrix_end
void inline fix_degenerate_bisectrix_end(const line_parameters& lp,
int* x, int* y)
void inline fix_degenerate_bisectrix_end(const line_parameters& lp, int* x, int* y)
{
int d = iround((double(*x - lp.x2) * double(lp.y2 - lp.y1) -
double(*y - lp.y2) * double(lp.x2 - lp.x1)) / lp.len);
int d = iround((double(*x - lp.x2) * double(lp.y2 - lp.y1) - double(*y - lp.y2) * double(lp.x2 - lp.x1)) / lp.len);
if (d < line_subpixel_scale / 2)
{
*x = lp.x2 + (lp.y2 - lp.y1);
@ -183,7 +169,6 @@ namespace agg
}
}
}
} // namespace agg
#endif

114
deps/agg/include/agg_math.h vendored
View file

@ -22,8 +22,7 @@
#include <cmath>
#include "agg_basics.h"
namespace agg
{
namespace agg {
//------------------------------------------------------vertex_dist_epsilon
// Coinciding points maximal distance (Epsilon)
@ -34,18 +33,13 @@ namespace agg
const double intersection_epsilon = 1.0e-30;
//------------------------------------------------------------cross_product
AGG_INLINE double cross_product(double x1, double y1,
double x2, double y2,
double x, double y)
AGG_INLINE double cross_product(double x1, double y1, double x2, double y2, double x, double y)
{
return (x - x2) * (y2 - y1) - (y - y2) * (x2 - x1);
}
//--------------------------------------------------------point_in_triangle
AGG_INLINE bool point_in_triangle(double x1, double y1,
double x2, double y2,
double x3, double y3,
double x, double y)
AGG_INLINE bool point_in_triangle(double x1, double y1, double x2, double y2, double x3, double y3, double x, double y)
{
bool cp1 = cross_product(x1, y1, x2, y2, x, y) < 0.0;
bool cp2 = cross_product(x2, y2, x3, y3, x, y) < 0.0;
@ -70,9 +64,7 @@ namespace agg
}
//------------------------------------------------calc_line_point_distance
AGG_INLINE double calc_line_point_distance(double x1, double y1,
double x2, double y2,
double x, double y)
AGG_INLINE double calc_line_point_distance(double x1, double y1, double x2, double y2, double x, double y)
{
double dx = x2 - x1;
double dy = y2 - y1;
@ -85,9 +77,7 @@ namespace agg
}
//-------------------------------------------------------calc_line_point_u
AGG_INLINE double calc_segment_point_u(double x1, double y1,
double x2, double y2,
double x, double y)
AGG_INLINE double calc_segment_point_u(double x1, double y1, double x2, double y2, double x, double y)
{
double dx = x2 - x1;
double dy = y2 - y1;
@ -104,17 +94,14 @@ namespace agg
}
//---------------------------------------------calc_line_point_sq_distance
AGG_INLINE double calc_segment_point_sq_distance(double x1, double y1,
double x2, double y2,
double x, double y,
double u)
AGG_INLINE double
calc_segment_point_sq_distance(double x1, double y1, double x2, double y2, double x, double y, double u)
{
if (u <= 0)
{
return calc_sq_distance(x, y, x1, y1);
}
else
if(u >= 1)
else if (u >= 1)
{
return calc_sq_distance(x, y, x2, y2);
}
@ -122,24 +109,27 @@ namespace agg
}
//---------------------------------------------calc_line_point_sq_distance
AGG_INLINE double calc_segment_point_sq_distance(double x1, double y1,
double x2, double y2,
double x, double y)
AGG_INLINE double calc_segment_point_sq_distance(double x1, double y1, double x2, double y2, double x, double y)
{
return
calc_segment_point_sq_distance(
x1, y1, x2, y2, x, y,
calc_segment_point_u(x1, y1, x2, y2, x, y));
return calc_segment_point_sq_distance(x1, y1, x2, y2, x, y, calc_segment_point_u(x1, y1, x2, y2, x, y));
}
//-------------------------------------------------------calc_intersection
AGG_INLINE bool calc_intersection(double ax, double ay, double bx, double by,
double cx, double cy, double dx, double dy,
double* x, double* y)
AGG_INLINE bool calc_intersection(double ax,
double ay,
double bx,
double by,
double cx,
double cy,
double dx,
double dy,
double* x,
double* y)
{
double num = (ay - cy) * (dx - cx) - (ax - cx) * (dy - cy);
double den = (bx - ax) * (dy - cy) - (by - ay) * (dx - cx);
if(std::fabs(den) < intersection_epsilon) return false;
if (std::fabs(den) < intersection_epsilon)
return false;
double r = num / den;
*x = ax + r * (bx - ax);
*y = ay + r * (by - ay);
@ -147,8 +137,8 @@ namespace agg
}
//-----------------------------------------------------intersection_exists
AGG_INLINE bool intersection_exists(double x1, double y1, double x2, double y2,
double x3, double y3, double x4, double y4)
AGG_INLINE bool
intersection_exists(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
{
// It's less expensive but you can't control the
// boundary conditions: Less or LessEqual
@ -156,10 +146,8 @@ namespace agg
double dy1 = y2 - y1;
double dx2 = x4 - x3;
double dy2 = y4 - y3;
return ((x3 - x2) * dy1 - (y3 - y2) * dx1 < 0.0) !=
((x4 - x2) * dy1 - (y4 - y2) * dx1 < 0.0) &&
((x1 - x4) * dy2 - (y1 - y4) * dx2 < 0.0) !=
((x2 - x4) * dy2 - (y2 - y4) * dx2 < 0.0);
return ((x3 - x2) * dy1 - (y3 - y2) * dx1 < 0.0) != ((x4 - x2) * dy1 - (y4 - y2) * dx1 < 0.0) &&
((x1 - x4) * dy2 - (y1 - y4) * dx2 < 0.0) != ((x2 - x4) * dy2 - (y2 - y4) * dx2 < 0.0);
// It's is more expensive but more flexible
// in terms of boundary conditions.
@ -174,10 +162,7 @@ namespace agg
}
//--------------------------------------------------------calc_orthogonal
AGG_INLINE void calc_orthogonal(double thickness,
double x1, double y1,
double x2, double y2,
double* x, double* y)
AGG_INLINE void calc_orthogonal(double thickness, double x1, double y1, double x2, double y2, double* x, double* y)
{
double dx = x2 - x1;
double dy = y2 - y1;
@ -187,11 +172,8 @@ namespace agg
}
//--------------------------------------------------------dilate_triangle
AGG_INLINE void dilate_triangle(double x1, double y1,
double x2, double y2,
double x3, double y3,
double *x, double* y,
double d)
AGG_INLINE void
dilate_triangle(double x1, double y1, double x2, double y2, double x3, double y3, double* x, double* y, double d)
{
double dx1 = 0.0;
double dy1 = 0.0;
@ -210,24 +192,29 @@ namespace agg
calc_orthogonal(d, x2, y2, x3, y3, &dx2, &dy2);
calc_orthogonal(d, x3, y3, x1, y1, &dx3, &dy3);
}
*x++ = x1 + dx1; *y++ = y1 + dy1;
*x++ = x2 + dx1; *y++ = y2 + dy1;
*x++ = x2 + dx2; *y++ = y2 + dy2;
*x++ = x3 + dx2; *y++ = y3 + dy2;
*x++ = x3 + dx3; *y++ = y3 + dy3;
*x++ = x1 + dx3; *y++ = y1 + dy3;
*x++ = x1 + dx1;
*y++ = y1 + dy1;
*x++ = x2 + dx1;
*y++ = y2 + dy1;
*x++ = x2 + dx2;
*y++ = y2 + dy2;
*x++ = x3 + dx2;
*y++ = y3 + dy2;
*x++ = x3 + dx3;
*y++ = y3 + dy3;
*x++ = x1 + dx3;
*y++ = y1 + dy3;
}
//------------------------------------------------------calc_triangle_area
AGG_INLINE double calc_triangle_area(double x1, double y1,
double x2, double y2,
double x3, double y3)
AGG_INLINE double calc_triangle_area(double x1, double y1, double x2, double y2, double x3, double y3)
{
return (x1 * y2 - x2 * y1 + x2 * y3 - x3 * y2 + x3 * y1 - x1 * y3) * 0.5;
}
//-------------------------------------------------------calc_polygon_area
template<class Storage> double calc_polygon_area(const Storage& st)
template<class Storage>
double calc_polygon_area(const Storage& st)
{
unsigned i;
double sum = 0.0;
@ -251,7 +238,6 @@ namespace agg
extern int16u g_sqrt_table[1024];
extern int8 g_elder_bit_table[256];
//---------------------------------------------------------------fast_sqrt
// Fast integer Sqrt - really fast: no cycles, divisions or multiplications
#if defined(_MSC_VER)
@ -265,8 +251,7 @@ namespace agg
// The key command here is bsr - determination the number of the most
// significant bit of the value. For other processors
//(and maybe compilers) the pure C "#else" section is used.
__asm
{
__asm {
mov ebx, val
mov edx, 11
bsr ecx, ebx
@ -337,9 +322,6 @@ namespace agg
#pragma warning(pop)
#endif
//--------------------------------------------------------------------besj
// Function BESJ calculates Bessel function of first kind of order n
// Arguments:
@ -372,7 +354,8 @@ namespace agg
double b = 0;
if (std::fabs(x) <= d)
{
if(n != 0) return 0;
if (n != 0)
return 0;
return 1;
}
double b1 = 0; // b1 is the value from the previous iteration
@ -431,7 +414,6 @@ namespace agg
}
}
}
} // namespace agg
#endif

175
deps/agg/include/agg_math_stroke.h vendored
View file

@ -23,38 +23,19 @@
#include "agg_math.h"
#include "agg_vertex_sequence.h"
namespace agg
{
namespace agg {
//-------------------------------------------------------------line_cap_e
enum line_cap_e
{
butt_cap,
square_cap,
round_cap
};
enum line_cap_e { butt_cap, square_cap, round_cap };
//------------------------------------------------------------line_join_e
enum line_join_e
{
miter_join = 0,
miter_join_revert = 1,
round_join = 2,
bevel_join = 3,
miter_join_round = 4
};
enum line_join_e { miter_join = 0, miter_join_revert = 1, round_join = 2, bevel_join = 3, miter_join_round = 4 };
//-----------------------------------------------------------inner_join_e
enum inner_join_e
{
inner_bevel,
inner_miter,
inner_jag,
inner_round
};
enum inner_join_e { inner_bevel, inner_miter, inner_jag, inner_round };
//------------------------------------------------------------math_stroke
template<class VertexConsumer> class math_stroke
template<class VertexConsumer>
class math_stroke
{
public:
typedef typename VertexConsumer::value_type coord_type;
@ -80,10 +61,7 @@ namespace agg
double inner_miter_limit() const { return m_inner_miter_limit; }
double approximation_scale() const { return m_approx_scale; }
void calc_cap(VertexConsumer& vc,
const vertex_dist& v0,
const vertex_dist& v1,
double len);
void calc_cap(VertexConsumer& vc, const vertex_dist& v0, const vertex_dist& v1, double len);
void calc_join(VertexConsumer& vc,
const vertex_dist& v0,
@ -93,22 +71,18 @@ namespace agg
double len2);
private:
AGG_INLINE void add_vertex(VertexConsumer& vc, double x, double y)
{
vc.add(coord_type(x, y));
}
AGG_INLINE void add_vertex(VertexConsumer& vc, double x, double y) { vc.add(coord_type(x, y)); }
void calc_arc(VertexConsumer& vc,
double x, double y,
double dx1, double dy1,
double dx2, double dy2);
void calc_arc(VertexConsumer& vc, double x, double y, double dx1, double dy1, double dx2, double dy2);
void calc_miter(VertexConsumer& vc,
const vertex_dist& v0,
const vertex_dist& v1,
const vertex_dist& v2,
double dx1, double dy1,
double dx2, double dy2,
double dx1,
double dy1,
double dx2,
double dy2,
line_join_e lj,
double mlimit,
double dbevel);
@ -126,22 +100,23 @@ namespace agg
};
//-----------------------------------------------------------------------
template<class VC> math_stroke<VC>::math_stroke() :
m_width(0.5),
m_width_abs(0.5),
m_width_eps(0.5/1024.0),
m_width_sign(1),
m_miter_limit(4.0),
m_inner_miter_limit(1.01),
m_approx_scale(1.0),
m_line_cap(butt_cap),
m_line_join(miter_join),
m_inner_join(inner_miter)
{
}
template<class VC>
math_stroke<VC>::math_stroke()
: m_width(0.5)
, m_width_abs(0.5)
, m_width_eps(0.5 / 1024.0)
, m_width_sign(1)
, m_miter_limit(4.0)
, m_inner_miter_limit(1.01)
, m_approx_scale(1.0)
, m_line_cap(butt_cap)
, m_line_join(miter_join)
, m_inner_join(inner_miter)
{}
//-----------------------------------------------------------------------
template<class VC> void math_stroke<VC>::width(double w)
template<class VC>
void math_stroke<VC>::width(double w)
{
m_width = w * 0.5;
if (m_width < 0)
@ -158,17 +133,15 @@ namespace agg
}
//-----------------------------------------------------------------------
template<class VC> void math_stroke<VC>::miter_limit_theta(double t)
template<class VC>
void math_stroke<VC>::miter_limit_theta(double t)
{
m_miter_limit = 1.0 / std::sin(t * 0.5);
}
//-----------------------------------------------------------------------
template<class VC>
void math_stroke<VC>::calc_arc(VC& vc,
double x, double y,
double dx1, double dy1,
double dx2, double dy2)
void math_stroke<VC>::calc_arc(VC& vc, double x, double y, double dx1, double dy1, double dx2, double dy2)
{
double a1 = std::atan2(dy1 * m_width_sign, dx1 * m_width_sign);
double a2 = std::atan2(dy2 * m_width_sign, dx2 * m_width_sign);
@ -180,7 +153,8 @@ namespace agg
add_vertex(vc, x + dx1, y + dy1);
if (m_width_sign > 0)
{
if(a1 > a2) a2 += 2 * pi;
if (a1 > a2)
a2 += 2 * pi;
n = int((a2 - a1) / da);
da = (a2 - a1) / (n + 1);
a1 += da;
@ -192,7 +166,8 @@ namespace agg
}
else
{
if(a1 < a2) a2 -= 2 * pi;
if (a1 < a2)
a2 -= 2 * pi;
n = int((a1 - a2) / da);
da = (a1 - a2) / (n + 1);
a1 -= da;
@ -211,8 +186,10 @@ namespace agg
const vertex_dist& v0,
const vertex_dist& v1,
const vertex_dist& v2,
double dx1, double dy1,
double dx2, double dy2,
double dx1,
double dy1,
double dx2,
double dy2,
line_join_e lj,
double mlimit,
double dbevel)
@ -224,11 +201,16 @@ namespace agg
bool miter_limit_exceeded = true; // Assume the worst
bool intersection_failed = true; // Assume the worst
if(calc_intersection(v0.x + dx1, v0.y - dy1,
v1.x + dx1, v1.y - dy1,
v1.x + dx2, v1.y - dy2,
v2.x + dx2, v2.y - dy2,
&xi, &yi))
if (calc_intersection(v0.x + dx1,
v0.y - dy1,
v1.x + dx1,
v1.y - dy1,
v1.x + dx2,
v1.y - dy2,
v2.x + dx2,
v2.y - dy2,
&xi,
&yi))
{
// Calculation of the intersection succeeded
//---------------------
@ -290,10 +272,8 @@ namespace agg
if (intersection_failed)
{
mlimit *= m_width_sign;
add_vertex(vc, v1.x + dx1 + dy1 * mlimit,
v1.y - dy1 + dx1 * mlimit);
add_vertex(vc, v1.x + dx2 - dy2 * mlimit,
v1.y - dy2 - dx2 * mlimit);
add_vertex(vc, v1.x + dx1 + dy1 * mlimit, v1.y - dy1 + dx1 * mlimit);
add_vertex(vc, v1.x + dx2 - dy2 * mlimit, v1.y - dy2 - dx2 * mlimit);
}
else
{
@ -302,10 +282,8 @@ namespace agg
double x2 = v1.x + dx2;
double y2 = v1.y - dy2;
di = (lim - dbevel) / (di - dbevel);
add_vertex(vc, x1 + (xi - x1) * di,
y1 + (yi - y1) * di);
add_vertex(vc, x2 + (xi - x2) * di,
y2 + (yi - y2) * di);
add_vertex(vc, x1 + (xi - x1) * di, y1 + (yi - y1) * di);
add_vertex(vc, x2 + (xi - x2) * di, y2 + (yi - y2) * di);
}
break;
}
@ -314,10 +292,7 @@ namespace agg
//--------------------------------------------------------stroke_calc_cap
template<class VC>
void math_stroke<VC>::calc_cap(VC& vc,
const vertex_dist& v0,
const vertex_dist& v1,
double len)
void math_stroke<VC>::calc_cap(VC& vc, const vertex_dist& v0, const vertex_dist& v1, double len)
{
vc.remove_all();
@ -354,8 +329,7 @@ namespace agg
a1 += da;
for (i = 0; i < n; i++)
{
add_vertex(vc, v0.x + std::cos(a1) * m_width,
v0.y + std::sin(a1) * m_width);
add_vertex(vc, v0.x + std::cos(a1) * m_width, v0.y + std::sin(a1) * m_width);
a1 += da;
}
}
@ -365,8 +339,7 @@ namespace agg
a1 -= da;
for (i = 0; i < n; i++)
{
add_vertex(vc, v0.x + std::cos(a1) * m_width,
v0.y + std::sin(a1) * m_width);
add_vertex(vc, v0.x + std::cos(a1) * m_width, v0.y + std::sin(a1) * m_width);
a1 -= da;
}
}
@ -409,10 +382,7 @@ namespace agg
break;
case inner_miter:
calc_miter(vc,
v0, v1, v2, dx1, dy1, dx2, dy2,
miter_join_revert,
limit, 0);
calc_miter(vc, v0, v1, v2, dx1, dy1, dx2, dy2, miter_join_revert, limit, 0);
break;
case inner_jag:
@ -420,10 +390,7 @@ namespace agg
cp = (dx1 - dx2) * (dx1 - dx2) + (dy1 - dy2) * (dy1 - dy2);
if (cp < len1 * len1 && cp < len2 * len2)
{
calc_miter(vc,
v0, v1, v2, dx1, dy1, dx2, dy2,
miter_join_revert,
limit, 0);
calc_miter(vc, v0, v1, v2, dx1, dy1, dx2, dy2, miter_join_revert, limit, 0);
}
else
{
@ -478,11 +445,16 @@ namespace agg
//-------------------
if (m_approx_scale * (m_width_abs - dbevel) < m_width_eps)
{
if(calc_intersection(v0.x + dx1, v0.y - dy1,
v1.x + dx1, v1.y - dy1,
v1.x + dx2, v1.y - dy2,
v2.x + dx2, v2.y - dy2,
&dx, &dy))
if (calc_intersection(v0.x + dx1,
v0.y - dy1,
v1.x + dx1,
v1.y - dy1,
v1.x + dx2,
v1.y - dy2,
v2.x + dx2,
v2.y - dy2,
&dx,
&dy))
{
add_vertex(vc, dx, dy);
}
@ -499,11 +471,7 @@ namespace agg
case miter_join:
case miter_join_revert:
case miter_join_round:
calc_miter(vc,
v0, v1, v2, dx1, dy1, dx2, dy2,
m_line_join,
m_miter_limit,
dbevel);
calc_miter(vc, v0, v1, v2, dx1, dy1, dx2, dy2, m_line_join, m_miter_limit, dbevel);
break;
case round_join:
@ -518,9 +486,6 @@ namespace agg
}
}
}
} // namespace agg
#endif

5
deps/agg/include/agg_path_length.h vendored
View file

@ -17,8 +17,7 @@
#include "agg_math.h"
namespace agg
{
namespace agg {
template<class VertexSource>
double path_length(VertexSource& vs, unsigned path_id = 0)
{
@ -60,6 +59,6 @@ namespace agg
}
return len;
}
}
} // namespace agg
#endif

436
deps/agg/include/agg_path_storage.h vendored
View file

@ -22,9 +22,7 @@
#include "agg_array.h"
#include "agg_bezier_arc.h"
namespace agg
{
namespace agg {
//----------------------------------------------------vertex_block_storage
template<class T, unsigned BlockShift = 8, unsigned BlockPool = 256>
@ -32,8 +30,7 @@ namespace agg
{
public:
// Allocation parameters
enum block_scale_e
{
enum block_scale_e {
block_shift = BlockShift,
block_size = 1 << block_shift,
block_mask = block_size - 1,
@ -80,7 +77,6 @@ namespace agg
int8u** m_cmd_blocks;
};
//------------------------------------------------------------------------
template<class T, unsigned S, unsigned P>
void vertex_block_storage<T, S, P>::free_all()
@ -90,10 +86,7 @@ namespace agg
T** coord_blk = m_coord_blocks + m_total_blocks - 1;
while (m_total_blocks--)
{
pod_allocator<T>::deallocate(
*coord_blk,
block_size * 2 +
block_size / (sizeof(T) / sizeof(unsigned char)));
pod_allocator<T>::deallocate(*coord_blk, block_size * 2 + block_size / (sizeof(T) / sizeof(unsigned char)));
--coord_blk;
}
pod_allocator<T*>::deallocate(m_coord_blocks, m_max_blocks * 2);
@ -114,31 +107,29 @@ namespace agg
//------------------------------------------------------------------------
template<class T, unsigned S, unsigned P>
vertex_block_storage<T,S,P>::vertex_block_storage() :
m_total_vertices(0),
m_total_blocks(0),
m_max_blocks(0),
m_coord_blocks(0),
m_cmd_blocks(0)
{
}
vertex_block_storage<T, S, P>::vertex_block_storage()
: m_total_vertices(0)
, m_total_blocks(0)
, m_max_blocks(0)
, m_coord_blocks(0)
, m_cmd_blocks(0)
{}
//------------------------------------------------------------------------
template<class T, unsigned S, unsigned P>
vertex_block_storage<T,S,P>::vertex_block_storage(const vertex_block_storage<T,S,P>& v) :
m_total_vertices(0),
m_total_blocks(0),
m_max_blocks(0),
m_coord_blocks(0),
m_cmd_blocks(0)
vertex_block_storage<T, S, P>::vertex_block_storage(const vertex_block_storage<T, S, P>& v)
: m_total_vertices(0)
, m_total_blocks(0)
, m_max_blocks(0)
, m_coord_blocks(0)
, m_cmd_blocks(0)
{
*this = v;
}
//------------------------------------------------------------------------
template<class T, unsigned S, unsigned P>
const vertex_block_storage<T,S,P>&
vertex_block_storage<T,S,P>::operator = (const vertex_block_storage<T,S,P>& v)
const vertex_block_storage<T, S, P>& vertex_block_storage<T, S, P>::operator=(const vertex_block_storage<T, S, P>& v)
{
remove_all();
unsigned i;
@ -160,8 +151,7 @@ namespace agg
//------------------------------------------------------------------------
template<class T, unsigned S, unsigned P>
inline void vertex_block_storage<T,S,P>::add_vertex(double x, double y,
unsigned cmd)
inline void vertex_block_storage<T, S, P>::add_vertex(double x, double y, unsigned cmd)
{
T* coord_ptr = 0;
*storage_ptrs(&coord_ptr) = (int8u)cmd;
@ -172,8 +162,7 @@ namespace agg
//------------------------------------------------------------------------
template<class T, unsigned S, unsigned P>
inline void vertex_block_storage<T,S,P>::modify_vertex(unsigned idx,
double x, double y)
inline void vertex_block_storage<T, S, P>::modify_vertex(unsigned idx, double x, double y)
{
T* pv = m_coord_blocks[idx >> block_shift] + ((idx & block_mask) << 1);
pv[0] = T(x);
@ -182,9 +171,7 @@ namespace agg
//------------------------------------------------------------------------
template<class T, unsigned S, unsigned P>
inline void vertex_block_storage<T,S,P>::modify_vertex(unsigned idx,
double x, double y,
unsigned cmd)
inline void vertex_block_storage<T, S, P>::modify_vertex(unsigned idx, double x, double y, unsigned cmd)
{
unsigned block = idx >> block_shift;
unsigned offset = idx & block_mask;
@ -196,8 +183,7 @@ namespace agg
//------------------------------------------------------------------------
template<class T, unsigned S, unsigned P>
inline void vertex_block_storage<T,S,P>::modify_command(unsigned idx,
unsigned cmd)
inline void vertex_block_storage<T, S, P>::modify_command(unsigned idx, unsigned cmd)
{
m_cmd_blocks[idx >> block_shift][idx & block_mask] = (int8u)cmd;
}
@ -213,8 +199,12 @@ namespace agg
T* pv1 = m_coord_blocks[b1] + (o1 << 1);
T* pv2 = m_coord_blocks[b2] + (o2 << 1);
T val;
val = pv1[0]; pv1[0] = pv2[0]; pv2[0] = val;
val = pv1[1]; pv1[1] = pv2[1]; pv2[1] = val;
val = pv1[0];
pv1[0] = pv2[0];
pv2[0] = val;
val = pv1[1];
pv1[1] = pv2[1];
pv2[1] = val;
int8u cmd = m_cmd_blocks[b1][o1];
m_cmd_blocks[b1][o1] = m_cmd_blocks[b2][o2];
m_cmd_blocks[b2][o2] = cmd;
@ -224,7 +214,8 @@ namespace agg
template<class T, unsigned S, unsigned P>
inline unsigned vertex_block_storage<T, S, P>::last_command() const
{
if(m_total_vertices) return command(m_total_vertices - 1);
if (m_total_vertices)
return command(m_total_vertices - 1);
return path_cmd_stop;
}
@ -232,7 +223,8 @@ namespace agg
template<class T, unsigned S, unsigned P>
inline unsigned vertex_block_storage<T, S, P>::last_vertex(double* x, double* y) const
{
if(m_total_vertices) return vertex(m_total_vertices - 1, x, y);
if (m_total_vertices)
return vertex(m_total_vertices - 1, x, y);
return path_cmd_stop;
}
@ -240,7 +232,8 @@ namespace agg
template<class T, unsigned S, unsigned P>
inline unsigned vertex_block_storage<T, S, P>::prev_vertex(double* x, double* y) const
{
if(m_total_vertices > 1) return vertex(m_total_vertices - 2, x, y);
if (m_total_vertices > 1)
return vertex(m_total_vertices - 2, x, y);
return path_cmd_stop;
}
@ -277,8 +270,7 @@ namespace agg
//------------------------------------------------------------------------
template<class T, unsigned S, unsigned P>
inline unsigned vertex_block_storage<T,S,P>::vertex(unsigned idx,
double* x, double* y) const
inline unsigned vertex_block_storage<T, S, P>::vertex(unsigned idx, double* x, double* y) const
{
unsigned nb = idx >> block_shift;
const T* pv = m_coord_blocks[nb] + ((idx & block_mask) << 1);
@ -300,21 +292,15 @@ namespace agg
{
if (nb >= m_max_blocks)
{
T** new_coords =
pod_allocator<T*>::allocate((m_max_blocks + block_pool) * 2);
T** new_coords = pod_allocator<T*>::allocate((m_max_blocks + block_pool) * 2);
unsigned char** new_cmds =
(unsigned char**)(new_coords + m_max_blocks + block_pool);
unsigned char** new_cmds = (unsigned char**)(new_coords + m_max_blocks + block_pool);
if (m_coord_blocks)
{
memcpy(new_coords,
m_coord_blocks,
m_max_blocks * sizeof(T*));
memcpy(new_coords, m_coord_blocks, m_max_blocks * sizeof(T*));
memcpy(new_cmds,
m_cmd_blocks,
m_max_blocks * sizeof(unsigned char*));
memcpy(new_cmds, m_cmd_blocks, m_max_blocks * sizeof(unsigned char*));
pod_allocator<T*>::deallocate(m_coord_blocks, m_max_blocks * 2);
}
@ -322,12 +308,9 @@ namespace agg
m_cmd_blocks = new_cmds;
m_max_blocks += block_pool;
}
m_coord_blocks[nb] =
pod_allocator<T>::allocate(block_size * 2 +
block_size / (sizeof(T) / sizeof(unsigned char)));
m_coord_blocks[nb] = pod_allocator<T>::allocate(block_size * 2 + block_size / (sizeof(T) / sizeof(unsigned char)));
m_cmd_blocks[nb] =
(unsigned char*)(m_coord_blocks[nb] + block_size * 2);
m_cmd_blocks[nb] = (unsigned char*)(m_coord_blocks[nb] + block_size * 2);
m_total_blocks++;
}
@ -345,29 +328,27 @@ namespace agg
return m_cmd_blocks[nb] + (m_total_vertices & block_mask);
}
//-----------------------------------------------------poly_plain_adaptor
template<class T> class poly_plain_adaptor
template<class T>
class poly_plain_adaptor
{
public:
typedef T value_type;
poly_plain_adaptor() :
m_data(0),
m_ptr(0),
m_end(0),
m_closed(false),
m_stop(false)
poly_plain_adaptor()
: m_data(0)
, m_ptr(0)
, m_end(0)
, m_closed(false)
, m_stop(false)
{}
poly_plain_adaptor(const T* data, unsigned num_points, bool closed) :
m_data(data),
m_ptr(data),
m_end(data + num_points * 2),
m_closed(closed),
m_stop(false)
poly_plain_adaptor(const T* data, unsigned num_points, bool closed)
: m_data(data)
, m_ptr(data)
, m_end(data + num_points * 2)
, m_closed(closed)
, m_stop(false)
{}
void init(const T* data, unsigned num_points, bool closed)
@ -398,8 +379,7 @@ namespace agg
if (m_closed && !m_stop)
{
m_stop = true;
return path_cmd_end_poly
| static_cast<agg::path_commands_e>(path_flags_close);
return path_cmd_end_poly | static_cast<agg::path_commands_e>(path_flags_close);
}
return path_cmd_stop;
}
@ -412,28 +392,25 @@ namespace agg
bool m_stop;
};
//-------------------------------------------------poly_container_adaptor
template<class Container> class poly_container_adaptor
template<class Container>
class poly_container_adaptor
{
public:
typedef typename Container::value_type vertex_type;
poly_container_adaptor() :
m_container(0),
m_index(0),
m_closed(false),
m_stop(false)
poly_container_adaptor()
: m_container(0)
, m_index(0)
, m_closed(false)
, m_stop(false)
{}
poly_container_adaptor(const Container& data, bool closed) :
m_container(&data),
m_index(0),
m_closed(closed),
m_stop(false)
poly_container_adaptor(const Container& data, bool closed)
: m_container(&data)
, m_index(0)
, m_closed(closed)
, m_stop(false)
{}
void init(const Container& data, bool closed)
@ -464,8 +441,7 @@ namespace agg
if (m_closed && !m_stop)
{
m_stop = true;
return path_cmd_end_poly
| static_cast<agg::path_commands_e>(path_flags_close);
return path_cmd_end_poly | static_cast<agg::path_commands_e>(path_flags_close);
}
return path_cmd_stop;
}
@ -477,26 +453,25 @@ namespace agg
bool m_stop;
};
//-----------------------------------------poly_container_reverse_adaptor
template<class Container> class poly_container_reverse_adaptor
template<class Container>
class poly_container_reverse_adaptor
{
public:
typedef typename Container::value_type vertex_type;
poly_container_reverse_adaptor() :
m_container(0),
m_index(-1),
m_closed(false),
m_stop(false)
poly_container_reverse_adaptor()
: m_container(0)
, m_index(-1)
, m_closed(false)
, m_stop(false)
{}
poly_container_reverse_adaptor(const Container& data, bool closed) :
m_container(&data),
m_index(-1),
m_closed(closed),
m_stop(false)
poly_container_reverse_adaptor(const Container& data, bool closed)
: m_container(&data)
, m_index(-1)
, m_closed(closed)
, m_stop(false)
{}
void init(const Container& data, bool closed)
@ -527,8 +502,7 @@ namespace agg
if (m_closed && !m_stop)
{
m_stop = true;
return path_cmd_end_poly
| static_cast<agg::path_commands_e>(path_flags_close);
return path_cmd_end_poly | static_cast<agg::path_commands_e>(path_flags_close);
}
return path_cmd_stop;
}
@ -540,19 +514,17 @@ namespace agg
bool m_stop;
};
//--------------------------------------------------------line_adaptor
class line_adaptor
{
public:
typedef double value_type;
line_adaptor() : m_line(m_coord, 2, false) {}
line_adaptor(double x1, double y1, double x2, double y2) :
m_line(m_coord, 2, false)
line_adaptor()
: m_line(m_coord, 2, false)
{}
line_adaptor(double x1, double y1, double x2, double y2)
: m_line(m_coord, 2, false)
{
m_coord[0] = x1;
m_coord[1] = y1;
@ -569,33 +541,15 @@ namespace agg
m_line.rewind(0);
}
void rewind(unsigned)
{
m_line.rewind(0);
}
void rewind(unsigned) { m_line.rewind(0); }
unsigned vertex(double* x, double* y)
{
return m_line.vertex(x, y);
}
unsigned vertex(double* x, double* y) { return m_line.vertex(x, y); }
private:
double m_coord[4];
poly_plain_adaptor<double> m_line;
};
//---------------------------------------------------------------path_base
// A container to store vertices with their flags.
// A path consists of a number of contours separated with "move_to"
@ -608,16 +562,28 @@ namespace agg
//
// See also: vertex_source concept
//------------------------------------------------------------------------
template<class VertexContainer> class path_base
template<class VertexContainer>
class path_base
{
public:
typedef VertexContainer container_type;
typedef path_base<VertexContainer> self_type;
//--------------------------------------------------------------------
path_base() : m_vertices(), m_iterator(0) {}
void remove_all() { m_vertices.remove_all(); m_iterator = 0; }
void free_all() { m_vertices.free_all(); m_iterator = 0; }
path_base()
: m_vertices()
, m_iterator(0)
{}
void remove_all()
{
m_vertices.remove_all();
m_iterator = 0;
}
void free_all()
{
m_vertices.free_all();
m_iterator = 0;
}
// Make path functions
//--------------------------------------------------------------------
@ -635,42 +601,25 @@ namespace agg
void vline_to(double y);
void vline_rel(double dy);
void arc_to(double rx, double ry,
double angle,
bool large_arc_flag,
bool sweep_flag,
double x, double y);
void arc_to(double rx, double ry, double angle, bool large_arc_flag, bool sweep_flag, double x, double y);
void arc_rel(double rx, double ry,
double angle,
bool large_arc_flag,
bool sweep_flag,
double dx, double dy);
void arc_rel(double rx, double ry, double angle, bool large_arc_flag, bool sweep_flag, double dx, double dy);
void curve3(double x_ctrl, double y_ctrl,
double x_to, double y_to);
void curve3(double x_ctrl, double y_ctrl, double x_to, double y_to);
void curve3_rel(double dx_ctrl, double dy_ctrl,
double dx_to, double dy_to);
void curve3_rel(double dx_ctrl, double dy_ctrl, double dx_to, double dy_to);
void curve3(double x_to, double y_to);
void curve3_rel(double dx_to, double dy_to);
void curve4(double x_ctrl1, double y_ctrl1,
double x_ctrl2, double y_ctrl2,
double x_to, double y_to);
void curve4(double x_ctrl1, double y_ctrl1, double x_ctrl2, double y_ctrl2, double x_to, double y_to);
void curve4_rel(double dx_ctrl1, double dy_ctrl1,
double dx_ctrl2, double dy_ctrl2,
double dx_to, double dy_to);
void curve4_rel(double dx_ctrl1, double dy_ctrl1, double dx_ctrl2, double dy_ctrl2, double dx_to, double dy_to);
void curve4(double x_ctrl2, double y_ctrl2,
double x_to, double y_to);
void curve4_rel(double x_ctrl2, double y_ctrl2,
double x_to, double y_to);
void curve4(double x_ctrl2, double y_ctrl2, double x_to, double y_to);
void curve4_rel(double x_ctrl2, double y_ctrl2, double x_to, double y_to);
void end_poly(unsigned flags = path_flags_close);
void close_polygon(unsigned flags = path_flags_none);
@ -753,7 +702,8 @@ namespace agg
{
if (calc_distance(x, y, x0, y0) > vertex_dist_epsilon)
{
if(is_move_to(cmd)) cmd = path_cmd_line_to;
if (is_move_to(cmd))
cmd = path_cmd_line_to;
m_vertices.add_vertex(x, y, cmd);
}
}
@ -765,25 +715,23 @@ namespace agg
}
else
{
if(is_move_to(cmd)) cmd = path_cmd_line_to;
if (is_move_to(cmd))
cmd = path_cmd_line_to;
}
m_vertices.add_vertex(x, y, cmd);
}
}
while (!is_stop(cmd = vs.vertex(&x, &y)))
{
m_vertices.add_vertex(x, y, is_move_to(cmd) ?
unsigned(path_cmd_line_to) :
cmd);
m_vertices.add_vertex(x, y, is_move_to(cmd) ? unsigned(path_cmd_line_to) : cmd);
}
}
}
// Concatenate polygon/polyline.
//--------------------------------------------------------------------
template<class T> void concat_poly(const T* data,
unsigned num_points,
bool closed)
template<class T>
void concat_poly(const T* data, unsigned num_points, bool closed)
{
poly_plain_adaptor<T> poly(data, num_points, closed);
concat_path(poly);
@ -791,9 +739,8 @@ namespace agg
// Join polygon/polyline continuously.
//--------------------------------------------------------------------
template<class T> void join_poly(const T* data,
unsigned num_points,
bool closed)
template<class T>
void join_poly(const T* data, unsigned num_points, bool closed)
{
poly_plain_adaptor<T> poly(data, num_points, closed);
join_path(poly);
@ -812,7 +759,8 @@ namespace agg
{
double x, y;
unsigned cmd = m_vertices.vertex(path_id, &x, &y);
if(is_stop(cmd)) break;
if (is_stop(cmd))
break;
if (is_vertex(cmd))
{
trans.transform(&x, &y);
@ -838,8 +786,6 @@ namespace agg
}
}
private:
unsigned perceive_polygon_orientation(unsigned start, unsigned end);
void invert_polygon(unsigned start, unsigned end);
@ -859,7 +805,6 @@ namespace agg
return m_vertices.total_vertices();
}
//------------------------------------------------------------------------
template<class VC>
inline void path_base<VC>::rel_to_abs(double* x, double* y) const
@ -873,8 +818,7 @@ namespace agg
*x += x2;
*y += y2;
}
else if (!is_stop(m_vertices.last_command()) &&
is_vertex(m_vertices.prev_vertex(&x2, &y2)))
else if (!is_stop(m_vertices.last_command()) && is_vertex(m_vertices.prev_vertex(&x2, &y2)))
{
*x += x2;
*y += y2;
@ -946,11 +890,7 @@ namespace agg
//------------------------------------------------------------------------
template<class VC>
void path_base<VC>::arc_to(double rx, double ry,
double angle,
bool large_arc_flag,
bool sweep_flag,
double x, double y)
void path_base<VC>::arc_to(double rx, double ry, double angle, bool large_arc_flag, bool sweep_flag, double x, double y)
{
if (m_vertices.total_vertices() && is_vertex(m_vertices.last_command()))
{
@ -994,11 +934,13 @@ namespace agg
//------------------------------------------------------------------------
template<class VC>
void path_base<VC>::arc_rel(double rx, double ry,
void path_base<VC>::arc_rel(double rx,
double ry,
double angle,
bool large_arc_flag,
bool sweep_flag,
double dx, double dy)
double dx,
double dy)
{
rel_to_abs(&dx, &dy);
arc_to(rx, ry, angle, large_arc_flag, sweep_flag, dx, dy);
@ -1006,8 +948,7 @@ namespace agg
//------------------------------------------------------------------------
template<class VC>
void path_base<VC>::curve3(double x_ctrl, double y_ctrl,
double x_to, double y_to)
void path_base<VC>::curve3(double x_ctrl, double y_ctrl, double x_to, double y_to)
{
m_vertices.add_vertex(x_ctrl, y_ctrl, path_cmd_curve3);
m_vertices.add_vertex(x_to, y_to, path_cmd_curve3);
@ -1015,8 +956,7 @@ namespace agg
//------------------------------------------------------------------------
template<class VC>
void path_base<VC>::curve3_rel(double dx_ctrl, double dy_ctrl,
double dx_to, double dy_to)
void path_base<VC>::curve3_rel(double dx_ctrl, double dy_ctrl, double dx_to, double dy_to)
{
rel_to_abs(&dx_ctrl, &dy_ctrl);
rel_to_abs(&dx_to, &dy_to);
@ -1059,9 +999,7 @@ namespace agg
//------------------------------------------------------------------------
template<class VC>
void path_base<VC>::curve4(double x_ctrl1, double y_ctrl1,
double x_ctrl2, double y_ctrl2,
double x_to, double y_to)
void path_base<VC>::curve4(double x_ctrl1, double y_ctrl1, double x_ctrl2, double y_ctrl2, double x_to, double y_to)
{
m_vertices.add_vertex(x_ctrl1, y_ctrl1, path_cmd_curve4);
m_vertices.add_vertex(x_ctrl2, y_ctrl2, path_cmd_curve4);
@ -1070,9 +1008,12 @@ namespace agg
//------------------------------------------------------------------------
template<class VC>
void path_base<VC>::curve4_rel(double dx_ctrl1, double dy_ctrl1,
double dx_ctrl2, double dy_ctrl2,
double dx_to, double dy_to)
void path_base<VC>::curve4_rel(double dx_ctrl1,
double dy_ctrl1,
double dx_ctrl2,
double dy_ctrl2,
double dx_to,
double dy_to)
{
rel_to_abs(&dx_ctrl1, &dy_ctrl1);
rel_to_abs(&dx_ctrl2, &dy_ctrl2);
@ -1084,8 +1025,7 @@ namespace agg
//------------------------------------------------------------------------
template<class VC>
void path_base<VC>::curve4(double x_ctrl2, double y_ctrl2,
double x_to, double y_to)
void path_base<VC>::curve4(double x_ctrl2, double y_ctrl2, double x_to, double y_to)
{
double x0;
double y0;
@ -1110,8 +1050,7 @@ namespace agg
//------------------------------------------------------------------------
template<class VC>
void path_base<VC>::curve4_rel(double dx_ctrl2, double dy_ctrl2,
double dx_to, double dy_to)
void path_base<VC>::curve4_rel(double dx_ctrl2, double dy_ctrl2, double dx_to, double dy_to)
{
rel_to_abs(&dx_ctrl2, &dy_ctrl2);
rel_to_abs(&dx_to, &dy_to);
@ -1216,14 +1155,14 @@ namespace agg
template<class VC>
inline unsigned path_base<VC>::vertex(double* x, double* y)
{
if(m_iterator >= m_vertices.total_vertices()) return path_cmd_stop;
if (m_iterator >= m_vertices.total_vertices())
return path_cmd_stop;
return m_vertices.vertex(m_iterator++, x, y);
}
//------------------------------------------------------------------------
template<class VC>
unsigned path_base<VC>::perceive_polygon_orientation(unsigned start,
unsigned end)
unsigned path_base<VC>::perceive_polygon_orientation(unsigned start, unsigned end)
{
// Calculate signed area (double area to be exact)
//---------------------
@ -1270,42 +1209,42 @@ namespace agg
void path_base<VC>::invert_polygon(unsigned start)
{
// Skip all non-vertices at the beginning
while(start < m_vertices.total_vertices() &&
!is_vertex(m_vertices.command(start))) ++start;
while (start < m_vertices.total_vertices() && !is_vertex(m_vertices.command(start)))
++start;
// Skip all insignificant move_to
while(start+1 < m_vertices.total_vertices() &&
is_move_to(m_vertices.command(start)) &&
is_move_to(m_vertices.command(start+1))) ++start;
while (start + 1 < m_vertices.total_vertices() && is_move_to(m_vertices.command(start)) &&
is_move_to(m_vertices.command(start + 1)))
++start;
// Find the last vertex
unsigned end = start + 1;
while(end < m_vertices.total_vertices() &&
!is_next_poly(m_vertices.command(end))) ++end;
while (end < m_vertices.total_vertices() && !is_next_poly(m_vertices.command(end)))
++end;
invert_polygon(start, end);
}
//------------------------------------------------------------------------
template<class VC>
unsigned path_base<VC>::arrange_polygon_orientation(unsigned start,
path_flags_e orientation)
unsigned path_base<VC>::arrange_polygon_orientation(unsigned start, path_flags_e orientation)
{
if(orientation == path_flags_none) return start;
if (orientation == path_flags_none)
return start;
// Skip all non-vertices at the beginning
while(start < m_vertices.total_vertices() &&
!is_vertex(m_vertices.command(start))) ++start;
while (start < m_vertices.total_vertices() && !is_vertex(m_vertices.command(start)))
++start;
// Skip all insignificant move_to
while(start+1 < m_vertices.total_vertices() &&
is_move_to(m_vertices.command(start)) &&
is_move_to(m_vertices.command(start+1))) ++start;
while (start + 1 < m_vertices.total_vertices() && is_move_to(m_vertices.command(start)) &&
is_move_to(m_vertices.command(start + 1)))
++start;
// Find the last vertex
unsigned end = start + 1;
while(end < m_vertices.total_vertices() &&
!is_next_poly(m_vertices.command(end))) ++end;
while (end < m_vertices.total_vertices() && !is_next_poly(m_vertices.command(end)))
++end;
if (end - start > 2)
{
@ -1314,8 +1253,7 @@ namespace agg
// Invert polygon, set orientation flag, and skip all end_poly
invert_polygon(start, end);
unsigned cmd;
while(end < m_vertices.total_vertices() &&
is_end_poly(cmd = m_vertices.command(end)))
while (end < m_vertices.total_vertices() && is_end_poly(cmd = m_vertices.command(end)))
{
m_vertices.modify_command(end++, set_orientation(cmd, orientation));
}
@ -1326,8 +1264,7 @@ namespace agg
//------------------------------------------------------------------------
template<class VC>
unsigned path_base<VC>::arrange_orientations(unsigned start,
path_flags_e orientation)
unsigned path_base<VC>::arrange_orientations(unsigned start, path_flags_e orientation)
{
if (orientation != path_flags_none)
{
@ -1399,7 +1336,8 @@ namespace agg
{
double x, y;
unsigned cmd = m_vertices.vertex(path_id, &x, &y);
if(is_stop(cmd)) break;
if (is_stop(cmd))
break;
if (is_vertex(cmd))
{
x += dx;
@ -1429,10 +1367,9 @@ namespace agg
////////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------vertex_stl_storage
template<class Container> class vertex_stl_storage
template<class Container>
class vertex_stl_storage
{
public:
typedef typename Container::value_type vertex_type;
@ -1443,9 +1380,7 @@ namespace agg
void add_vertex(double x, double y, unsigned cmd)
{
m_vertices.push_back(vertex_type(value_type(x),
value_type(y),
int8u(cmd)));
m_vertices.push_back(vertex_type(value_type(x), value_type(y), int8u(cmd)));
}
void modify_vertex(unsigned idx, double x, double y)
@ -1463,10 +1398,7 @@ namespace agg
v.cmd = int8u(cmd);
}
void modify_command(unsigned idx, unsigned cmd)
{
m_vertices[idx].cmd = int8u(cmd);
}
void modify_command(unsigned idx, unsigned cmd) { m_vertices[idx].cmd = int8u(cmd); }
void swap_vertices(unsigned v1, unsigned v2)
{
@ -1475,12 +1407,7 @@ namespace agg
m_vertices[v2] = t;
}
unsigned last_command() const
{
return m_vertices.size() ?
m_vertices[m_vertices.size() - 1].cmd :
path_cmd_stop;
}
unsigned last_command() const { return m_vertices.size() ? m_vertices[m_vertices.size() - 1].cmd : path_cmd_stop; }
unsigned last_vertex(double* x, double* y) const
{
@ -1502,20 +1429,11 @@ namespace agg
return vertex(m_vertices.size() - 2, x, y);
}
double last_x() const
{
return m_vertices.size() ? m_vertices[m_vertices.size() - 1].x : 0.0;
}
double last_x() const { return m_vertices.size() ? m_vertices[m_vertices.size() - 1].x : 0.0; }
double last_y() const
{
return m_vertices.size() ? m_vertices[m_vertices.size() - 1].y : 0.0;
}
double last_y() const { return m_vertices.size() ? m_vertices[m_vertices.size() - 1].y : 0.0; }
unsigned total_vertices() const
{
return m_vertices.size();
}
unsigned total_vertices() const { return m_vertices.size(); }
unsigned vertex(unsigned idx, double* x, double* y) const
{
@ -1525,10 +1443,7 @@ namespace agg
return v.cmd;
}
unsigned command(unsigned idx) const
{
return m_vertices[idx].cmd;
}
unsigned command(unsigned idx) const { return m_vertices[idx].cmd; }
private:
Container m_vertices;
@ -1541,9 +1456,7 @@ namespace agg
//-----------------------------------------------------------------------
// typedef path_base<vertex_stl_storage<pod_bvector<vertex_d> > > path_storage;
}
} // namespace agg
// Example of declarations path_storage with std::vector as a container
//---------------------------------------------------------------------------
@ -1554,5 +1467,4 @@ namespace agg
// typedef path_base<vertex_stl_storage<std::vector<vertex_d> > > path_storage;
//}
#endif

132
deps/agg/include/agg_path_storage_integer.h vendored
View file

@ -19,86 +19,74 @@
#include <cstring>
#include "agg_array.h"
namespace agg
{
namespace agg {
//---------------------------------------------------------vertex_integer
template<class T, unsigned CoordShift=6> struct vertex_integer
template<class T, unsigned CoordShift = 6>
struct vertex_integer
{
enum path_cmd
{
cmd_move_to = 0,
cmd_line_to = 1,
cmd_curve3 = 2,
cmd_curve4 = 3
};
enum path_cmd { cmd_move_to = 0, cmd_line_to = 1, cmd_curve3 = 2, cmd_curve4 = 3 };
enum coord_scale_e
{
coord_shift = CoordShift,
coord_scale = 1 << coord_shift
};
enum coord_scale_e { coord_shift = CoordShift, coord_scale = 1 << coord_shift };
T x, y;
vertex_integer() {}
vertex_integer(T x_, T y_, unsigned flag) :
x(((x_ << 1) & ~1) | (flag & 1)),
y(((y_ << 1) & ~1) | (flag >> 1)) {}
vertex_integer(T x_, T y_, unsigned flag)
: x(((x_ << 1) & ~1) | (flag & 1))
, y(((y_ << 1) & ~1) | (flag >> 1))
{}
unsigned vertex(double* x_, double* y_,
double dx=0, double dy=0,
double scale=1.0) const
unsigned vertex(double* x_, double* y_, double dx = 0, double dy = 0, double scale = 1.0) const
{
*x_ = dx + (double(x >> 1) / coord_scale) * scale;
*y_ = dy + (double(y >> 1) / coord_scale) * scale;
switch (((y & 1) << 1) | (x & 1))
{
case cmd_move_to: return path_cmd_move_to;
case cmd_line_to: return path_cmd_line_to;
case cmd_curve3: return path_cmd_curve3;
case cmd_curve4: return path_cmd_curve4;
case cmd_move_to:
return path_cmd_move_to;
case cmd_line_to:
return path_cmd_line_to;
case cmd_curve3:
return path_cmd_curve3;
case cmd_curve4:
return path_cmd_curve4;
}
return path_cmd_stop;
}
};
//---------------------------------------------------path_storage_integer
template<class T, unsigned CoordShift=6> class path_storage_integer
template<class T, unsigned CoordShift = 6>
class path_storage_integer
{
public:
typedef T value_type;
typedef vertex_integer<T, CoordShift> vertex_integer_type;
//--------------------------------------------------------------------
path_storage_integer() : m_storage(), m_vertex_idx(0), m_closed(true) {}
path_storage_integer()
: m_storage()
, m_vertex_idx(0)
, m_closed(true)
{}
//--------------------------------------------------------------------
void remove_all() { m_storage.remove_all(); }
//--------------------------------------------------------------------
void move_to(T x, T y)
{
m_storage.add(vertex_integer_type(x, y, vertex_integer_type::cmd_move_to));
}
void move_to(T x, T y) { m_storage.add(vertex_integer_type(x, y, vertex_integer_type::cmd_move_to)); }
//--------------------------------------------------------------------
void line_to(T x, T y)
{
m_storage.add(vertex_integer_type(x, y, vertex_integer_type::cmd_line_to));
}
void line_to(T x, T y) { m_storage.add(vertex_integer_type(x, y, vertex_integer_type::cmd_line_to)); }
//--------------------------------------------------------------------
void curve3(T x_ctrl, T y_ctrl,
T x_to, T y_to)
void curve3(T x_ctrl, T y_ctrl, T x_to, T y_to)
{
m_storage.add(vertex_integer_type(x_ctrl, y_ctrl, vertex_integer_type::cmd_curve3));
m_storage.add(vertex_integer_type(x_to, y_to, vertex_integer_type::cmd_curve3));
}
//--------------------------------------------------------------------
void curve4(T x_ctrl1, T y_ctrl1,
T x_ctrl2, T y_ctrl2,
T x_to, T y_to)
void curve4(T x_ctrl1, T y_ctrl1, T x_ctrl2, T y_ctrl2, T x_to, T y_to)
{
m_storage.add(vertex_integer_type(x_ctrl1, y_ctrl1, vertex_integer_type::cmd_curve4));
m_storage.add(vertex_integer_type(x_ctrl2, y_ctrl2, vertex_integer_type::cmd_curve4));
@ -110,10 +98,7 @@ namespace agg
//--------------------------------------------------------------------
unsigned size() const { return m_storage.size(); }
unsigned vertex(unsigned idx, double* x, double* y) const
{
return m_storage[idx].vertex(x, y);
}
unsigned vertex(unsigned idx, double* x, double* y) const { return m_storage[idx].vertex(x, y); }
//--------------------------------------------------------------------
unsigned byte_size() const { return m_storage.size() * sizeof(vertex_integer_type); }
@ -178,10 +163,14 @@ namespace agg
{
double x, y;
m_storage[i].vertex(&x, &y);
if(x < bounds.x1) bounds.x1 = x;
if(y < bounds.y1) bounds.y1 = y;
if(x > bounds.x2) bounds.x2 = x;
if(y > bounds.y2) bounds.y2 = y;
if (x < bounds.x1)
bounds.x1 = x;
if (y < bounds.y1)
bounds.y1 = y;
if (x > bounds.x2)
bounds.x2 = x;
if (y > bounds.y2)
bounds.y2 = y;
}
}
return bounds;
@ -193,40 +182,36 @@ namespace agg
bool m_closed;
};
//-----------------------------------------serialized_integer_path_adaptor
template<class T, unsigned CoordShift=6> class serialized_integer_path_adaptor
template<class T, unsigned CoordShift = 6>
class serialized_integer_path_adaptor
{
public:
typedef vertex_integer<T, CoordShift> vertex_integer_type;
//--------------------------------------------------------------------
serialized_integer_path_adaptor() :
m_data(0),
m_end(0),
m_ptr(0),
m_dx(0.0),
m_dy(0.0),
m_scale(1.0),
m_vertices(0)
serialized_integer_path_adaptor()
: m_data(0)
, m_end(0)
, m_ptr(0)
, m_dx(0.0)
, m_dy(0.0)
, m_scale(1.0)
, m_vertices(0)
{}
//--------------------------------------------------------------------
serialized_integer_path_adaptor(const int8u* data, unsigned size,
double dx, double dy) :
m_data(data),
m_end(data + size),
m_ptr(data),
m_dx(dx),
m_dy(dy),
m_vertices(0)
serialized_integer_path_adaptor(const int8u* data, unsigned size, double dx, double dy)
: m_data(data)
, m_end(data + size)
, m_ptr(data)
, m_dx(dx)
, m_dy(dy)
, m_vertices(0)
{}
//--------------------------------------------------------------------
void init(const int8u* data, unsigned size,
double dx, double dy, double scale=1.0)
void init(const int8u* data, unsigned size, double dx, double dy, double scale = 1.0)
{
m_data = data;
m_end = data + size;
@ -237,7 +222,6 @@ namespace agg
m_vertices = 0;
}
//--------------------------------------------------------------------
void rewind(unsigned)
{
@ -288,8 +272,6 @@ namespace agg
unsigned m_vertices;
};
}
} // namespace agg
#endif

38
deps/agg/include/agg_pattern_filters_rgba.h vendored
View file

@ -19,52 +19,39 @@
#include "agg_line_aa_basics.h"
#include "agg_color_rgba.h"
namespace agg
{
namespace agg {
//=======================================================pattern_filter_nn
template<class ColorT> struct pattern_filter_nn
template<class ColorT>
struct pattern_filter_nn
{
typedef ColorT color_type;
static unsigned dilation() { return 0; }
static void AGG_INLINE pixel_low_res(color_type const* const* buf,
color_type* p, int x, int y)
{
*p = buf[y][x];
}
static void AGG_INLINE pixel_low_res(color_type const* const* buf, color_type* p, int x, int y) { *p = buf[y][x]; }
static void AGG_INLINE pixel_high_res(color_type const* const* buf,
color_type* p, int x, int y)
static void AGG_INLINE pixel_high_res(color_type const* const* buf, color_type* p, int x, int y)
{
*p = buf[y >> line_subpixel_shift]
[x >> line_subpixel_shift];
*p = buf[y >> line_subpixel_shift][x >> line_subpixel_shift];
}
};
typedef pattern_filter_nn<rgba8> pattern_filter_nn_rgba8;
typedef pattern_filter_nn<rgba16> pattern_filter_nn_rgba16;
//===========================================pattern_filter_bilinear_rgba
template<class ColorT> struct pattern_filter_bilinear_rgba
template<class ColorT>
struct pattern_filter_bilinear_rgba
{
typedef ColorT color_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
static unsigned dilation() { return 1; }
static AGG_INLINE void pixel_low_res(color_type const* const* buf,
color_type* p, int x, int y)
{
*p = buf[y][x];
}
static AGG_INLINE void pixel_low_res(color_type const* const* buf, color_type* p, int x, int y) { *p = buf[y][x]; }
static AGG_INLINE void pixel_high_res(color_type const* const* buf,
color_type* p, int x, int y)
static AGG_INLINE void pixel_high_res(color_type const* const* buf, color_type* p, int x, int y)
{
calc_type r, g, b, a;
r = g = b = a = line_subpixel_scale * line_subpixel_scale / 2;
@ -77,8 +64,7 @@ namespace agg
y &= line_subpixel_mask;
const color_type* ptr = buf[y_lr] + x_lr;
weight = (line_subpixel_scale - x) *
(line_subpixel_scale - y);
weight = (line_subpixel_scale - x) * (line_subpixel_scale - y);
r += weight * ptr->r;
g += weight * ptr->g;
b += weight * ptr->b;
@ -117,6 +103,6 @@ namespace agg
typedef pattern_filter_bilinear_rgba<rgba8> pattern_filter_bilinear_rgba8;
typedef pattern_filter_bilinear_rgba<rgba16> pattern_filter_bilinear_rgba16;
}
} // namespace agg
#endif

71
deps/agg/include/agg_pixfmt_amask_adaptor.h vendored
View file

@ -16,16 +16,14 @@
#ifndef AGG_PIXFMT_AMASK_ADAPTOR_INCLUDED
#define AGG_PIXFMT_AMASK_ADAPTOR_INCLUDED
#include <cstring>
#include "agg_array.h"
#include "agg_rendering_buffer.h"
namespace agg
{
namespace agg {
//==================================================pixfmt_amask_adaptor
template<class PixFmt, class AlphaMask> class pixfmt_amask_adaptor
template<class PixFmt, class AlphaMask>
class pixfmt_amask_adaptor
{
public:
typedef PixFmt pixfmt_type;
@ -57,10 +55,11 @@ namespace agg
memcpy(&m_span[0], covers, len * sizeof(cover_type));
}
public:
pixfmt_amask_adaptor(pixfmt_type& pixf, const amask_type& mask) :
m_pixf(&pixf), m_mask(&mask), m_span()
pixfmt_amask_adaptor(pixfmt_type& pixf, const amask_type& mask)
: m_pixf(&pixf)
, m_mask(&mask)
, m_span()
{}
void attach_pixfmt(pixfmt_type& pixf) { m_pixf = &pixf; }
@ -78,16 +77,10 @@ namespace agg
unsigned height() const { return m_pixf->height(); }
//--------------------------------------------------------------------
color_type pixel(int x, int y)
{
return m_pixf->pixel(x, y);
}
color_type pixel(int x, int y) { return m_pixf->pixel(x, y); }
//--------------------------------------------------------------------
void copy_pixel(int x, int y, const color_type& c)
{
m_pixf->blend_pixel(x, y, c, m_mask->pixel(x, y));
}
void copy_pixel(int x, int y, const color_type& c) { m_pixf->blend_pixel(x, y, c, m_mask->pixel(x, y)); }
//--------------------------------------------------------------------
void blend_pixel(int x, int y, const color_type& c, cover_type cover)
@ -96,9 +89,7 @@ namespace agg
}
//--------------------------------------------------------------------
void copy_hline(int x, int y,
unsigned len,
const color_type& c)
void copy_hline(int x, int y, unsigned len, const color_type& c)
{
realloc_span(len);
m_mask->fill_hspan(x, y, &m_span[0], len);
@ -106,10 +97,7 @@ namespace agg
}
//--------------------------------------------------------------------
void blend_hline(int x, int y,
unsigned len,
const color_type& c,
cover_type cover)
void blend_hline(int x, int y, unsigned len, const color_type& c, cover_type cover)
{
init_span(len);
m_mask->combine_hspan(x, y, &m_span[0], len);
@ -117,9 +105,7 @@ namespace agg
}
//--------------------------------------------------------------------
void copy_vline(int x, int y,
unsigned len,
const color_type& c)
void copy_vline(int x, int y, unsigned len, const color_type& c)
{
realloc_span(len);
m_mask->fill_vspan(x, y, &m_span[0], len);
@ -127,10 +113,7 @@ namespace agg
}
//--------------------------------------------------------------------
void blend_vline(int x, int y,
unsigned len,
const color_type& c,
cover_type cover)
void blend_vline(int x, int y, unsigned len, const color_type& c, cover_type cover)
{
init_span(len);
m_mask->combine_vspan(x, y, &m_span[0], len);
@ -138,39 +121,27 @@ namespace agg
}
//--------------------------------------------------------------------
void copy_from(const rendering_buffer& from,
int xdst, int ydst,
int xsrc, int ysrc,
unsigned len)
void copy_from(const rendering_buffer& from, int xdst, int ydst, int xsrc, int ysrc, unsigned len)
{
m_pixf->copy_from(from, xdst, ydst, xsrc, ysrc, len);
}
//--------------------------------------------------------------------
void blend_solid_hspan(int x, int y,
unsigned len,
const color_type& c,
const cover_type* covers)
void blend_solid_hspan(int x, int y, unsigned len, const color_type& c, const cover_type* covers)
{
init_span(len, covers);
m_mask->combine_hspan(x, y, &m_span[0], len);
m_pixf->blend_solid_hspan(x, y, len, c, &m_span[0]);
}
//--------------------------------------------------------------------
void blend_solid_vspan(int x, int y,
unsigned len,
const color_type& c,
const cover_type* covers)
void blend_solid_vspan(int x, int y, unsigned len, const color_type& c, const cover_type* covers)
{
init_span(len, covers);
m_mask->combine_vspan(x, y, &m_span[0], len);
m_pixf->blend_solid_vspan(x, y, len, c, &m_span[0]);
}
//--------------------------------------------------------------------
void copy_color_hspan(int x, int y, unsigned len, const color_type* colors)
{
@ -188,7 +159,8 @@ namespace agg
}
//--------------------------------------------------------------------
void blend_color_hspan(int x, int y,
void blend_color_hspan(int x,
int y,
unsigned len,
const color_type* colors,
const cover_type* covers,
@ -207,9 +179,9 @@ namespace agg
m_pixf->blend_color_hspan(x, y, len, colors, &m_span[0], cover);
}
//--------------------------------------------------------------------
void blend_color_vspan(int x, int y,
void blend_color_vspan(int x,
int y,
unsigned len,
const color_type* colors,
const cover_type* covers,
@ -234,7 +206,6 @@ namespace agg
pod_array<cover_type> m_span;
};
}
} // namespace agg
#endif

27
deps/agg/include/agg_pixfmt_base.h vendored
View file

@ -20,19 +20,15 @@
#include "agg_color_gray.h"
#include "agg_color_rgba.h"
namespace agg
{
namespace agg {
struct pixfmt_gray_tag
{
};
{};
struct pixfmt_rgb_tag
{
};
{};
struct pixfmt_rgba_tag
{
};
{};
//--------------------------------------------------------------blender_base
template<class ColorT, class Order = void>
@ -46,8 +42,7 @@ namespace agg
{
if (cover > cover_none)
{
rgba c(
color_type::to_double(r),
rgba c(color_type::to_double(r),
color_type::to_double(g),
color_type::to_double(b),
color_type::to_double(a));
@ -63,17 +58,13 @@ namespace agg
return c;
}
else return rgba::no_color();
else
return rgba::no_color();
}
static rgba get(const value_type* p, cover_type cover = cover_full)
{
return get(
p[order_type::R],
p[order_type::G],
p[order_type::B],
p[order_type::A],
cover);
return get(p[order_type::R], p[order_type::G], p[order_type::B], p[order_type::A], cover);
}
static void set(value_type* p, value_type r, value_type g, value_type b, value_type a)
@ -92,6 +83,6 @@ namespace agg
p[order_type::A] = color_type::from_double(c.a);
}
};
}
} // namespace agg
#endif

284
deps/agg/include/agg_pixfmt_gray.h vendored
View file

@ -28,11 +28,11 @@
#include "agg_pixfmt_base.h"
#include "agg_rendering_buffer.h"
namespace agg
{
namespace agg {
//============================================================blender_gray
template<class ColorT> struct blender_gray
template<class ColorT>
struct blender_gray
{
typedef ColorT color_type;
typedef typename color_type::value_type value_type;
@ -43,22 +43,20 @@ namespace agg
// compositing function. Since the render buffer is opaque we skip the
// initial premultiply and final demultiply.
static AGG_INLINE void blend_pix(value_type* p,
value_type cv, value_type alpha, cover_type cover)
static AGG_INLINE void blend_pix(value_type* p, value_type cv, value_type alpha, cover_type cover)
{
blend_pix(p, cv, color_type::mult_cover(alpha, cover));
}
static AGG_INLINE void blend_pix(value_type* p,
value_type cv, value_type alpha)
static AGG_INLINE void blend_pix(value_type* p, value_type cv, value_type alpha)
{
*p = color_type::lerp(*p, cv, alpha);
}
};
//======================================================blender_gray_pre
template<class ColorT> struct blender_gray_pre
template<class ColorT>
struct blender_gray_pre
{
typedef ColorT color_type;
typedef typename color_type::value_type value_type;
@ -68,59 +66,51 @@ namespace agg
// Blend pixels using the premultiplied form of Alvy-Ray Smith's
// compositing function.
static AGG_INLINE void blend_pix(value_type* p,
value_type cv, value_type alpha, cover_type cover)
static AGG_INLINE void blend_pix(value_type* p, value_type cv, value_type alpha, cover_type cover)
{
blend_pix(p, color_type::mult_cover(cv, cover), color_type::mult_cover(alpha, cover));
}
static AGG_INLINE void blend_pix(value_type* p,
value_type cv, value_type alpha)
static AGG_INLINE void blend_pix(value_type* p, value_type cv, value_type alpha)
{
*p = color_type::prelerp(*p, cv, alpha);
}
};
//=====================================================apply_gamma_dir_gray
template<class ColorT, class GammaLut> class apply_gamma_dir_gray
template<class ColorT, class GammaLut>
class apply_gamma_dir_gray
{
public:
typedef typename ColorT::value_type value_type;
apply_gamma_dir_gray(const GammaLut& gamma) : m_gamma(gamma) {}
apply_gamma_dir_gray(const GammaLut& gamma)
: m_gamma(gamma)
{}
AGG_INLINE void operator () (value_type* p)
{
*p = m_gamma.dir(*p);
}
AGG_INLINE void operator()(value_type* p) { *p = m_gamma.dir(*p); }
private:
const GammaLut& m_gamma;
};
//=====================================================apply_gamma_inv_gray
template<class ColorT, class GammaLut> class apply_gamma_inv_gray
template<class ColorT, class GammaLut>
class apply_gamma_inv_gray
{
public:
typedef typename ColorT::value_type value_type;
apply_gamma_inv_gray(const GammaLut& gamma) : m_gamma(gamma) {}
apply_gamma_inv_gray(const GammaLut& gamma)
: m_gamma(gamma)
{}
AGG_INLINE void operator () (value_type* p)
{
*p = m_gamma.inv(*p);
}
AGG_INLINE void operator()(value_type* p) { *p = m_gamma.inv(*p); }
private:
const GammaLut& m_gamma;
};
//=================================================pixfmt_alpha_blend_gray
template<class Blender, class RenBuf, unsigned Step = 1, unsigned Offset = 0>
class pixfmt_alpha_blend_gray
@ -134,8 +124,7 @@ namespace agg
typedef int order_type; // A fake one
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum
{
enum {
num_components = 1,
pix_width = sizeof(value_type) * Step,
pix_step = Step,
@ -145,61 +134,32 @@ namespace agg
{
value_type c[num_components];
void set(value_type v)
{
c[0] = v;
}
void set(value_type v) { c[0] = v; }
void set(const color_type& color)
{
set(color.v);
}
void set(const color_type& color) { set(color.v); }
void get(value_type& v) const
{
v = c[0];
}
void get(value_type& v) const { v = c[0]; }
color_type get() const
{
return color_type(c[0]);
}
color_type get() const { return color_type(c[0]); }
pixel_type* next()
{
return (pixel_type*)(c + pix_step);
}
pixel_type* next() { return (pixel_type*)(c + pix_step); }
const pixel_type* next() const
{
return (const pixel_type*)(c + pix_step);
}
const pixel_type* next() const { return (const pixel_type*)(c + pix_step); }
pixel_type* advance(int n)
{
return (pixel_type*)(c + n * pix_step);
}
pixel_type* advance(int n) { return (pixel_type*)(c + n * pix_step); }
const pixel_type* advance(int n) const
{
return (const pixel_type*)(c + n * pix_step);
}
const pixel_type* advance(int n) const { return (const pixel_type*)(c + n * pix_step); }
};
private:
//--------------------------------------------------------------------
AGG_INLINE void blend_pix(pixel_type* p,
value_type v, value_type a,
unsigned cover)
AGG_INLINE void blend_pix(pixel_type* p, value_type v, value_type a, unsigned cover)
{
blender_type::blend_pix(p->c, v, a, cover);
}
//--------------------------------------------------------------------
AGG_INLINE void blend_pix(pixel_type* p, value_type v, value_type a)
{
blender_type::blend_pix(p->c, v, a);
}
AGG_INLINE void blend_pix(pixel_type* p, value_type v, value_type a) { blender_type::blend_pix(p->c, v, a); }
//--------------------------------------------------------------------
AGG_INLINE void blend_pix(pixel_type* p, const color_type& c, unsigned cover)
@ -208,10 +168,7 @@ namespace agg
}
//--------------------------------------------------------------------
AGG_INLINE void blend_pix(pixel_type* p, const color_type& c)
{
blender_type::blend_pix(p->c, c.v, c.a);
}
AGG_INLINE void blend_pix(pixel_type* p, const color_type& c) { blender_type::blend_pix(p->c, c.v, c.a); }
//--------------------------------------------------------------------
AGG_INLINE void copy_or_blend_pix(pixel_type* p, const color_type& c, unsigned cover)
@ -247,8 +204,8 @@ namespace agg
public:
//--------------------------------------------------------------------
explicit pixfmt_alpha_blend_gray(rbuf_type& rb) :
m_rbuf(&rb)
explicit pixfmt_alpha_blend_gray(rbuf_type& rb)
: m_rbuf(&rb)
{}
void attach(rbuf_type& rb) { m_rbuf = &rb; }
//--------------------------------------------------------------------
@ -260,10 +217,7 @@ namespace agg
if (r.clip(rect_i(0, 0, pixf.width() - 1, pixf.height() - 1)))
{
int stride = pixf.stride();
m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1),
(r.x2 - r.x1) + 1,
(r.y2 - r.y1) + 1,
stride);
m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), (r.x2 - r.x1) + 1, (r.y2 - r.y1) + 1, stride);
return true;
}
return false;
@ -304,10 +258,7 @@ namespace agg
}
// Get pixel pointer from raw buffer pointer.
AGG_INLINE static pixel_type* pix_value_ptr(void* p)
{
return (pixel_type*)((value_type*)p + pix_offset);
}
AGG_INLINE static pixel_type* pix_value_ptr(void* p) { return (pixel_type*)((value_type*)p + pix_offset); }
// Get pixel pointer from raw buffer pointer.
AGG_INLINE static const pixel_type* pix_value_ptr(const void* p)
@ -324,16 +275,10 @@ namespace agg
}
//--------------------------------------------------------------------
AGG_INLINE static color_type read_plain_color(const void* p)
{
return pix_value_ptr(p)->get();
}
AGG_INLINE static color_type read_plain_color(const void* p) { return pix_value_ptr(p)->get(); }
//--------------------------------------------------------------------
AGG_INLINE static void make_pix(int8u* p, const color_type& c)
{
((pixel_type*)p)->set(c);
}
AGG_INLINE static void make_pix(int8u* p, const color_type& c) { ((pixel_type*)p)->set(c); }
//--------------------------------------------------------------------
AGG_INLINE color_type pixel(int x, int y) const
@ -346,10 +291,7 @@ namespace agg
}
//--------------------------------------------------------------------
AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
{
pix_value_ptr(x, y, 1)->set(c);
}
AGG_INLINE void copy_pixel(int x, int y, const color_type& c) { pix_value_ptr(x, y, 1)->set(c); }
//--------------------------------------------------------------------
AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover)
@ -358,38 +300,27 @@ namespace agg
}
//--------------------------------------------------------------------
AGG_INLINE void copy_hline(int x, int y,
unsigned len,
const color_type& c)
AGG_INLINE void copy_hline(int x, int y, unsigned len, const color_type& c)
{
pixel_type* p = pix_value_ptr(x, y, len);
do
{
p->set(c);
p = p->next();
} while (--len);
}
while(--len);
}
//--------------------------------------------------------------------
AGG_INLINE void copy_vline(int x, int y,
unsigned len,
const color_type& c)
AGG_INLINE void copy_vline(int x, int y, unsigned len, const color_type& c)
{
do
{
pix_value_ptr(x, y++, 1)->set(c);
} while (--len);
}
while (--len);
}
//--------------------------------------------------------------------
void blend_hline(int x, int y,
unsigned len,
const color_type& c,
int8u cover)
void blend_hline(int x, int y, unsigned len, const color_type& c, int8u cover)
{
if (!c.is_transparent())
{
@ -401,8 +332,7 @@ namespace agg
{
p->set(c);
p = p->next();
}
while (--len);
} while (--len);
}
else
{
@ -410,18 +340,13 @@ namespace agg
{
blend_pix(p, c, cover);
p = p->next();
}
while (--len);
} while (--len);
}
}
}
//--------------------------------------------------------------------
void blend_vline(int x, int y,
unsigned len,
const color_type& c,
int8u cover)
void blend_vline(int x, int y, unsigned len, const color_type& c, int8u cover)
{
if (!c.is_transparent())
{
@ -430,26 +355,20 @@ namespace agg
do
{
pix_value_ptr(x, y++, 1)->set(c);
}
while (--len);
} while (--len);
}
else
{
do
{
blend_pix(pix_value_ptr(x, y++, 1), c, cover);
}
while (--len);
} while (--len);
}
}
}
//--------------------------------------------------------------------
void blend_solid_hspan(int x, int y,
unsigned len,
const color_type& c,
const int8u* covers)
void blend_solid_hspan(int x, int y, unsigned len, const color_type& c, const int8u* covers)
{
if (!c.is_transparent())
{
@ -467,17 +386,12 @@ namespace agg
}
p = p->next();
++covers;
}
while (--len);
} while (--len);
}
}
//--------------------------------------------------------------------
void blend_solid_vspan(int x, int y,
unsigned len,
const color_type& c,
const int8u* covers)
void blend_solid_vspan(int x, int y, unsigned len, const color_type& c, const int8u* covers)
{
if (!c.is_transparent())
{
@ -494,16 +408,12 @@ namespace agg
blend_pix(p, c, *covers);
}
++covers;
}
while (--len);
} while (--len);
}
}
//--------------------------------------------------------------------
void copy_color_hspan(int x, int y,
unsigned len,
const color_type* colors)
void copy_color_hspan(int x, int y, unsigned len, const color_type* colors)
{
pixel_type* p = pix_value_ptr(x, y, len);
@ -511,30 +421,20 @@ namespace agg
{
p->set(*colors++);
p = p->next();
} while (--len);
}
while (--len);
}
//--------------------------------------------------------------------
void copy_color_vspan(int x, int y,
unsigned len,
const color_type* colors)
void copy_color_vspan(int x, int y, unsigned len, const color_type* colors)
{
do
{
pix_value_ptr(x, y++, 1)->set(*colors++);
} while (--len);
}
while (--len);
}
//--------------------------------------------------------------------
void blend_color_hspan(int x, int y,
unsigned len,
const color_type* colors,
const int8u* covers,
int8u cover)
void blend_color_hspan(int x, int y, unsigned len, const color_type* colors, const int8u* covers, int8u cover)
{
pixel_type* p = pix_value_ptr(x, y, len);
@ -544,8 +444,7 @@ namespace agg
{
copy_or_blend_pix(p, *colors++, *covers++);
p = p->next();
}
while (--len);
} while (--len);
}
else
{
@ -555,8 +454,7 @@ namespace agg
{
copy_or_blend_pix(p, *colors++);
p = p->next();
}
while (--len);
} while (--len);
}
else
{
@ -564,27 +462,20 @@ namespace agg
{
copy_or_blend_pix(p, *colors++, cover);
p = p->next();
}
while (--len);
} while (--len);
}
}
}
//--------------------------------------------------------------------
void blend_color_vspan(int x, int y,
unsigned len,
const color_type* colors,
const int8u* covers,
int8u cover)
void blend_color_vspan(int x, int y, unsigned len, const color_type* colors, const int8u* covers, int8u cover)
{
if (covers)
{
do
{
copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++, *covers++);
}
while (--len);
} while (--len);
}
else
{
@ -593,22 +484,21 @@ namespace agg
do
{
copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++);
}
while (--len);
} while (--len);
}
else
{
do
{
copy_or_blend_pix(pix_value_ptr(x, y++, 1), *colors++, cover);
}
while (--len);
} while (--len);
}
}
}
//--------------------------------------------------------------------
template<class Function> void for_each_pixel(Function f)
template<class Function>
void for_each_pixel(Function f)
{
unsigned y;
for (y = 0; y < height(); ++y)
@ -622,36 +512,32 @@ namespace agg
{
f(p->c);
p = p->next();
}
while (--len);
} while (--len);
}
}
}
//--------------------------------------------------------------------
template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
template<class GammaLut>
void apply_gamma_dir(const GammaLut& g)
{
for_each_pixel(apply_gamma_dir_gray<color_type, GammaLut>(g));
}
//--------------------------------------------------------------------
template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
template<class GammaLut>
void apply_gamma_inv(const GammaLut& g)
{
for_each_pixel(apply_gamma_inv_gray<color_type, GammaLut>(g));
}
//--------------------------------------------------------------------
template<class RenBuf2>
void copy_from(const RenBuf2& from,
int xdst, int ydst,
int xsrc, int ysrc,
unsigned len)
void copy_from(const RenBuf2& from, int xdst, int ydst, int xsrc, int ysrc, unsigned len)
{
if (const int8u* p = from.row_ptr(ysrc))
{
memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width,
p + xsrc * pix_width,
len * pix_width);
memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, p + xsrc * pix_width, len * pix_width);
}
}
@ -660,8 +546,10 @@ namespace agg
template<class SrcPixelFormatRenderer>
void blend_from_color(const SrcPixelFormatRenderer& from,
const color_type& color,
int xdst, int ydst,
int xsrc, int ysrc,
int xdst,
int ydst,
int xsrc,
int ysrc,
unsigned len,
int8u cover)
{
@ -677,8 +565,7 @@ namespace agg
copy_or_blend_pix(pdst, color, src_color_type::scale_cover(cover, psrc->c[0]));
psrc = psrc->next();
pdst = pdst->next();
}
while (--len);
} while (--len);
}
}
@ -688,8 +575,10 @@ namespace agg
template<class SrcPixelFormatRenderer>
void blend_from_lut(const SrcPixelFormatRenderer& from,
const color_type* color_lut,
int xdst, int ydst,
int xsrc, int ysrc,
int xdst,
int ydst,
int xsrc,
int ysrc,
unsigned len,
int8u cover)
{
@ -704,8 +593,7 @@ namespace agg
copy_or_blend_pix(pdst, color_lut[psrc->c[0]], cover);
psrc = psrc->next();
pdst = pdst->next();
}
while (--len);
} while (--len);
}
}
@ -732,6 +620,6 @@ namespace agg
typedef pixfmt_alpha_blend_gray<blender_sgray8_pre, rendering_buffer> pixfmt_sgray8_pre;
typedef pixfmt_alpha_blend_gray<blender_gray16_pre, rendering_buffer> pixfmt_gray16_pre;
typedef pixfmt_alpha_blend_gray<blender_gray32_pre, rendering_buffer> pixfmt_gray32_pre;
}
} // namespace agg
#endif

364
deps/agg/include/agg_pixfmt_rgb.h vendored
View file

@ -29,16 +29,18 @@
#include "agg_color_rgba.h"
#include "agg_rendering_buffer.h"
namespace agg
{
namespace agg {
//=====================================================apply_gamma_dir_rgb
template<class ColorT, class Order, class GammaLut> class apply_gamma_dir_rgb
template<class ColorT, class Order, class GammaLut>
class apply_gamma_dir_rgb
{
public:
typedef typename ColorT::value_type value_type;
apply_gamma_dir_rgb(const GammaLut& gamma) : m_gamma(gamma) {}
apply_gamma_dir_rgb(const GammaLut& gamma)
: m_gamma(gamma)
{}
AGG_INLINE void operator()(value_type* p)
{
@ -51,15 +53,16 @@ namespace agg
const GammaLut& m_gamma;
};
//=====================================================apply_gamma_inv_rgb
template<class ColorT, class Order, class GammaLut> class apply_gamma_inv_rgb
template<class ColorT, class Order, class GammaLut>
class apply_gamma_inv_rgb
{
public:
typedef typename ColorT::value_type value_type;
apply_gamma_inv_rgb(const GammaLut& gamma) : m_gamma(gamma) {}
apply_gamma_inv_rgb(const GammaLut& gamma)
: m_gamma(gamma)
{}
AGG_INLINE void operator()(value_type* p)
{
@ -72,9 +75,9 @@ namespace agg
const GammaLut& m_gamma;
};
//=========================================================blender_rgb
template<class ColorT, class Order> struct blender_rgb
template<class ColorT, class Order>
struct blender_rgb
{
typedef ColorT color_type;
typedef Order order_type;
@ -83,10 +86,8 @@ namespace agg
enum base_scale_e { base_shift = color_type::base_shift };
//--------------------------------------------------------------------
static AGG_INLINE void blend_pix(value_type* p,
unsigned cr, unsigned cg, unsigned cb,
unsigned alpha,
unsigned cover=0)
static AGG_INLINE void
blend_pix(value_type* p, unsigned cr, unsigned cg, unsigned cb, unsigned alpha, unsigned cover = 0)
{
p[Order::R] += (value_type)(((cr - p[Order::R]) * alpha) >> base_shift);
p[Order::G] += (value_type)(((cg - p[Order::G]) * alpha) >> base_shift);
@ -94,9 +95,9 @@ namespace agg
}
};
//======================================================blender_rgb_pre
template<class ColorT, class Order> struct blender_rgb_pre
template<class ColorT, class Order>
struct blender_rgb_pre
{
typedef ColorT color_type;
typedef Order order_type;
@ -105,10 +106,8 @@ namespace agg
enum base_scale_e { base_shift = color_type::base_shift };
//--------------------------------------------------------------------
static AGG_INLINE void blend_pix(value_type* p,
unsigned cr, unsigned cg, unsigned cb,
unsigned alpha,
unsigned cover)
static AGG_INLINE void
blend_pix(value_type* p, unsigned cr, unsigned cg, unsigned cb, unsigned alpha, unsigned cover)
{
alpha = color_type::base_mask - alpha;
cover = (cover + 1) << (base_shift - 8);
@ -118,22 +117,18 @@ namespace agg
}
//--------------------------------------------------------------------
static AGG_INLINE void blend_pix(value_type* p,
unsigned cr, unsigned cg, unsigned cb,
unsigned alpha)
static AGG_INLINE void blend_pix(value_type* p, unsigned cr, unsigned cg, unsigned cb, unsigned alpha)
{
alpha = color_type::base_mask - alpha;
p[Order::R] = (value_type)(((p[Order::R] * alpha) >> base_shift) + cr);
p[Order::G] = (value_type)(((p[Order::G] * alpha) >> base_shift) + cg);
p[Order::B] = (value_type)(((p[Order::B] * alpha) >> base_shift) + cb);
}
};
//===================================================blender_rgb_gamma
template<class ColorT, class Order, class Gamma> class blender_rgb_gamma
template<class ColorT, class Order, class Gamma>
class blender_rgb_gamma
{
public:
typedef ColorT color_type;
@ -144,14 +139,13 @@ namespace agg
enum base_scale_e { base_shift = color_type::base_shift };
//--------------------------------------------------------------------
blender_rgb_gamma() : m_gamma(0) {}
blender_rgb_gamma()
: m_gamma(0)
{}
void gamma(const gamma_type& g) { m_gamma = &g; }
//--------------------------------------------------------------------
AGG_INLINE void blend_pix(value_type* p,
unsigned cr, unsigned cg, unsigned cb,
unsigned alpha,
unsigned cover=0)
AGG_INLINE void blend_pix(value_type* p, unsigned cr, unsigned cg, unsigned cb, unsigned alpha, unsigned cover = 0)
{
calc_type r = m_gamma->dir(p[Order::R]);
calc_type g = m_gamma->dir(p[Order::G]);
@ -165,11 +159,9 @@ namespace agg
const gamma_type* m_gamma;
};
//==================================================pixfmt_alpha_blend_rgb
template<class Blender, class RenBuf> class pixfmt_alpha_blend_rgb
template<class Blender, class RenBuf>
class pixfmt_alpha_blend_rgb
{
public:
typedef RenBuf rbuf_type;
@ -179,8 +171,7 @@ namespace agg
typedef typename blender_type::order_type order_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum base_scale_e
{
enum base_scale_e {
base_shift = color_type::base_shift,
base_scale = color_type::base_scale,
base_mask = color_type::base_mask,
@ -189,9 +180,7 @@ namespace agg
private:
//--------------------------------------------------------------------
AGG_INLINE void copy_or_blend_pix(value_type* p,
const color_type& c,
unsigned cover)
AGG_INLINE void copy_or_blend_pix(value_type* p, const color_type& c, unsigned cover)
{
if (c.a)
{
@ -210,8 +199,7 @@ namespace agg
}
//--------------------------------------------------------------------
AGG_INLINE void copy_or_blend_pix(value_type* p,
const color_type& c)
AGG_INLINE void copy_or_blend_pix(value_type* p, const color_type& c)
{
if (c.a)
{
@ -228,11 +216,10 @@ namespace agg
}
}
public:
//--------------------------------------------------------------------
explicit pixfmt_alpha_blend_rgb(rbuf_type& rb) :
m_rbuf(&rb)
explicit pixfmt_alpha_blend_rgb(rbuf_type& rb)
: m_rbuf(&rb)
{}
void attach(rbuf_type& rb) { m_rbuf = &rb; }
@ -244,10 +231,7 @@ namespace agg
if (r.clip(rect_i(0, 0, pixf.width() - 1, pixf.height() - 1)))
{
int stride = pixf.stride();
m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1),
(r.x2 - r.x1) + 1,
(r.y2 - r.y1) + 1,
stride);
m_rbuf->attach(pixf.pix_ptr(r.x1, stride < 0 ? r.y2 : r.y1), (r.x2 - r.x1) + 1, (r.y2 - r.y1) + 1, stride);
return true;
}
return false;
@ -267,15 +251,9 @@ namespace agg
AGG_INLINE row_data row(int y) const { return m_rbuf->row(y); }
//--------------------------------------------------------------------
AGG_INLINE int8u* pix_ptr(int x, int y)
{
return m_rbuf->row_ptr(y) + x * pix_width;
}
AGG_INLINE int8u* pix_ptr(int x, int y) { return m_rbuf->row_ptr(y) + x * pix_width; }
AGG_INLINE const int8u* pix_ptr(int x, int y) const
{
return m_rbuf->row_ptr(y) + x * pix_width;
}
AGG_INLINE const int8u* pix_ptr(int x, int y) const { return m_rbuf->row_ptr(y) + x * pix_width; }
//--------------------------------------------------------------------
AGG_INLINE static void make_pix(int8u* p, const color_type& c)
@ -289,9 +267,7 @@ namespace agg
AGG_INLINE color_type pixel(int x, int y) const
{
value_type* p = (value_type*)m_rbuf->row_ptr(y) + x + x + x;
return color_type(p[order_type::R],
p[order_type::G],
p[order_type::B]);
return color_type(p[order_type::R], p[order_type::G], p[order_type::B]);
}
//--------------------------------------------------------------------
@ -309,11 +285,8 @@ namespace agg
copy_or_blend_pix((value_type*)m_rbuf->row_ptr(x, y, 1) + x + x + x, c, cover);
}
//--------------------------------------------------------------------
AGG_INLINE void copy_hline(int x, int y,
unsigned len,
const color_type& c)
AGG_INLINE void copy_hline(int x, int y, unsigned len, const color_type& c)
{
value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + x + x + x;
do
@ -322,38 +295,27 @@ namespace agg
p[order_type::G] = c.g;
p[order_type::B] = c.b;
p += 3;
} while (--len);
}
while(--len);
}
//--------------------------------------------------------------------
AGG_INLINE void copy_vline(int x, int y,
unsigned len,
const color_type& c)
AGG_INLINE void copy_vline(int x, int y, unsigned len, const color_type& c)
{
do
{
value_type* p = (value_type*)
m_rbuf->row_ptr(x, y++, 1) + x + x + x;
value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
p[order_type::R] = c.r;
p[order_type::G] = c.g;
p[order_type::B] = c.b;
} while (--len);
}
while(--len);
}
//--------------------------------------------------------------------
void blend_hline(int x, int y,
unsigned len,
const color_type& c,
int8u cover)
void blend_hline(int x, int y, unsigned len, const color_type& c, int8u cover)
{
if (c.a)
{
value_type* p = (value_type*)
m_rbuf->row_ptr(x, y, len) + x + x + x;
value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + x + x + x;
calc_type alpha = (calc_type(c.a) * (calc_type(cover) + 1)) >> 8;
if (alpha == base_mask)
@ -364,8 +326,7 @@ namespace agg
p[order_type::G] = c.g;
p[order_type::B] = c.b;
p += 3;
}
while(--len);
} while (--len);
}
else
{
@ -373,18 +334,13 @@ namespace agg
{
m_blender.blend_pix(p, c.r, c.g, c.b, alpha, cover);
p += 3;
}
while(--len);
} while (--len);
}
}
}
//--------------------------------------------------------------------
void blend_vline(int x, int y,
unsigned len,
const color_type& c,
int8u cover)
void blend_vline(int x, int y, unsigned len, const color_type& c, int8u cover)
{
if (c.a)
{
@ -394,40 +350,31 @@ namespace agg
{
do
{
p = (value_type*)
m_rbuf->row_ptr(x, y++, 1) + x + x + x;
p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
p[order_type::R] = c.r;
p[order_type::G] = c.g;
p[order_type::B] = c.b;
}
while(--len);
} while (--len);
}
else
{
do
{
p = (value_type*)
m_rbuf->row_ptr(x, y++, 1) + x + x + x;
p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
m_blender.blend_pix(p, c.r, c.g, c.b, alpha, cover);
}
while(--len);
} while (--len);
}
}
}
//--------------------------------------------------------------------
void blend_solid_hspan(int x, int y,
unsigned len,
const color_type& c,
const int8u* covers)
void blend_solid_hspan(int x, int y, unsigned len, const color_type& c, const int8u* covers)
{
if (c.a)
{
value_type* p = (value_type*)
m_rbuf->row_ptr(x, y, len) + x + x + x;
value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + x + x + x;
do
{
@ -444,24 +391,18 @@ namespace agg
}
p += 3;
++covers;
}
while(--len);
} while (--len);
}
}
//--------------------------------------------------------------------
void blend_solid_vspan(int x, int y,
unsigned len,
const color_type& c,
const int8u* covers)
void blend_solid_vspan(int x, int y, unsigned len, const color_type& c, const int8u* covers)
{
if (c.a)
{
do
{
value_type* p = (value_type*)
m_rbuf->row_ptr(x, y++, 1) + x + x + x;
value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
calc_type alpha = (calc_type(c.a) * (calc_type(*covers) + 1)) >> 8;
if (alpha == base_mask)
@ -475,19 +416,14 @@ namespace agg
m_blender.blend_pix(p, c.r, c.g, c.b, alpha, *covers);
}
++covers;
}
while(--len);
} while (--len);
}
}
//--------------------------------------------------------------------
void copy_color_hspan(int x, int y,
unsigned len,
const color_type* colors)
void copy_color_hspan(int x, int y, unsigned len, const color_type* colors)
{
value_type* p = (value_type*)
m_rbuf->row_ptr(x, y, len) + x + x + x;
value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + x + x + x;
do
{
@ -496,38 +432,26 @@ namespace agg
p[order_type::B] = colors->b;
++colors;
p += 3;
} while (--len);
}
while(--len);
}
//--------------------------------------------------------------------
void copy_color_vspan(int x, int y,
unsigned len,
const color_type* colors)
void copy_color_vspan(int x, int y, unsigned len, const color_type* colors)
{
do
{
value_type* p = (value_type*)
m_rbuf->row_ptr(x, y++, 1) + x + x + x;
value_type* p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
p[order_type::R] = colors->r;
p[order_type::G] = colors->g;
p[order_type::B] = colors->b;
++colors;
} while (--len);
}
while(--len);
}
//--------------------------------------------------------------------
void blend_color_hspan(int x, int y,
unsigned len,
const color_type* colors,
const int8u* covers,
int8u cover)
void blend_color_hspan(int x, int y, unsigned len, const color_type* colors, const int8u* covers, int8u cover)
{
value_type* p = (value_type*)
m_rbuf->row_ptr(x, y, len) + x + x + x;
value_type* p = (value_type*)m_rbuf->row_ptr(x, y, len) + x + x + x;
if (covers)
{
@ -535,8 +459,7 @@ namespace agg
{
copy_or_blend_pix(p, *colors++, *covers++);
p += 3;
}
while(--len);
} while (--len);
}
else
{
@ -546,8 +469,7 @@ namespace agg
{
copy_or_blend_pix(p, *colors++);
p += 3;
}
while(--len);
} while (--len);
}
else
{
@ -555,32 +477,23 @@ namespace agg
{
copy_or_blend_pix(p, *colors++, cover);
p += 3;
}
while(--len);
} while (--len);
}
}
}
//--------------------------------------------------------------------
void blend_color_vspan(int x, int y,
unsigned len,
const color_type* colors,
const int8u* covers,
int8u cover)
void blend_color_vspan(int x, int y, unsigned len, const color_type* colors, const int8u* covers, int8u cover)
{
value_type* p;
if (covers)
{
do
{
p = (value_type*)
m_rbuf->row_ptr(x, y++, 1) + x + x + x;
p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
copy_or_blend_pix(p, *colors++, *covers++);
}
while(--len);
} while (--len);
}
else
{
@ -588,29 +501,26 @@ namespace agg
{
do
{
p = (value_type*)
m_rbuf->row_ptr(x, y++, 1) + x + x + x;
p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
copy_or_blend_pix(p, *colors++);
}
while(--len);
} while (--len);
}
else
{
do
{
p = (value_type*)
m_rbuf->row_ptr(x, y++, 1) + x + x + x;
p = (value_type*)m_rbuf->row_ptr(x, y++, 1) + x + x + x;
copy_or_blend_pix(p, *colors++, cover);
}
while(--len);
} while (--len);
}
}
}
//--------------------------------------------------------------------
template<class Function> void for_each_pixel(Function f)
template<class Function>
void for_each_pixel(Function f)
{
unsigned y;
for (y = 0; y < height(); ++y)
@ -619,54 +529,45 @@ namespace agg
if (r.ptr)
{
unsigned len = r.x2 - r.x1 + 1;
value_type* p = (value_type*)
m_rbuf->row_ptr(r.x1, y, len) + r.x1 * 3;
value_type* p = (value_type*)m_rbuf->row_ptr(r.x1, y, len) + r.x1 * 3;
do
{
f(p);
p += 3;
}
while(--len);
} while (--len);
}
}
}
//--------------------------------------------------------------------
template<class GammaLut> void apply_gamma_dir(const GammaLut& g)
template<class GammaLut>
void apply_gamma_dir(const GammaLut& g)
{
for_each_pixel(apply_gamma_dir_rgb<color_type, order_type, GammaLut>(g));
}
//--------------------------------------------------------------------
template<class GammaLut> void apply_gamma_inv(const GammaLut& g)
template<class GammaLut>
void apply_gamma_inv(const GammaLut& g)
{
for_each_pixel(apply_gamma_inv_rgb<color_type, order_type, GammaLut>(g));
}
//--------------------------------------------------------------------
template<class RenBuf2>
void copy_from(const RenBuf2& from,
int xdst, int ydst,
int xsrc, int ysrc,
unsigned len)
void copy_from(const RenBuf2& from, int xdst, int ydst, int xsrc, int ysrc, unsigned len)
{
const int8u* p = from.row_ptr(ysrc);
if (p)
{
memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width,
p + xsrc * pix_width,
len * pix_width);
memmove(m_rbuf->row_ptr(xdst, ydst, len) + xdst * pix_width, p + xsrc * pix_width, len * pix_width);
}
}
//--------------------------------------------------------------------
template<class SrcPixelFormatRenderer>
void blend_from(const SrcPixelFormatRenderer& from,
int xdst, int ydst,
int xsrc, int ysrc,
unsigned len,
int8u cover)
void
blend_from(const SrcPixelFormatRenderer& from, int xdst, int ydst, int xsrc, int ysrc, unsigned len, int8u cover)
{
typedef typename SrcPixelFormatRenderer::order_type src_order;
@ -674,8 +575,7 @@ namespace agg
if (psrc)
{
psrc += xsrc * 4;
value_type* pdst =
(value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
value_type* pdst = (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
if (cover == 255)
{
@ -701,8 +601,7 @@ namespace agg
}
psrc += 4;
pdst += 3;
}
while(--len);
} while (--len);
}
else
{
@ -716,8 +615,7 @@ namespace agg
copy_or_blend_pix(pdst, color, cover);
psrc += 4;
pdst += 3;
}
while(--len);
} while (--len);
}
}
}
@ -726,8 +624,10 @@ namespace agg
template<class SrcPixelFormatRenderer>
void blend_from_color(const SrcPixelFormatRenderer& from,
const color_type& color,
int xdst, int ydst,
int xsrc, int ysrc,
int xdst,
int ydst,
int xsrc,
int ysrc,
unsigned len,
int8u cover)
{
@ -735,17 +635,13 @@ namespace agg
const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc);
if (psrc)
{
value_type* pdst =
(value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
value_type* pdst = (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
do
{
copy_or_blend_pix(pdst,
color,
(*psrc * cover + base_mask) >> base_shift);
copy_or_blend_pix(pdst, color, (*psrc * cover + base_mask) >> base_shift);
++psrc;
pdst += 3;
}
while(--len);
} while (--len);
}
}
@ -753,8 +649,10 @@ namespace agg
template<class SrcPixelFormatRenderer>
void blend_from_lut(const SrcPixelFormatRenderer& from,
const color_type* color_lut,
int xdst, int ydst,
int xsrc, int ysrc,
int xdst,
int ydst,
int xsrc,
int ysrc,
unsigned len,
int8u cover)
{
@ -762,20 +660,17 @@ namespace agg
const src_value_type* psrc = (src_value_type*)from.row_ptr(ysrc);
if (psrc)
{
value_type* pdst =
(value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
value_type* pdst = (value_type*)m_rbuf->row_ptr(xdst, ydst, len) + xdst * 3;
if (cover == 255)
{
do
{
const color_type& color = color_lut[*psrc];
m_blender.blend_pix(pdst,
color.r, color.g, color.b, color.a);
m_blender.blend_pix(pdst, color.r, color.g, color.b, color.a);
++psrc;
pdst += 3;
}
while(--len);
} while (--len);
}
else
{
@ -784,8 +679,7 @@ namespace agg
copy_or_blend_pix(pdst, color_lut[*psrc], cover);
++psrc;
pdst += 3;
}
while(--len);
} while (--len);
}
}
}
@ -800,61 +694,63 @@ namespace agg
typedef pixfmt_alpha_blend_rgb<blender_rgb<rgba16, order_rgb>, rendering_buffer> pixfmt_rgb48; //----pixfmt_rgb48
typedef pixfmt_alpha_blend_rgb<blender_rgb<rgba16, order_bgr>, rendering_buffer> pixfmt_bgr48; //----pixfmt_bgr48
typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba8, order_rgb>, rendering_buffer> pixfmt_rgb24_pre; //----pixfmt_rgb24_pre
typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba8, order_bgr>, rendering_buffer> pixfmt_bgr24_pre; //----pixfmt_bgr24_pre
typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba16, order_rgb>, rendering_buffer> pixfmt_rgb48_pre; //----pixfmt_rgb48_pre
typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba16, order_bgr>, rendering_buffer> pixfmt_bgr48_pre; //----pixfmt_bgr48_pre
typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba8, order_rgb>, rendering_buffer>
pixfmt_rgb24_pre; //----pixfmt_rgb24_pre
typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba8, order_bgr>, rendering_buffer>
pixfmt_bgr24_pre; //----pixfmt_bgr24_pre
typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba16, order_rgb>, rendering_buffer>
pixfmt_rgb48_pre; //----pixfmt_rgb48_pre
typedef pixfmt_alpha_blend_rgb<blender_rgb_pre<rgba16, order_bgr>, rendering_buffer>
pixfmt_bgr48_pre; //----pixfmt_bgr48_pre
//-----------------------------------------------------pixfmt_rgb24_gamma
template<class Gamma> class pixfmt_rgb24_gamma :
public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer>
template<class Gamma>
class pixfmt_rgb24_gamma : public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer>
{
public:
pixfmt_rgb24_gamma(rendering_buffer& rb, const Gamma& g) :
pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer>(rb)
pixfmt_rgb24_gamma(rendering_buffer& rb, const Gamma& g)
: pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_rgb, Gamma>, rendering_buffer>(rb)
{
this->blender().gamma(g);
}
};
//-----------------------------------------------------pixfmt_bgr24_gamma
template<class Gamma> class pixfmt_bgr24_gamma :
public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer>
template<class Gamma>
class pixfmt_bgr24_gamma : public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer>
{
public:
pixfmt_bgr24_gamma(rendering_buffer& rb, const Gamma& g) :
pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer>(rb)
pixfmt_bgr24_gamma(rendering_buffer& rb, const Gamma& g)
: pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba8, order_bgr, Gamma>, rendering_buffer>(rb)
{
this->blender().gamma(g);
}
};
//-----------------------------------------------------pixfmt_rgb48_gamma
template<class Gamma> class pixfmt_rgb48_gamma :
public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer>
template<class Gamma>
class pixfmt_rgb48_gamma : public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer>
{
public:
pixfmt_rgb48_gamma(rendering_buffer& rb, const Gamma& g) :
pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer>(rb)
pixfmt_rgb48_gamma(rendering_buffer& rb, const Gamma& g)
: pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_rgb, Gamma>, rendering_buffer>(rb)
{
this->blender().gamma(g);
}
};
//-----------------------------------------------------pixfmt_bgr48_gamma
template<class Gamma> class pixfmt_bgr48_gamma :
public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer>
template<class Gamma>
class pixfmt_bgr48_gamma : public pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer>
{
public:
pixfmt_bgr48_gamma(rendering_buffer& rb, const Gamma& g) :
pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer>(rb)
pixfmt_bgr48_gamma(rendering_buffer& rb, const Gamma& g)
: pixfmt_alpha_blend_rgb<blender_rgb_gamma<rgba16, order_bgr, Gamma>, rendering_buffer>(rb)
{
this->blender().gamma(g);
}
};
}
} // namespace agg
#endif

627
deps/agg/include/agg_pixfmt_rgb_packed.h vendored
View file

File diff suppressed because it is too large Load diff

1426
deps/agg/include/agg_pixfmt_rgba.h vendored
View file

File diff suppressed because it is too large Load diff

91
deps/agg/include/agg_pixfmt_transposer.h vendored
View file

@ -18,10 +18,10 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//=======================================================pixfmt_transposer
template<class PixFmt> class pixfmt_transposer
template<class PixFmt>
class pixfmt_transposer
{
public:
typedef PixFmt pixfmt_type;
@ -31,8 +31,12 @@ namespace agg
typedef typename color_type::calc_type calc_type;
//--------------------------------------------------------------------
pixfmt_transposer() : m_pixf(0) {}
explicit pixfmt_transposer(pixfmt_type& pixf) : m_pixf(&pixf) {}
pixfmt_transposer()
: m_pixf(0)
{}
explicit pixfmt_transposer(pixfmt_type& pixf)
: m_pixf(&pixf)
{}
void attach(pixfmt_type& pixf) { m_pixf = &pixf; }
//--------------------------------------------------------------------
@ -40,109 +44,66 @@ namespace agg
AGG_INLINE unsigned height() const { return m_pixf->width(); }
//--------------------------------------------------------------------
AGG_INLINE color_type pixel(int x, int y) const
{
return m_pixf->pixel(y, x);
}
AGG_INLINE color_type pixel(int x, int y) const { return m_pixf->pixel(y, x); }
//--------------------------------------------------------------------
AGG_INLINE void copy_pixel(int x, int y, const color_type& c)
{
m_pixf->copy_pixel(y, x, c);
}
AGG_INLINE void copy_pixel(int x, int y, const color_type& c) { m_pixf->copy_pixel(y, x, c); }
//--------------------------------------------------------------------
AGG_INLINE void blend_pixel(int x, int y,
const color_type& c,
int8u cover)
{
m_pixf->blend_pixel(y, x, c, cover);
}
AGG_INLINE void blend_pixel(int x, int y, const color_type& c, int8u cover) { m_pixf->blend_pixel(y, x, c, cover); }
//--------------------------------------------------------------------
AGG_INLINE void copy_hline(int x, int y,
unsigned len,
const color_type& c)
{
m_pixf->copy_vline(y, x, len, c);
}
AGG_INLINE void copy_hline(int x, int y, unsigned len, const color_type& c) { m_pixf->copy_vline(y, x, len, c); }
//--------------------------------------------------------------------
AGG_INLINE void copy_vline(int x, int y,
unsigned len,
const color_type& c)
{
m_pixf->copy_hline(y, x, len, c);
}
AGG_INLINE void copy_vline(int x, int y, unsigned len, const color_type& c) { m_pixf->copy_hline(y, x, len, c); }
//--------------------------------------------------------------------
AGG_INLINE void blend_hline(int x, int y,
unsigned len,
const color_type& c,
int8u cover)
AGG_INLINE void blend_hline(int x, int y, unsigned len, const color_type& c, int8u cover)
{
m_pixf->blend_vline(y, x, len, c, cover);
}
//--------------------------------------------------------------------
AGG_INLINE void blend_vline(int x, int y,
unsigned len,
const color_type& c,
int8u cover)
AGG_INLINE void blend_vline(int x, int y, unsigned len, const color_type& c, int8u cover)
{
m_pixf->blend_hline(y, x, len, c, cover);
}
//--------------------------------------------------------------------
AGG_INLINE void blend_solid_hspan(int x, int y,
unsigned len,
const color_type& c,
const int8u* covers)
AGG_INLINE void blend_solid_hspan(int x, int y, unsigned len, const color_type& c, const int8u* covers)
{
m_pixf->blend_solid_vspan(y, x, len, c, covers);
}
//--------------------------------------------------------------------
AGG_INLINE void blend_solid_vspan(int x, int y,
unsigned len,
const color_type& c,
const int8u* covers)
AGG_INLINE void blend_solid_vspan(int x, int y, unsigned len, const color_type& c, const int8u* covers)
{
m_pixf->blend_solid_hspan(y, x, len, c, covers);
}
//--------------------------------------------------------------------
AGG_INLINE void copy_color_hspan(int x, int y,
unsigned len,
const color_type* colors)
AGG_INLINE void copy_color_hspan(int x, int y, unsigned len, const color_type* colors)
{
m_pixf->copy_color_vspan(y, x, len, colors);
}
//--------------------------------------------------------------------
AGG_INLINE void copy_color_vspan(int x, int y,
unsigned len,
const color_type* colors)
AGG_INLINE void copy_color_vspan(int x, int y, unsigned len, const color_type* colors)
{
m_pixf->copy_color_hspan(y, x, len, colors);
}
//--------------------------------------------------------------------
AGG_INLINE void blend_color_hspan(int x, int y,
unsigned len,
const color_type* colors,
const int8u* covers,
int8u cover)
AGG_INLINE void
blend_color_hspan(int x, int y, unsigned len, const color_type* colors, const int8u* covers, int8u cover)
{
m_pixf->blend_color_vspan(y, x, len, colors, covers, cover);
}
//--------------------------------------------------------------------
AGG_INLINE void blend_color_vspan(int x, int y,
unsigned len,
const color_type* colors,
const int8u* covers,
int8u cover)
AGG_INLINE void
blend_color_vspan(int x, int y, unsigned len, const color_type* colors, const int8u* covers, int8u cover)
{
m_pixf->blend_color_hspan(y, x, len, colors, covers, cover);
}
@ -150,8 +111,6 @@ namespace agg
private:
pixfmt_type* m_pixf;
};
}
} // namespace agg
#endif

139
deps/agg/include/agg_rasterizer_cells_aa.h vendored
View file

@ -35,17 +35,15 @@
#include "agg_math.h"
#include "agg_array.h"
namespace agg
{
namespace agg {
//-----------------------------------------------------rasterizer_cells_aa
// An internal class that implements the main rasterization algorithm.
// Used in the rasterizer. Should not be used direcly.
template<class Cell> class rasterizer_cells_aa
{
enum cell_block_scale_e
template<class Cell>
class rasterizer_cells_aa
{
enum cell_block_scale_e {
cell_block_shift = 12,
cell_block_size = 1 << cell_block_shift,
cell_block_mask = cell_block_size - 1,
@ -77,15 +75,9 @@ namespace agg
void sort_cells();
unsigned total_cells() const
{
return m_num_cells;
}
unsigned total_cells() const { return m_num_cells; }
unsigned scanline_num_cells(unsigned y) const
{
return m_sorted_y[y - m_min_y].num;
}
unsigned scanline_num_cells(unsigned y) const { return m_sorted_y[y - m_min_y].num; }
const cell_type* const* scanline_cells(unsigned y) const
{
@ -121,9 +113,6 @@ namespace agg
bool m_sorted;
};
//------------------------------------------------------------------------
template<class Cell>
rasterizer_cells_aa<Cell>::~rasterizer_cells_aa()
@ -143,20 +132,20 @@ namespace agg
//------------------------------------------------------------------------
template<class Cell>
rasterizer_cells_aa<Cell>::rasterizer_cells_aa() :
m_num_blocks(0),
m_max_blocks(0),
m_curr_block(0),
m_num_cells(0),
m_cells(0),
m_curr_cell_ptr(0),
m_sorted_cells(),
m_sorted_y(),
m_min_x(0x7FFFFFFF),
m_min_y(0x7FFFFFFF),
m_max_x(-0x7FFFFFFF),
m_max_y(-0x7FFFFFFF),
m_sorted(false)
rasterizer_cells_aa<Cell>::rasterizer_cells_aa()
: m_num_blocks(0)
, m_max_blocks(0)
, m_curr_block(0)
, m_num_cells(0)
, m_cells(0)
, m_curr_cell_ptr(0)
, m_sorted_cells()
, m_sorted_y()
, m_min_x(0x7FFFFFFF)
, m_min_y(0x7FFFFFFF)
, m_max_x(-0x7FFFFFFF)
, m_max_y(-0x7FFFFFFF)
, m_sorted(false)
{
m_style_cell.initial();
m_curr_cell.initial();
@ -185,7 +174,8 @@ namespace agg
{
if ((m_num_cells & cell_block_mask) == 0)
{
if(m_num_blocks >= cell_block_limit) return;
if (m_num_blocks >= cell_block_limit)
return;
allocate_block();
}
*m_curr_cell_ptr++ = m_curr_cell;
@ -210,9 +200,7 @@ namespace agg
//------------------------------------------------------------------------
template<class Cell>
AGG_INLINE void rasterizer_cells_aa<Cell>::render_hline(int ey,
int x1, int y1,
int x2, int y2)
AGG_INLINE void rasterizer_cells_aa<Cell>::render_hline(int ey, int x1, int y1, int x2, int y2)
{
int ex1 = x1 >> poly_subpixel_shift;
int ex2 = x2 >> poly_subpixel_shift;
@ -327,8 +315,10 @@ namespace agg
int cy = (y1 + y2) >> 1;
// Bail if values are so large they are likely to wrap
if ((std::abs(x1) >= std::numeric_limits<int>::max()/2) || (std::abs(y1) >= std::numeric_limits<int>::max()/2) ||
(std::abs(x2) >= std::numeric_limits<int>::max()/2) || (std::abs(y2) >= std::numeric_limits<int>::max()/2))
if ((std::abs(x1) >= std::numeric_limits<int>::max() / 2) ||
(std::abs(y1) >= std::numeric_limits<int>::max() / 2) ||
(std::abs(x2) >= std::numeric_limits<int>::max() / 2) ||
(std::abs(y2) >= std::numeric_limits<int>::max() / 2))
return;
line(x1, y1, cx, cy);
@ -346,14 +336,22 @@ namespace agg
int x_from, x_to;
int p, rem, mod, lift, delta, first, incr;
if(ex1 < m_min_x) m_min_x = ex1;
if(ex1 > m_max_x) m_max_x = ex1;
if(ey1 < m_min_y) m_min_y = ey1;
if(ey1 > m_max_y) m_max_y = ey1;
if(ex2 < m_min_x) m_min_x = ex2;
if(ex2 > m_max_x) m_max_x = ex2;
if(ey2 < m_min_y) m_min_y = ey2;
if(ey2 > m_max_y) m_max_y = ey2;
if (ex1 < m_min_x)
m_min_x = ex1;
if (ex1 > m_max_x)
m_max_x = ex1;
if (ey1 < m_min_y)
m_min_y = ey1;
if (ey1 > m_max_y)
m_max_y = ey1;
if (ex2 < m_min_x)
m_min_x = ex2;
if (ex2 > m_max_x)
m_max_x = ex2;
if (ey2 < m_min_y)
m_min_y = ey2;
if (ey2 > m_max_y)
m_max_y = ey2;
set_curr_cell(ex1, ey1);
@ -478,9 +476,7 @@ namespace agg
{
if (m_num_blocks >= m_max_blocks)
{
cell_type** new_cells =
pod_allocator<cell_type*>::allocate(m_max_blocks +
cell_block_pool);
cell_type** new_cells = pod_allocator<cell_type*>::allocate(m_max_blocks + cell_block_pool);
if (m_cells)
{
@ -491,30 +487,22 @@ namespace agg
m_max_blocks += cell_block_pool;
}
m_cells[m_num_blocks++] =
pod_allocator<cell_type>::allocate(cell_block_size);
m_cells[m_num_blocks++] = pod_allocator<cell_type>::allocate(cell_block_size);
}
m_curr_cell_ptr = m_cells[m_curr_block++];
}
//------------------------------------------------------------------------
template <class T> static AGG_INLINE void swap_cells(T* a, T* b)
template<class T>
static AGG_INLINE void swap_cells(T* a, T* b)
{
T temp = *a;
*a = *b;
*b = temp;
}
//------------------------------------------------------------------------
enum
{
qsort_threshold = 9
};
enum { qsort_threshold = 9 };
//------------------------------------------------------------------------
template<class Cell>
@ -565,8 +553,12 @@ namespace agg
for (;;)
{
int x = (*base)->x;
do i++; while( (*i)->x < x );
do j--; while( x < (*j)->x );
do
i++;
while ((*i)->x < x);
do
j--;
while (x < (*j)->x);
if (i > j)
{
@ -625,12 +617,12 @@ namespace agg
}
}
//------------------------------------------------------------------------
template<class Cell>
void rasterizer_cells_aa<Cell>::sort_cells()
{
if(m_sorted) return; //Perform sort only the first time.
if (m_sorted)
return; // Perform sort only the first time.
add_curr_cell();
m_curr_cell.x = 0x7FFFFFFF;
@ -638,7 +630,8 @@ namespace agg
m_curr_cell.cover = 0;
m_curr_cell.area = 0;
if(m_num_cells == 0) return;
if (m_num_cells == 0)
return;
// DBG: Check to see if min/max works well.
// for(unsigned nc = 0; nc < m_num_cells; nc++)
@ -736,23 +729,26 @@ namespace agg
m_sorted = true;
}
//------------------------------------------------------scanline_hit_test
class scanline_hit_test
{
public:
scanline_hit_test(int x) : m_x(x), m_hit(false) {}
scanline_hit_test(int x)
: m_x(x)
, m_hit(false)
{}
void reset_spans() {}
void finalize(int) {}
void add_cell(int x, int)
{
if(m_x == x) m_hit = true;
if (m_x == x)
m_hit = true;
}
void add_span(int x, int len, int)
{
if(m_x >= x && m_x < x+len) m_hit = true;
if (m_x >= x && m_x < x + len)
m_hit = true;
}
unsigned num_spans() const { return 1; }
bool hit() const { return m_hit; }
@ -762,7 +758,6 @@ namespace agg
bool m_hit;
};
}
} // namespace agg
#endif

183
deps/agg/include/agg_rasterizer_compound_aa.h vendored
View file

@ -32,8 +32,7 @@
#include "agg_rasterizer_cells_aa.h"
#include "agg_rasterizer_sl_clip.h"
namespace agg
{
namespace agg {
//-----------------------------------------------------------cell_style_aa
// A pixel cell. There're no constructors defined and it was done
@ -69,18 +68,16 @@ namespace agg
}
};
//===========================================================layer_order_e
enum layer_order_e
{
enum layer_order_e {
layer_unsorted, //------layer_unsorted
layer_direct, //------layer_direct
layer_inverse //------layer_inverse
};
//==================================================rasterizer_compound_aa
template<class Clip=rasterizer_sl_clip_int> class rasterizer_compound_aa
template<class Clip = rasterizer_sl_clip_int>
class rasterizer_compound_aa
{
struct style_info
{
@ -99,8 +96,7 @@ namespace agg
typedef typename Clip::conv_type conv_type;
typedef typename Clip::coord_type coord_type;
enum aa_scale_e
{
enum aa_scale_e {
aa_shift = 8,
aa_scale = 1 << aa_shift,
aa_mask = aa_scale - 1,
@ -109,24 +105,27 @@ namespace agg
};
//--------------------------------------------------------------------
rasterizer_compound_aa() :
m_outline(),
m_clipper(),
m_filling_rule(fill_non_zero),
m_layer_order(layer_direct),
m_styles(), // Active Styles
m_ast(), // Active Style Table (unique values)
m_asm(), // Active Style Mask
m_cells(),
m_cover_buf(),
m_master_alpha(),
m_min_style(0x7FFFFFFF),
m_max_style(-0x7FFFFFFF),
m_start_x(0),
m_start_y(0),
m_scan_y(0x7FFFFFFF),
m_sl_start(0),
m_sl_len(0)
rasterizer_compound_aa()
: m_outline()
, m_clipper()
, m_filling_rule(fill_non_zero)
, m_layer_order(layer_direct)
, m_styles()
, // Active Styles
m_ast()
, // Active Style Table (unique values)
m_asm()
, // Active Style Mask
m_cells()
, m_cover_buf()
, m_master_alpha()
, m_min_style(0x7FFFFFFF)
, m_max_style(-0x7FFFFFFF)
, m_start_x(0)
, m_start_y(0)
, m_scan_y(0x7FFFFFFF)
, m_sl_start(0)
, m_sl_len(0)
{}
//--------------------------------------------------------------------
@ -157,14 +156,14 @@ namespace agg
unsigned cmd;
vs.rewind(path_id);
if(m_outline.sorted()) reset();
if (m_outline.sorted())
reset();
while (!is_stop(cmd = vs.vertex(&x, &y)))
{
add_vertex(x, y, cmd);
}
}
//--------------------------------------------------------------------
int min_x() const { return m_outline.min_x(); }
int min_y() const { return m_outline.min_y(); }
@ -191,7 +190,8 @@ namespace agg
AGG_INLINE unsigned calculate_alpha(int area, unsigned master_alpha) const
{
int cover = area >> (poly_subpixel_shift * 2 + 1 - aa_shift);
if(cover < 0) cover = -cover;
if (cover < 0)
cover = -cover;
if (m_filling_rule == fill_even_odd)
{
cover &= aa_mask2;
@ -200,17 +200,20 @@ namespace agg
cover = aa_scale2 - cover;
}
}
if(cover > aa_mask) cover = aa_mask;
if (cover > aa_mask)
cover = aa_mask;
return (cover * master_alpha + aa_mask) >> aa_shift;
}
//--------------------------------------------------------------------
// Sweeps one scanline with one style index. The style ID can be
// determined by calling style().
template<class Scanline> bool sweep_scanline(Scanline& sl, int style_idx)
template<class Scanline>
bool sweep_scanline(Scanline& sl, int style_idx)
{
int scan_y = m_scan_y - 1;
if(scan_y > m_outline.max_y()) return false;
if (scan_y > m_outline.max_y())
return false;
sl.reset_spans();
@ -244,16 +247,14 @@ namespace agg
if (area)
{
alpha = calculate_alpha((cover << (poly_subpixel_shift + 1)) - area,
master_alpha);
alpha = calculate_alpha((cover << (poly_subpixel_shift + 1)) - area, master_alpha);
sl.add_cell(x, alpha);
x++;
}
if (num_cells && cell->x > x)
{
alpha = calculate_alpha(cover << (poly_subpixel_shift + 1),
master_alpha);
alpha = calculate_alpha(cover << (poly_subpixel_shift + 1), master_alpha);
if (alpha)
{
sl.add_span(x, cell->x - x, alpha);
@ -261,7 +262,8 @@ namespace agg
}
}
if(sl.num_spans() == 0) return false;
if (sl.num_spans() == 0)
return false;
sl.finalize(scan_y);
return true;
}
@ -273,8 +275,7 @@ namespace agg
//--------------------------------------------------------------------
// Disable copying
rasterizer_compound_aa(const rasterizer_compound_aa<Clip>&);
const rasterizer_compound_aa<Clip>&
operator = (const rasterizer_compound_aa<Clip>&);
const rasterizer_compound_aa<Clip>& operator=(const rasterizer_compound_aa<Clip>&);
private:
rasterizer_cells_aa<cell_style_aa> m_outline;
@ -297,15 +298,6 @@ namespace agg
unsigned m_sl_len;
};
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::reset()
@ -334,12 +326,10 @@ namespace agg
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::clip_box(double x1, double y1,
double x2, double y2)
void rasterizer_compound_aa<Clip>::clip_box(double x1, double y1, double x2, double y2)
{
reset();
m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1),
conv_type::upscale(x2), conv_type::upscale(y2));
m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1), conv_type::upscale(x2), conv_type::upscale(y2));
}
//------------------------------------------------------------------------
@ -359,46 +349,46 @@ namespace agg
cell.left = (int16)left;
cell.right = (int16)right;
m_outline.style(cell);
if(left >= 0 && left < m_min_style) m_min_style = left;
if(left >= 0 && left > m_max_style) m_max_style = left;
if(right >= 0 && right < m_min_style) m_min_style = right;
if(right >= 0 && right > m_max_style) m_max_style = right;
if (left >= 0 && left < m_min_style)
m_min_style = left;
if (left >= 0 && left > m_max_style)
m_max_style = left;
if (right >= 0 && right < m_min_style)
m_min_style = right;
if (right >= 0 && right > m_max_style)
m_max_style = right;
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::move_to(int x, int y)
{
if(m_outline.sorted()) reset();
m_clipper.move_to(m_start_x = conv_type::downscale(x),
m_start_y = conv_type::downscale(y));
if (m_outline.sorted())
reset();
m_clipper.move_to(m_start_x = conv_type::downscale(x), m_start_y = conv_type::downscale(y));
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::line_to(int x, int y)
{
m_clipper.line_to(m_outline,
conv_type::downscale(x),
conv_type::downscale(y));
m_clipper.line_to(m_outline, conv_type::downscale(x), conv_type::downscale(y));
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::move_to_d(double x, double y)
{
if(m_outline.sorted()) reset();
m_clipper.move_to(m_start_x = conv_type::upscale(x),
m_start_y = conv_type::upscale(y));
if (m_outline.sorted())
reset();
m_clipper.move_to(m_start_x = conv_type::upscale(x), m_start_y = conv_type::upscale(y));
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::line_to_d(double x, double y)
{
m_clipper.line_to(m_outline,
conv_type::upscale(x),
conv_type::upscale(y));
m_clipper.line_to(m_outline, conv_type::upscale(x), conv_type::upscale(y));
}
//------------------------------------------------------------------------
@ -409,13 +399,11 @@ namespace agg
{
move_to_d(x, y);
}
else
if(is_vertex(cmd))
else if (is_vertex(cmd))
{
line_to_d(x, y);
}
else
if(is_close(cmd))
else if (is_close(cmd))
{
m_clipper.line_to(m_outline, m_start_x, m_start_y);
}
@ -425,23 +413,20 @@ namespace agg
template<class Clip>
void rasterizer_compound_aa<Clip>::edge(int x1, int y1, int x2, int y2)
{
if(m_outline.sorted()) reset();
if (m_outline.sorted())
reset();
m_clipper.move_to(conv_type::downscale(x1), conv_type::downscale(y1));
m_clipper.line_to(m_outline,
conv_type::downscale(x2),
conv_type::downscale(y2));
m_clipper.line_to(m_outline, conv_type::downscale(x2), conv_type::downscale(y2));
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_compound_aa<Clip>::edge_d(double x1, double y1,
double x2, double y2)
void rasterizer_compound_aa<Clip>::edge_d(double x1, double y1, double x2, double y2)
{
if(m_outline.sorted()) reset();
if (m_outline.sorted())
reset();
m_clipper.move_to(conv_type::upscale(x1), conv_type::upscale(y1));
m_clipper.line_to(m_outline,
conv_type::upscale(x2),
conv_type::upscale(y2));
m_clipper.line_to(m_outline, conv_type::upscale(x2), conv_type::upscale(y2));
}
//------------------------------------------------------------------------
@ -474,8 +459,10 @@ namespace agg
template<class Clip>
AGG_INLINE void rasterizer_compound_aa<Clip>::add_style(int style_id)
{
if(style_id < 0) style_id = 0;
else style_id -= m_min_style - 1;
if (style_id < 0)
style_id = 0;
else
style_id -= m_min_style - 1;
unsigned nbyte = style_id >> 3;
unsigned mask = 1 << (style_id & 7);
@ -499,7 +486,8 @@ namespace agg
{
for (;;)
{
if(m_scan_y > m_outline.max_y()) return 0;
if (m_scan_y > m_outline.max_y())
return 0;
unsigned num_cells = m_outline.scanline_num_cells(m_scan_y);
const cell_style_aa* const* cells = m_outline.scanline_cells(m_scan_y);
unsigned num_styles = m_max_style - m_min_style + 2;
@ -550,8 +538,7 @@ namespace agg
while (num_cells--)
{
curr_cell = *cells++;
style_id = (curr_cell->left < 0) ? 0 :
curr_cell->left - m_min_style + 1;
style_id = (curr_cell->left < 0) ? 0 : curr_cell->left - m_min_style + 1;
style = &m_styles[style_id];
if (curr_cell->x == style->last_x)
@ -570,8 +557,7 @@ namespace agg
style->num_cells++;
}
style_id = (curr_cell->right < 0) ? 0 :
curr_cell->right - m_min_style + 1;
style_id = (curr_cell->right < 0) ? 0 : curr_cell->right - m_min_style + 1;
style = &m_styles[style_id];
if (curr_cell->x == style->last_x)
@ -591,7 +577,8 @@ namespace agg
}
}
}
if(m_ast.size() > 1) break;
if (m_ast.size() > 1)
break;
++m_scan_y;
}
++m_scan_y;
@ -599,8 +586,10 @@ namespace agg
if (m_layer_order != layer_unsorted)
{
range_adaptor<pod_vector<unsigned>> ra(m_ast, 1, m_ast.size() - 1);
if(m_layer_order == layer_direct) quick_sort(ra, unsigned_greater);
else quick_sort(ra, unsigned_less);
if (m_layer_order == layer_direct)
quick_sort(ra, unsigned_greater);
else
quick_sort(ra, unsigned_less);
}
return m_ast.size() - 1;
@ -609,8 +598,7 @@ namespace agg
//------------------------------------------------------------------------
// Returns style ID depending of the existing style index
template<class Clip>
AGG_INLINE
unsigned rasterizer_compound_aa<Clip>::style(unsigned style_idx) const
AGG_INLINE unsigned rasterizer_compound_aa<Clip>::style(unsigned style_idx) const
{
return m_ast[style_idx + 1] + m_min_style - 1;
}
@ -690,9 +678,6 @@ namespace agg
}
}
}
} // namespace agg
#endif

47
deps/agg/include/agg_rasterizer_outline.h vendored
View file

@ -17,21 +17,20 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//======================================================rasterizer_outline
template<class Renderer> class rasterizer_outline
template<class Renderer>
class rasterizer_outline
{
public:
explicit rasterizer_outline(Renderer& ren) :
m_ren(&ren),
m_start_x(0),
m_start_y(0),
m_vertices(0)
explicit rasterizer_outline(Renderer& ren)
: m_ren(&ren)
, m_start_x(0)
, m_start_y(0)
, m_vertices(0)
{}
void attach(Renderer& ren) { m_ren = &ren; }
//--------------------------------------------------------------------
void move_to(int x, int y)
{
@ -47,16 +46,10 @@ namespace agg
}
//--------------------------------------------------------------------
void move_to_d(double x, double y)
{
move_to(m_ren->coord(x), m_ren->coord(y));
}
void move_to_d(double x, double y) { move_to(m_ren->coord(x), m_ren->coord(y)); }
//--------------------------------------------------------------------
void line_to_d(double x, double y)
{
line_to(m_ren->coord(x), m_ren->coord(y));
}
void line_to_d(double x, double y) { line_to(m_ren->coord(x), m_ren->coord(y)); }
//--------------------------------------------------------------------
void close()
@ -79,7 +72,8 @@ namespace agg
{
if (is_end_poly(cmd))
{
if(is_closed(cmd)) close();
if (is_closed(cmd))
close();
}
else
{
@ -88,7 +82,6 @@ namespace agg
}
}
//--------------------------------------------------------------------
template<class VertexSource>
void add_path(VertexSource& vs, unsigned path_id = 0)
@ -104,13 +97,9 @@ namespace agg
}
}
//--------------------------------------------------------------------
template<class VertexSource, class ColorStorage, class PathId>
void render_all_paths(VertexSource& vs,
const ColorStorage& colors,
const PathId& path_id,
unsigned num_paths)
void render_all_paths(VertexSource& vs, const ColorStorage& colors, const PathId& path_id, unsigned num_paths)
{
for (unsigned i = 0; i < num_paths; i++)
{
@ -119,9 +108,9 @@ namespace agg
}
}
//--------------------------------------------------------------------
template<class Ctrl> void render_ctrl(Ctrl& c)
template<class Ctrl>
void render_ctrl(Ctrl& c)
{
unsigned i;
for (i = 0; i < c.num_paths(); i++)
@ -131,7 +120,6 @@ namespace agg
}
}
private:
Renderer* m_ren;
int m_start_x;
@ -139,9 +127,6 @@ namespace agg
unsigned m_vertices;
};
}
} // namespace agg
#endif

195
deps/agg/include/agg_rasterizer_outline_aa.h vendored
View file

@ -19,14 +19,17 @@
#include "agg_line_aa_basics.h"
#include "agg_vertex_sequence.h"
namespace agg
{
namespace agg {
//-------------------------------------------------------------------------
inline bool cmp_dist_start(int d) { return d > 0; }
inline bool cmp_dist_end(int d) { return d <= 0; }
inline bool cmp_dist_start(int d)
{
return d > 0;
}
inline bool cmp_dist_end(int d)
{
return d <= 0;
}
//-----------------------------------------------------------line_aa_vertex
// Vertex (x, y) with the distance to the next one. The last vertex has
@ -38,26 +41,22 @@ namespace agg
int len;
line_aa_vertex() {}
line_aa_vertex(int x_, int y_) :
x(x_),
y(y_),
len(0)
{
}
line_aa_vertex(int x_, int y_)
: x(x_)
, y(y_)
, len(0)
{}
bool operator()(const line_aa_vertex& val)
{
double dx = val.x - x;
double dy = val.y - y;
return (len = uround(sqrt(dx * dx + dy * dy))) >
(line_subpixel_scale + line_subpixel_scale / 2);
return (len = uround(sqrt(dx * dx + dy * dy))) > (line_subpixel_scale + line_subpixel_scale / 2);
}
};
//----------------------------------------------------------outline_aa_join_e
enum outline_aa_join_e
{
enum outline_aa_join_e {
outline_no_join, //-----outline_no_join
outline_miter_join, //-----outline_miter_join
outline_round_join, //-----outline_round_join
@ -65,7 +64,8 @@ namespace agg
};
//=======================================================rasterizer_outline_aa
template<class Renderer, class Coord=line_coord> class rasterizer_outline_aa
template<class Renderer, class Coord = line_coord>
class rasterizer_outline_aa
{
private:
//------------------------------------------------------------------------
@ -85,23 +85,19 @@ namespace agg
typedef line_aa_vertex vertex_type;
typedef vertex_sequence<vertex_type, 6> vertex_storage_type;
explicit rasterizer_outline_aa(Renderer& ren) :
m_ren(&ren),
m_line_join(ren.accurate_join_only() ?
outline_miter_accurate_join :
outline_round_join),
m_round_cap(false),
m_start_x(0),
m_start_y(0)
explicit rasterizer_outline_aa(Renderer& ren)
: m_ren(&ren)
, m_line_join(ren.accurate_join_only() ? outline_miter_accurate_join : outline_round_join)
, m_round_cap(false)
, m_start_x(0)
, m_start_y(0)
{}
void attach(Renderer& ren) { m_ren = &ren; }
//------------------------------------------------------------------------
void line_join(outline_aa_join_e join)
{
m_line_join = m_ren->accurate_join_only() ?
outline_miter_accurate_join :
join;
m_line_join = m_ren->accurate_join_only() ? outline_miter_accurate_join : join;
}
bool line_join() const { return m_line_join; }
@ -110,28 +106,16 @@ namespace agg
bool round_cap() const { return m_round_cap; }
//------------------------------------------------------------------------
void move_to(int x, int y)
{
m_src_vertices.modify_last(vertex_type(m_start_x = x, m_start_y = y));
}
void move_to(int x, int y) { m_src_vertices.modify_last(vertex_type(m_start_x = x, m_start_y = y)); }
//------------------------------------------------------------------------
void line_to(int x, int y)
{
m_src_vertices.add(vertex_type(x, y));
}
void line_to(int x, int y) { m_src_vertices.add(vertex_type(x, y)); }
//------------------------------------------------------------------------
void move_to_d(double x, double y)
{
move_to(Coord::conv(x), Coord::conv(y));
}
void move_to_d(double x, double y) { move_to(Coord::conv(x), Coord::conv(y)); }
//------------------------------------------------------------------------
void line_to_d(double x, double y)
{
line_to(Coord::conv(x), Coord::conv(y));
}
void line_to_d(double x, double y) { line_to(Coord::conv(x), Coord::conv(y)); }
//------------------------------------------------------------------------
void render(bool close_polygon);
@ -177,13 +161,9 @@ namespace agg
render(false);
}
//------------------------------------------------------------------------
template<class VertexSource, class ColorStorage, class PathId>
void render_all_paths(VertexSource& vs,
const ColorStorage& colors,
const PathId& path_id,
unsigned num_paths)
void render_all_paths(VertexSource& vs, const ColorStorage& colors, const PathId& path_id, unsigned num_paths)
{
for (unsigned i = 0; i < num_paths; i++)
{
@ -192,9 +172,9 @@ namespace agg
}
}
//------------------------------------------------------------------------
template<class Ctrl> void render_ctrl(Ctrl& c)
template<class Ctrl>
void render_ctrl(Ctrl& c)
{
unsigned i;
for (i = 0; i < c.num_paths(); i++)
@ -206,8 +186,7 @@ namespace agg
private:
rasterizer_outline_aa(const rasterizer_outline_aa<Renderer, Coord>&);
const rasterizer_outline_aa<Renderer, Coord>& operator =
(const rasterizer_outline_aa<Renderer, Coord>&);
const rasterizer_outline_aa<Renderer, Coord>& operator=(const rasterizer_outline_aa<Renderer, Coord>&);
Renderer* m_ren;
vertex_storage_type m_src_vertices;
@ -217,18 +196,9 @@ namespace agg
int m_start_y;
};
//----------------------------------------------------------------------------
template<class Renderer, class Coord>
void rasterizer_outline_aa<Renderer, Coord>::draw(draw_vars& dv,
unsigned start,
unsigned end)
void rasterizer_outline_aa<Renderer, Coord>::draw(draw_vars& dv, unsigned start, unsigned end)
{
unsigned i;
const vertex_storage_type::value_type* v;
@ -245,15 +215,24 @@ namespace agg
switch (dv.flags)
{
case 0: m_ren->line3(dv.curr, dv.xb1, dv.yb1, dv.xb2, dv.yb2); break;
case 1: m_ren->line2(dv.curr, dv.xb2, dv.yb2); break;
case 2: m_ren->line1(dv.curr, dv.xb1, dv.yb1); break;
case 3: m_ren->line0(dv.curr); break;
case 0:
m_ren->line3(dv.curr, dv.xb1, dv.yb1, dv.xb2, dv.yb2);
break;
case 1:
m_ren->line2(dv.curr, dv.xb2, dv.yb2);
break;
case 2:
m_ren->line1(dv.curr, dv.xb1, dv.yb1);
break;
case 3:
m_ren->line0(dv.curr);
break;
}
if (m_line_join == outline_round_join && (dv.flags & 2) == 0)
{
m_ren->pie(dv.curr.x2, dv.curr.y2,
m_ren->pie(dv.curr.x2,
dv.curr.y2,
dv.curr.x2 + (dv.curr.y2 - dv.curr.y1),
dv.curr.y2 - (dv.curr.x2 - dv.curr.x1),
dv.curr.x2 + (dv.next.y2 - dv.next.y1),
@ -266,7 +245,8 @@ namespace agg
dv.lnext = m_src_vertices[dv.idx].len;
++dv.idx;
if(dv.idx >= m_src_vertices.size()) dv.idx = 0;
if (dv.idx >= m_src_vertices.size())
dv.idx = 0;
v = &m_src_vertices[dv.idx];
dv.x2 = v->x;
@ -285,8 +265,7 @@ namespace agg
case outline_miter_join:
dv.flags >>= 1;
dv.flags |= ((dv.curr.diagonal_quadrant() ==
dv.next.diagonal_quadrant()) << 1);
dv.flags |= ((dv.curr.diagonal_quadrant() == dv.next.diagonal_quadrant()) << 1);
if ((dv.flags & 2) == 0)
{
bisectrix(dv.curr, dv.next, &dv.xb2, &dv.yb2);
@ -295,8 +274,7 @@ namespace agg
case outline_round_join:
dv.flags >>= 1;
dv.flags |= ((dv.curr.diagonal_quadrant() ==
dv.next.diagonal_quadrant()) << 1);
dv.flags |= ((dv.curr.diagonal_quadrant() == dv.next.diagonal_quadrant()) << 1);
break;
case outline_miter_accurate_join:
@ -307,9 +285,6 @@ namespace agg
}
}
//----------------------------------------------------------------------------
template<class Renderer, class Coord>
void rasterizer_outline_aa<Renderer, Coord>::render(bool close_polygon)
@ -362,8 +337,7 @@ namespace agg
case outline_miter_join:
case outline_round_join:
dv.flags =
(prev.diagonal_quadrant() == dv.curr.diagonal_quadrant()) |
dv.flags = (prev.diagonal_quadrant() == dv.curr.diagonal_quadrant()) |
((dv.curr.diagonal_quadrant() == dv.next.diagonal_quadrant()) << 1);
break;
@ -391,8 +365,7 @@ namespace agg
case 1:
break;
case 2:
{
case 2: {
v = &m_src_vertices[0];
x1 = v->x;
y1 = v->y;
@ -405,11 +378,7 @@ namespace agg
{
m_ren->semidot(cmp_dist_start, x1, y1, x1 + (y2 - y1), y1 - (x2 - x1));
}
m_ren->line3(lp,
x1 + (y2 - y1),
y1 - (x2 - x1),
x2 + (y2 - y1),
y2 - (x2 - x1));
m_ren->line3(lp, x1 + (y2 - y1), y1 - (x2 - x1), x2 + (y2 - y1), y2 - (x2 - x1));
if (m_round_cap)
{
m_ren->semidot(cmp_dist_end, x2, y2, x2 + (y2 - y1), y2 - (x2 - x1));
@ -417,8 +386,7 @@ namespace agg
}
break;
case 3:
{
case 3: {
int x3, y3;
int lnext;
v = &m_src_vertices[0];
@ -442,23 +410,18 @@ namespace agg
if (m_line_join == outline_round_join)
{
m_ren->line3(lp1, x1 + (y2 - y1), y1 - (x2 - x1),
x2 + (y2 - y1), y2 - (x2 - x1));
m_ren->line3(lp1, x1 + (y2 - y1), y1 - (x2 - x1), x2 + (y2 - y1), y2 - (x2 - x1));
m_ren->pie(x2, y2, x2 + (y2 - y1), y2 - (x2 - x1),
x2 + (y3 - y2), y2 - (x3 - x2));
m_ren->pie(x2, y2, x2 + (y2 - y1), y2 - (x2 - x1), x2 + (y3 - y2), y2 - (x3 - x2));
m_ren->line3(lp2, x2 + (y3 - y2), y2 - (x3 - x2),
x3 + (y3 - y2), y3 - (x3 - x2));
m_ren->line3(lp2, x2 + (y3 - y2), y2 - (x3 - x2), x3 + (y3 - y2), y3 - (x3 - x2));
}
else
{
bisectrix(lp1, lp2, &dv.xb1, &dv.yb1);
m_ren->line3(lp1, x1 + (y2 - y1), y1 - (x2 - x1),
dv.xb1, dv.yb1);
m_ren->line3(lp1, x1 + (y2 - y1), y1 - (x2 - x1), dv.xb1, dv.yb1);
m_ren->line3(lp2, dv.xb1, dv.yb1,
x3 + (y3 - y2), y3 - (x3 - x2));
m_ren->line3(lp2, dv.xb1, dv.yb1, x3 + (y3 - y2), y3 - (x3 - x2));
}
if (m_round_cap)
{
@ -467,8 +430,7 @@ namespace agg
}
break;
default:
{
default: {
dv.idx = 3;
v = &m_src_vertices[0];
@ -506,8 +468,7 @@ namespace agg
case outline_miter_join:
case outline_round_join:
dv.flags =
(prev.diagonal_quadrant() == dv.curr.diagonal_quadrant()) |
dv.flags = (prev.diagonal_quadrant() == dv.curr.diagonal_quadrant()) |
((dv.curr.diagonal_quadrant() == dv.next.diagonal_quadrant()) << 1);
break;
@ -524,25 +485,23 @@ namespace agg
{
if (m_line_join == outline_round_join)
{
m_ren->line3(prev, x1 + (y2 - y1), y1 - (x2 - x1),
x2 + (y2 - y1), y2 - (x2 - x1));
m_ren->pie(prev.x2, prev.y2,
x2 + (y2 - y1), y2 - (x2 - x1),
m_ren->line3(prev, x1 + (y2 - y1), y1 - (x2 - x1), x2 + (y2 - y1), y2 - (x2 - x1));
m_ren->pie(prev.x2,
prev.y2,
x2 + (y2 - y1),
y2 - (x2 - x1),
dv.curr.x1 + (dv.curr.y2 - dv.curr.y1),
dv.curr.y1 - (dv.curr.x2 - dv.curr.x1));
}
else
{
bisectrix(prev, dv.curr, &dv.xb1, &dv.yb1);
m_ren->line3(prev, x1 + (y2 - y1), y1 - (x2 - x1),
dv.xb1, dv.yb1);
m_ren->line3(prev, x1 + (y2 - y1), y1 - (x2 - x1), dv.xb1, dv.yb1);
}
}
else
{
m_ren->line1(prev,
x1 + (y2 - y1),
y1 - (x2 - x1));
m_ren->line1(prev, x1 + (y2 - y1), y1 - (x2 - x1));
}
if ((dv.flags & 2) == 0 && m_line_join != outline_round_join)
{
@ -563,7 +522,9 @@ namespace agg
}
else
{
m_ren->line3(dv.curr, dv.xb1, dv.yb1,
m_ren->line3(dv.curr,
dv.xb1,
dv.yb1,
dv.curr.x2 + (dv.curr.y2 - dv.curr.y1),
dv.curr.y2 - (dv.curr.x2 - dv.curr.x1));
}
@ -576,11 +537,12 @@ namespace agg
}
if (m_round_cap)
{
m_ren->semidot(cmp_dist_end, dv.curr.x2, dv.curr.y2,
m_ren->semidot(cmp_dist_end,
dv.curr.x2,
dv.curr.y2,
dv.curr.x2 + (dv.curr.y2 - dv.curr.y1),
dv.curr.y2 - (dv.curr.x2 - dv.curr.x1));
}
}
break;
}
@ -588,9 +550,6 @@ namespace agg
m_src_vertices.remove_all();
}
}
} // namespace agg
#endif

182
deps/agg/include/agg_rasterizer_scanline_aa.h vendored
View file

@ -33,10 +33,7 @@
#include "agg_rasterizer_sl_clip.h"
#include "agg_gamma_functions.h"
namespace agg
{
namespace agg {
//-----------------------------------------------------------------cell_aa
// A pixel cell. There're no constructors defined and it was done
@ -59,13 +56,9 @@ namespace agg
void style(const cell_aa&) {}
int not_equal(int ex, int ey, const cell_aa&) const
{
return (ex - x) | (ey - y);
}
int not_equal(int ex, int ey, const cell_aa&) const { return (ex - x) | (ey - y); }
};
//==================================================rasterizer_scanline_aa
// Polygon rasterizer that is used to render filled polygons with
// high-quality Anti-Aliasing. Internally, by default, the class uses
@ -97,23 +90,17 @@ namespace agg
//
// filling_rule() and gamma() can be called anytime before "sweeping".
//------------------------------------------------------------------------
template<class Clip=rasterizer_sl_clip_int> class rasterizer_scanline_aa
template<class Clip = rasterizer_sl_clip_int>
class rasterizer_scanline_aa
{
enum status
{
status_initial,
status_move_to,
status_line_to,
status_closed
};
enum status { status_initial, status_move_to, status_line_to, status_closed };
public:
typedef Clip clip_type;
typedef typename Clip::conv_type conv_type;
typedef typename Clip::coord_type coord_type;
enum aa_scale_e
{
enum aa_scale_e {
aa_shift = 8,
aa_scale = 1 << aa_shift,
aa_mask = aa_scale - 1,
@ -122,29 +109,30 @@ namespace agg
};
//--------------------------------------------------------------------
rasterizer_scanline_aa() :
m_outline(),
m_clipper(),
m_filling_rule(fill_non_zero),
m_auto_close(true),
m_start_x(0),
m_start_y(0),
m_status(status_initial)
rasterizer_scanline_aa()
: m_outline()
, m_clipper()
, m_filling_rule(fill_non_zero)
, m_auto_close(true)
, m_start_x(0)
, m_start_y(0)
, m_status(status_initial)
{
int i;
for(i = 0; i < aa_scale; i++) m_gamma[i] = i;
for (i = 0; i < aa_scale; i++)
m_gamma[i] = i;
}
//--------------------------------------------------------------------
template<class GammaF>
rasterizer_scanline_aa(const GammaF& gamma_function) :
m_outline(),
m_clipper(m_outline),
m_filling_rule(fill_non_zero),
m_auto_close(true),
m_start_x(0),
m_start_y(0),
m_status(status_initial)
rasterizer_scanline_aa(const GammaF& gamma_function)
: m_outline()
, m_clipper(m_outline)
, m_filling_rule(fill_non_zero)
, m_auto_close(true)
, m_start_x(0)
, m_start_y(0)
, m_status(status_initial)
{
gamma(gamma_function);
}
@ -157,7 +145,8 @@ namespace agg
void auto_close(bool flag) { m_auto_close = flag; }
//--------------------------------------------------------------------
template<class GammaF> void gamma(const GammaF& gamma_function)
template<class GammaF>
void gamma(const GammaF& gamma_function)
{
int i;
for (i = 0; i < aa_scale; i++)
@ -167,10 +156,7 @@ namespace agg
}
//--------------------------------------------------------------------
unsigned apply_gamma(unsigned cover) const
{
return m_gamma[cover];
}
unsigned apply_gamma(unsigned cover) const { return m_gamma[cover]; }
//--------------------------------------------------------------------
void move_to(int x, int y);
@ -192,7 +178,8 @@ namespace agg
unsigned cmd;
vs.rewind(path_id);
if(m_outline.sorted()) reset();
if (m_outline.sorted())
reset();
while (!is_stop(cmd = vs.vertex(&x, &y)))
{
add_vertex(x, y, cmd);
@ -215,7 +202,8 @@ namespace agg
{
int cover = area >> (poly_subpixel_shift * 2 + 1 - aa_shift);
if(cover < 0) cover = -cover;
if (cover < 0)
cover = -cover;
if (m_filling_rule == fill_even_odd)
{
cover &= aa_mask2;
@ -224,16 +212,19 @@ namespace agg
cover = aa_scale2 - cover;
}
}
if(cover > aa_mask) cover = aa_mask;
if (cover > aa_mask)
cover = aa_mask;
return m_gamma[cover];
}
//--------------------------------------------------------------------
template<class Scanline> bool sweep_scanline(Scanline& sl)
template<class Scanline>
bool sweep_scanline(Scanline& sl)
{
for (;;)
{
if(m_scan_y > m_outline.max_y()) return false;
if (m_scan_y > m_outline.max_y())
return false;
sl.reset_spans();
unsigned num_cells = m_outline.scanline_num_cells(m_scan_y);
const cell_aa* const* cells = m_outline.scanline_cells(m_scan_y);
@ -252,7 +243,8 @@ namespace agg
while (--num_cells)
{
cur_cell = *++cells;
if(cur_cell->x != x) break;
if (cur_cell->x != x)
break;
area += cur_cell->area;
cover += cur_cell->cover;
}
@ -277,7 +269,8 @@ namespace agg
}
}
if(sl.num_spans()) break;
if (sl.num_spans())
break;
++m_scan_y;
}
@ -289,13 +282,11 @@ namespace agg
//--------------------------------------------------------------------
bool hit_test(int tx, int ty);
private:
//--------------------------------------------------------------------
// Disable copying
rasterizer_scanline_aa(const rasterizer_scanline_aa<Clip>&);
const rasterizer_scanline_aa<Clip>&
operator = (const rasterizer_scanline_aa<Clip>&);
const rasterizer_scanline_aa<Clip>& operator=(const rasterizer_scanline_aa<Clip>&);
private:
rasterizer_cells_aa<cell_aa> m_outline;
@ -309,17 +300,6 @@ namespace agg
int m_scan_y;
};
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::reset()
@ -337,12 +317,10 @@ namespace agg
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::clip_box(double x1, double y1,
double x2, double y2)
void rasterizer_scanline_aa<Clip>::clip_box(double x1, double y1, double x2, double y2)
{
reset();
m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1),
conv_type::upscale(x2), conv_type::upscale(y2));
m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1), conv_type::upscale(x2), conv_type::upscale(y2));
}
//------------------------------------------------------------------------
@ -368,10 +346,11 @@ namespace agg
template<class Clip>
void rasterizer_scanline_aa<Clip>::move_to(int x, int y)
{
if(m_outline.sorted()) reset();
if(m_auto_close) close_polygon();
m_clipper.move_to(m_start_x = conv_type::downscale(x),
m_start_y = conv_type::downscale(y));
if (m_outline.sorted())
reset();
if (m_auto_close)
close_polygon();
m_clipper.move_to(m_start_x = conv_type::downscale(x), m_start_y = conv_type::downscale(y));
m_status = status_move_to;
}
@ -379,9 +358,7 @@ namespace agg
template<class Clip>
void rasterizer_scanline_aa<Clip>::line_to(int x, int y)
{
m_clipper.line_to(m_outline,
conv_type::downscale(x),
conv_type::downscale(y));
m_clipper.line_to(m_outline, conv_type::downscale(x), conv_type::downscale(y));
m_status = status_line_to;
}
@ -389,10 +366,11 @@ namespace agg
template<class Clip>
void rasterizer_scanline_aa<Clip>::move_to_d(double x, double y)
{
if(m_outline.sorted()) reset();
if(m_auto_close) close_polygon();
m_clipper.move_to(m_start_x = conv_type::upscale(x),
m_start_y = conv_type::upscale(y));
if (m_outline.sorted())
reset();
if (m_auto_close)
close_polygon();
m_clipper.move_to(m_start_x = conv_type::upscale(x), m_start_y = conv_type::upscale(y));
m_status = status_move_to;
}
@ -400,9 +378,7 @@ namespace agg
template<class Clip>
void rasterizer_scanline_aa<Clip>::line_to_d(double x, double y)
{
m_clipper.line_to(m_outline,
conv_type::upscale(x),
conv_type::upscale(y));
m_clipper.line_to(m_outline, conv_type::upscale(x), conv_type::upscale(y));
m_status = status_line_to;
}
@ -414,13 +390,11 @@ namespace agg
{
move_to_d(x, y);
}
else
if(is_vertex(cmd))
else if (is_vertex(cmd))
{
line_to_d(x, y);
}
else
if(is_close(cmd))
else if (is_close(cmd))
{
close_polygon();
}
@ -430,24 +404,21 @@ namespace agg
template<class Clip>
void rasterizer_scanline_aa<Clip>::edge(int x1, int y1, int x2, int y2)
{
if(m_outline.sorted()) reset();
if (m_outline.sorted())
reset();
m_clipper.move_to(conv_type::downscale(x1), conv_type::downscale(y1));
m_clipper.line_to(m_outline,
conv_type::downscale(x2),
conv_type::downscale(y2));
m_clipper.line_to(m_outline, conv_type::downscale(x2), conv_type::downscale(y2));
m_status = status_move_to;
}
//------------------------------------------------------------------------
template<class Clip>
void rasterizer_scanline_aa<Clip>::edge_d(double x1, double y1,
double x2, double y2)
void rasterizer_scanline_aa<Clip>::edge_d(double x1, double y1, double x2, double y2)
{
if(m_outline.sorted()) reset();
if (m_outline.sorted())
reset();
m_clipper.move_to(conv_type::upscale(x1), conv_type::upscale(y1));
m_clipper.line_to(m_outline,
conv_type::upscale(x2),
conv_type::upscale(y2));
m_clipper.line_to(m_outline, conv_type::upscale(x2), conv_type::upscale(y2));
m_status = status_move_to;
}
@ -455,7 +426,8 @@ namespace agg
template<class Clip>
void rasterizer_scanline_aa<Clip>::sort()
{
if(m_auto_close) close_polygon();
if (m_auto_close)
close_polygon();
m_outline.sort_cells();
}
@ -463,7 +435,8 @@ namespace agg
template<class Clip>
AGG_INLINE bool rasterizer_scanline_aa<Clip>::rewind_scanlines()
{
if(m_auto_close) close_polygon();
if (m_auto_close)
close_polygon();
m_outline.sort_cells();
if (m_outline.total_cells() == 0)
{
@ -473,16 +446,14 @@ namespace agg
return true;
}
//------------------------------------------------------------------------
template<class Clip>
AGG_INLINE bool rasterizer_scanline_aa<Clip>::navigate_scanline(int y)
{
if(m_auto_close) close_polygon();
if (m_auto_close)
close_polygon();
m_outline.sort_cells();
if(m_outline.total_cells() == 0 ||
y < m_outline.min_y() ||
y > m_outline.max_y())
if (m_outline.total_cells() == 0 || y < m_outline.min_y() || y > m_outline.max_y())
{
return false;
}
@ -494,16 +465,13 @@ namespace agg
template<class Clip>
bool rasterizer_scanline_aa<Clip>::hit_test(int tx, int ty)
{
if(!navigate_scanline(ty)) return false;
if (!navigate_scanline(ty))
return false;
scanline_hit_test sl(tx);
sweep_scanline(sl);
return sl.hit();
}
}
} // namespace agg
#endif

86
deps/agg/include/agg_rasterizer_sl_clip.h vendored
View file

@ -17,11 +17,9 @@
#include "agg_clip_liang_barsky.h"
namespace agg
{
namespace agg {
//--------------------------------------------------------poly_max_coord_e
enum poly_max_coord_e
{
enum poly_max_coord_e {
poly_max_coord = (1 << 30) - 1 //----poly_max_coord
};
@ -29,10 +27,7 @@ namespace agg
struct ras_conv_int
{
typedef int coord_type;
static AGG_INLINE int mul_div(double a, double b, double c)
{
return iround(a * b / c);
}
static AGG_INLINE int mul_div(double a, double b, double c) { return iround(a * b / c); }
static int xi(int v) { return v; }
static int yi(int v) { return v; }
static int upscale(double v) { return iround(v * static_cast<double>(poly_subpixel_scale)); }
@ -60,10 +55,7 @@ namespace agg
struct ras_conv_int_3x
{
typedef int coord_type;
static AGG_INLINE int mul_div(double a, double b, double c)
{
return iround(a * b / c);
}
static AGG_INLINE int mul_div(double a, double b, double c) { return iround(a * b / c); }
static int xi(int v) { return v * 3; }
static int yi(int v) { return v; }
static int upscale(double v) { return iround(v * static_cast<double>(poly_subpixel_scale)); }
@ -74,10 +66,7 @@ namespace agg
struct ras_conv_dbl
{
typedef double coord_type;
static AGG_INLINE double mul_div(double a, double b, double c)
{
return a * b / c;
}
static AGG_INLINE double mul_div(double a, double b, double c) { return a * b / c; }
static int xi(double v) { return iround(v * static_cast<double>(poly_subpixel_scale)); }
static int yi(double v) { return iround(v * static_cast<double>(poly_subpixel_scale)); }
static double upscale(double v) { return v; }
@ -88,22 +77,16 @@ namespace agg
struct ras_conv_dbl_3x
{
typedef double coord_type;
static AGG_INLINE double mul_div(double a, double b, double c)
{
return a * b / c;
}
static AGG_INLINE double mul_div(double a, double b, double c) { return a * b / c; }
static int xi(double v) { return iround(v * static_cast<double>(poly_subpixel_scale) * 3); }
static int yi(double v) { return iround(v * static_cast<double>(poly_subpixel_scale)); }
static double upscale(double v) { return v; }
static double downscale(int v) { return v / static_cast<double>(poly_subpixel_scale); }
};
//------------------------------------------------------rasterizer_sl_clip
template<class Conv> class rasterizer_sl_clip
template<class Conv>
class rasterizer_sl_clip
{
public:
typedef Conv conv_type;
@ -111,19 +94,16 @@ namespace agg
typedef rect_base<coord_type> rect_type;
//--------------------------------------------------------------------
rasterizer_sl_clip() :
m_clip_box(0,0,0,0),
m_x1(0),
m_y1(0),
m_f1(0),
m_clipping(false)
rasterizer_sl_clip()
: m_clip_box(0, 0, 0, 0)
, m_x1(0)
, m_y1(0)
, m_f1(0)
, m_clipping(false)
{}
//--------------------------------------------------------------------
void reset_clipping()
{
m_clipping = false;
}
void reset_clipping() { m_clipping = false; }
//--------------------------------------------------------------------
void clip_box(coord_type x1, coord_type y1, coord_type x2, coord_type y2)
@ -138,16 +118,16 @@ namespace agg
{
m_x1 = x1;
m_y1 = y1;
if(m_clipping) m_f1 = clipping_flags(x1, y1, m_clip_box);
if (m_clipping)
m_f1 = clipping_flags(x1, y1, m_clip_box);
}
private:
//------------------------------------------------------------------------
template<class Rasterizer>
AGG_INLINE void line_clip_y(Rasterizer& ras,
coord_type x1, coord_type y1,
coord_type x2, coord_type y2,
unsigned f1, unsigned f2) const
AGG_INLINE void
line_clip_y(Rasterizer& ras, coord_type x1, coord_type y1, coord_type x2, coord_type y2, unsigned f1, unsigned f2)
const
{
f1 &= 10;
f2 &= 10;
@ -192,12 +172,10 @@ namespace agg
tx2 = x1 + Conv::mul_div(m_clip_box.y2 - y1, x2 - x1, y2 - y1);
ty2 = m_clip_box.y2;
}
ras.line(Conv::xi(tx1), Conv::yi(ty1),
Conv::xi(tx2), Conv::yi(ty2));
ras.line(Conv::xi(tx1), Conv::yi(ty1), Conv::xi(tx2), Conv::yi(ty2));
}
}
public:
//--------------------------------------------------------------------
template<class Rasterizer>
@ -288,14 +266,12 @@ namespace agg
}
else
{
ras.line(Conv::xi(m_x1), Conv::yi(m_y1),
Conv::xi(x2), Conv::yi(y2));
ras.line(Conv::xi(m_x1), Conv::yi(m_y1), Conv::xi(x2), Conv::yi(y2));
}
m_x1 = x2;
m_y1 = y2;
}
private:
rect_type m_clip_box;
coord_type m_x1;
@ -304,9 +280,6 @@ namespace agg
bool m_clipping;
};
//---------------------------------------------------rasterizer_sl_no_clip
class rasterizer_sl_no_clip
{
@ -314,11 +287,18 @@ namespace agg
typedef ras_conv_int conv_type;
typedef int coord_type;
rasterizer_sl_no_clip() : m_x1(0), m_y1(0) {}
rasterizer_sl_no_clip()
: m_x1(0)
, m_y1(0)
{}
void reset_clipping() {}
void clip_box(coord_type /*x1*/, coord_type /*y1*/, coord_type /*x2*/, coord_type /*y2*/) {}
void move_to(coord_type x1, coord_type y1) { m_x1 = x1; m_y1 = y1; }
void move_to(coord_type x1, coord_type y1)
{
m_x1 = x1;
m_y1 = y1;
}
template<class Rasterizer>
void line_to(Rasterizer& ras, coord_type x2, coord_type y2)
@ -332,7 +312,6 @@ namespace agg
int m_x1, m_y1;
};
// -----rasterizer_sl_clip_int
// -----rasterizer_sl_clip_int_sat
// -----rasterizer_sl_clip_int_3x
@ -345,7 +324,6 @@ namespace agg
typedef rasterizer_sl_clip<ras_conv_dbl> rasterizer_sl_clip_dbl;
typedef rasterizer_sl_clip<ras_conv_dbl_3x> rasterizer_sl_clip_dbl_3x;
}
} // namespace agg
#endif

311
deps/agg/include/agg_renderer_base.h vendored
View file

@ -23,11 +23,11 @@
#include "agg_basics.h"
#include "agg_rendering_buffer.h"
namespace agg
{
namespace agg {
//-----------------------------------------------------------renderer_base
template<class PixelFormat> class renderer_base
template<class PixelFormat>
class renderer_base
{
public:
typedef PixelFormat pixfmt_type;
@ -36,10 +36,13 @@ namespace agg
typedef typename pixfmt_type::row_data row_data;
//--------------------------------------------------------------------
renderer_base() : m_ren(0), m_clip_box(1, 1, 0, 0) {}
explicit renderer_base(pixfmt_type& ren) :
m_ren(&ren),
m_clip_box(0, 0, ren.width() - 1, ren.height() - 1)
renderer_base()
: m_ren(0)
, m_clip_box(1, 1, 0, 0)
{}
explicit renderer_base(pixfmt_type& ren)
: m_ren(&ren)
, m_clip_box(0, 0, ren.width() - 1, ren.height() - 1)
{}
void attach(pixfmt_type& ren)
{
@ -103,8 +106,7 @@ namespace agg
//--------------------------------------------------------------------
bool inbox(int x, int y) const
{
return x >= m_clip_box.x1 && y >= m_clip_box.y1 &&
x <= m_clip_box.x2 && y <= m_clip_box.y2;
return x >= m_clip_box.x1 && y >= m_clip_box.y1 && x <= m_clip_box.x2 && y <= m_clip_box.y2;
}
//--------------------------------------------------------------------
@ -134,7 +136,6 @@ namespace agg
}
}
//--------------------------------------------------------------------
void copy_pixel(int x, int y, const color_type& c)
{
@ -154,24 +155,30 @@ namespace agg
}
//--------------------------------------------------------------------
color_type pixel(int x, int y) const
{
return inbox(x, y) ?
m_ren->pixel(x, y) :
color_type::no_color();
}
color_type pixel(int x, int y) const { return inbox(x, y) ? m_ren->pixel(x, y) : color_type::no_color(); }
//--------------------------------------------------------------------
void copy_hline(int x1, int y, int x2, const color_type& c)
{
if(x1 > x2) { int t = x2; x2 = x1; x1 = t; }
if(y > ymax()) return;
if(y < ymin()) return;
if(x1 > xmax()) return;
if(x2 < xmin()) return;
if (x1 > x2)
{
int t = x2;
x2 = x1;
x1 = t;
}
if (y > ymax())
return;
if (y < ymin())
return;
if (x1 > xmax())
return;
if (x2 < xmin())
return;
if(x1 < xmin()) x1 = xmin();
if(x2 > xmax()) x2 = xmax();
if (x1 < xmin())
x1 = xmin();
if (x2 > xmax())
x2 = xmax();
m_ren->copy_hline(x1, y, x2 - x1 + 1, c);
}
@ -179,51 +186,81 @@ namespace agg
//--------------------------------------------------------------------
void copy_vline(int x, int y1, int y2, const color_type& c)
{
if(y1 > y2) { int t = y2; y2 = y1; y1 = t; }
if(x > xmax()) return;
if(x < xmin()) return;
if(y1 > ymax()) return;
if(y2 < ymin()) return;
if (y1 > y2)
{
int t = y2;
y2 = y1;
y1 = t;
}
if (x > xmax())
return;
if (x < xmin())
return;
if (y1 > ymax())
return;
if (y2 < ymin())
return;
if(y1 < ymin()) y1 = ymin();
if(y2 > ymax()) y2 = ymax();
if (y1 < ymin())
y1 = ymin();
if (y2 > ymax())
y2 = ymax();
m_ren->copy_vline(x, y1, y2 - y1 + 1, c);
}
//--------------------------------------------------------------------
void blend_hline(int x1, int y, int x2,
const color_type& c, cover_type cover)
void blend_hline(int x1, int y, int x2, const color_type& c, cover_type cover)
{
if(x1 > x2) { int t = x2; x2 = x1; x1 = t; }
if(y > ymax()) return;
if(y < ymin()) return;
if(x1 > xmax()) return;
if(x2 < xmin()) return;
if (x1 > x2)
{
int t = x2;
x2 = x1;
x1 = t;
}
if (y > ymax())
return;
if (y < ymin())
return;
if (x1 > xmax())
return;
if (x2 < xmin())
return;
if(x1 < xmin()) x1 = xmin();
if(x2 > xmax()) x2 = xmax();
if (x1 < xmin())
x1 = xmin();
if (x2 > xmax())
x2 = xmax();
m_ren->blend_hline(x1, y, x2 - x1 + 1, c, cover);
}
//--------------------------------------------------------------------
void blend_vline(int x, int y1, int y2,
const color_type& c, cover_type cover)
void blend_vline(int x, int y1, int y2, const color_type& c, cover_type cover)
{
if(y1 > y2) { int t = y2; y2 = y1; y1 = t; }
if(x > xmax()) return;
if(x < xmin()) return;
if(y1 > ymax()) return;
if(y2 < ymin()) return;
if (y1 > y2)
{
int t = y2;
y2 = y1;
y1 = t;
}
if (x > xmax())
return;
if (x < xmin())
return;
if (y1 > ymax())
return;
if (y2 < ymin())
return;
if(y1 < ymin()) y1 = ymin();
if(y2 > ymax()) y2 = ymax();
if (y1 < ymin())
y1 = ymin();
if (y2 > ymax())
y2 = ymax();
m_ren->blend_vline(x, y1, y2 - y1 + 1, c, cover);
}
//--------------------------------------------------------------------
void copy_bar(int x1, int y1, int x2, int y2, const color_type& c)
{
@ -240,8 +277,7 @@ namespace agg
}
//--------------------------------------------------------------------
void blend_bar(int x1, int y1, int x2, int y2,
const color_type& c, cover_type cover)
void blend_bar(int x1, int y1, int x2, int y2, const color_type& c, cover_type cover)
{
rect_i rc(x1, y1, x2, y2);
rc.normalize();
@ -250,183 +286,209 @@ namespace agg
int y;
for (y = rc.y1; y <= rc.y2; y++)
{
m_ren->blend_hline(rc.x1,
y,
unsigned(rc.x2 - rc.x1 + 1),
c,
cover);
m_ren->blend_hline(rc.x1, y, unsigned(rc.x2 - rc.x1 + 1), c, cover);
}
}
}
//--------------------------------------------------------------------
void blend_solid_hspan(int x, int y, int len,
const color_type& c,
const cover_type* covers)
void blend_solid_hspan(int x, int y, int len, const color_type& c, const cover_type* covers)
{
if(y > ymax()) return;
if(y < ymin()) return;
if (y > ymax())
return;
if (y < ymin())
return;
if (x < xmin())
{
len -= xmin() - x;
if(len <= 0) return;
if (len <= 0)
return;
covers += xmin() - x;
x = xmin();
}
if (x + len > xmax())
{
len = xmax() - x + 1;
if(len <= 0) return;
if (len <= 0)
return;
}
m_ren->blend_solid_hspan(x, y, len, c, covers);
}
//--------------------------------------------------------------------
void blend_solid_vspan(int x, int y, int len,
const color_type& c,
const cover_type* covers)
void blend_solid_vspan(int x, int y, int len, const color_type& c, const cover_type* covers)
{
if(x > xmax()) return;
if(x < xmin()) return;
if (x > xmax())
return;
if (x < xmin())
return;
if (y < ymin())
{
len -= ymin() - y;
if(len <= 0) return;
if (len <= 0)
return;
covers += ymin() - y;
y = ymin();
}
if (y + len > ymax())
{
len = ymax() - y + 1;
if(len <= 0) return;
if (len <= 0)
return;
}
m_ren->blend_solid_vspan(x, y, len, c, covers);
}
//--------------------------------------------------------------------
void copy_color_hspan(int x, int y, int len, const color_type* colors)
{
if(y > ymax()) return;
if(y < ymin()) return;
if (y > ymax())
return;
if (y < ymin())
return;
if (x < xmin())
{
int d = xmin() - x;
len -= d;
if(len <= 0) return;
if (len <= 0)
return;
colors += d;
x = xmin();
}
if (x + len > xmax())
{
len = xmax() - x + 1;
if(len <= 0) return;
if (len <= 0)
return;
}
m_ren->copy_color_hspan(x, y, len, colors);
}
//--------------------------------------------------------------------
void copy_color_vspan(int x, int y, int len, const color_type* colors)
{
if(x > xmax()) return;
if(x < xmin()) return;
if (x > xmax())
return;
if (x < xmin())
return;
if (y < ymin())
{
int d = ymin() - y;
len -= d;
if(len <= 0) return;
if (len <= 0)
return;
colors += d;
y = ymin();
}
if (y + len > ymax())
{
len = ymax() - y + 1;
if(len <= 0) return;
if (len <= 0)
return;
}
m_ren->copy_color_vspan(x, y, len, colors);
}
//--------------------------------------------------------------------
void blend_color_hspan(int x, int y, int len,
void blend_color_hspan(int x,
int y,
int len,
const color_type* colors,
const cover_type* covers,
cover_type cover = agg::cover_full)
{
if(y > ymax()) return;
if(y < ymin()) return;
if (y > ymax())
return;
if (y < ymin())
return;
if (x < xmin())
{
int d = xmin() - x;
len -= d;
if(len <= 0) return;
if(covers) covers += d;
if (len <= 0)
return;
if (covers)
covers += d;
colors += d;
x = xmin();
}
if (x + len > xmax())
{
len = xmax() - x + 1;
if(len <= 0) return;
if (len <= 0)
return;
}
m_ren->blend_color_hspan(x, y, len, colors, covers, cover);
}
//--------------------------------------------------------------------
void blend_color_hspan_alpha(int x, int y, int len,
void blend_color_hspan_alpha(int x,
int y,
int len,
const color_type* colors,
value_type alpha,
const cover_type* covers,
cover_type cover = agg::cover_full)
{
if(y > ymax()) return;
if(y < ymin()) return;
if (y > ymax())
return;
if (y < ymin())
return;
if (x < xmin())
{
int d = xmin() - x;
len -= d;
if(len <= 0) return;
if(covers) covers += d;
if (len <= 0)
return;
if (covers)
covers += d;
colors += d;
x = xmin();
}
if (x + len > xmax())
{
len = xmax() - x + 1;
if(len <= 0) return;
if (len <= 0)
return;
}
m_ren->blend_color_hspan_alpha(x, y, len, colors, alpha, covers, cover);
}
//--------------------------------------------------------------------
void blend_color_vspan(int x, int y, int len,
void blend_color_vspan(int x,
int y,
int len,
const color_type* colors,
const cover_type* covers,
cover_type cover = agg::cover_full)
{
if(x > xmax()) return;
if(x < xmin()) return;
if (x > xmax())
return;
if (x < xmin())
return;
if (y < ymin())
{
int d = ymin() - y;
len -= d;
if(len <= 0) return;
if(covers) covers += d;
if (len <= 0)
return;
if (covers)
covers += d;
colors += d;
y = ymin();
}
if (y + len > ymax())
{
len = ymax() - y + 1;
if(len <= 0) return;
if (len <= 0)
return;
}
m_ren->blend_color_vspan(x, y, len, colors, covers, cover);
}
@ -450,8 +512,10 @@ namespace agg
src.y1 = 0;
}
if(src.x2 > wsrc) src.x2 = wsrc;
if(src.y2 > hsrc) src.y2 = hsrc;
if (src.x2 > wsrc)
src.x2 = wsrc;
if (src.y2 > hsrc)
src.y2 = hsrc;
if (dst.x1 < cb.x1)
{
@ -464,23 +528,24 @@ namespace agg
dst.y1 = cb.y1;
}
if(dst.x2 > cb.x2) dst.x2 = cb.x2;
if(dst.y2 > cb.y2) dst.y2 = cb.y2;
if (dst.x2 > cb.x2)
dst.x2 = cb.x2;
if (dst.y2 > cb.y2)
dst.y2 = cb.y2;
rc.x2 = dst.x2 - dst.x1;
rc.y2 = dst.y2 - dst.y1;
if(rc.x2 > src.x2 - src.x1) rc.x2 = src.x2 - src.x1;
if(rc.y2 > src.y2 - src.y1) rc.y2 = src.y2 - src.y1;
if (rc.x2 > src.x2 - src.x1)
rc.x2 = src.x2 - src.x1;
if (rc.y2 > src.y2 - src.y1)
rc.y2 = src.y2 - src.y1;
return rc;
}
//--------------------------------------------------------------------
template<class RenBuf>
void copy_from(const RenBuf& src,
const rect_i* rect_src_ptr = 0,
int dx = 0,
int dy = 0)
void copy_from(const RenBuf& src, const rect_i* rect_src_ptr = 0, int dx = 0, int dy = 0)
{
rect_i rsrc(0, 0, src.width(), src.height());
if (rect_src_ptr)
@ -510,10 +575,7 @@ namespace agg
}
while (rc.y2 > 0)
{
m_ren->copy_from(src,
rdst.x1, rdst.y1,
rsrc.x1, rsrc.y1,
rc.x2);
m_ren->copy_from(src, rdst.x1, rdst.y1, rsrc.x1, rsrc.y1, rc.x2);
rdst.y1 += incy;
rsrc.y1 += incy;
--rc.y2;
@ -576,11 +638,7 @@ namespace agg
}
if (len > 0)
{
m_ren->blend_from(src,
x1dst, rdst.y1,
x1src, rsrc.y1,
len,
cover);
m_ren->blend_from(src, x1dst, rdst.y1, x1src, rsrc.y1, len, cover);
}
}
}
@ -647,12 +705,7 @@ namespace agg
}
if (len > 0)
{
m_ren->blend_from_color(src,
color,
x1dst, rdst.y1,
x1src, rsrc.y1,
len,
cover);
m_ren->blend_from_color(src, color, x1dst, rdst.y1, x1src, rsrc.y1, len, cover);
}
}
}
@ -719,12 +772,7 @@ namespace agg
}
if (len > 0)
{
m_ren->blend_from_lut(src,
color_lut,
x1dst, rdst.y1,
x1src, rsrc.y1,
len,
cover);
m_ren->blend_from_lut(src, color_lut, x1dst, rdst.y1, x1src, rsrc.y1, len, cover);
}
}
}
@ -740,7 +788,6 @@ namespace agg
rect_i m_clip_box;
};
}
} // namespace agg
#endif

1080
deps/agg/include/agg_renderer_markers.h vendored
View file

File diff suppressed because it is too large Load diff

115
deps/agg/include/agg_renderer_mclip.h vendored
View file

@ -24,11 +24,11 @@
#include "agg_array.h"
#include "agg_renderer_base.h"
namespace agg
{
namespace agg {
//----------------------------------------------------------renderer_mclip
template<class PixelFormat> class renderer_mclip
template<class PixelFormat>
class renderer_mclip
{
public:
typedef PixelFormat pixfmt_type;
@ -37,10 +37,10 @@ namespace agg
typedef renderer_base<pixfmt_type> base_ren_type;
//--------------------------------------------------------------------
explicit renderer_mclip(pixfmt_type& pixf) :
m_ren(pixf),
m_curr_cb(0),
m_bounds(m_ren.xmin(), m_ren.ymin(), m_ren.xmax(), m_ren.ymax())
explicit renderer_mclip(pixfmt_type& pixf)
: m_ren(pixf)
, m_curr_cb(0)
, m_bounds(m_ren.xmin(), m_ren.ymin(), m_ren.xmax(), m_ren.ymax())
{}
void attach(pixfmt_type& pixf)
{
@ -110,18 +110,19 @@ namespace agg
if (cb.clip(rect_i(0, 0, width() - 1, height() - 1)))
{
m_clip.add(cb);
if(cb.x1 < m_bounds.x1) m_bounds.x1 = cb.x1;
if(cb.y1 < m_bounds.y1) m_bounds.y1 = cb.y1;
if(cb.x2 > m_bounds.x2) m_bounds.x2 = cb.x2;
if(cb.y2 > m_bounds.y2) m_bounds.y2 = cb.y2;
if (cb.x1 < m_bounds.x1)
m_bounds.x1 = cb.x1;
if (cb.y1 < m_bounds.y1)
m_bounds.y1 = cb.y1;
if (cb.x2 > m_bounds.x2)
m_bounds.x2 = cb.x2;
if (cb.y2 > m_bounds.y2)
m_bounds.y2 = cb.y2;
}
}
//--------------------------------------------------------------------
void clear(const color_type& c)
{
m_ren.clear(c);
}
void clear(const color_type& c) { m_ren.clear(c); }
//--------------------------------------------------------------------
void copy_pixel(int x, int y, const color_type& c)
@ -134,8 +135,7 @@ namespace agg
m_ren.ren().copy_pixel(x, y, c);
break;
}
}
while(next_clip_box());
} while (next_clip_box());
}
//--------------------------------------------------------------------
@ -149,8 +149,7 @@ namespace agg
m_ren.ren().blend_pixel(x, y, c, cover);
break;
}
}
while(next_clip_box());
} while (next_clip_box());
}
//--------------------------------------------------------------------
@ -163,8 +162,7 @@ namespace agg
{
return m_ren.ren().pixel(x, y);
}
}
while(next_clip_box());
} while (next_clip_box());
return color_type::no_color();
}
@ -175,8 +173,7 @@ namespace agg
do
{
m_ren.copy_hline(x1, y, x2, c);
}
while(next_clip_box());
} while (next_clip_box());
}
//--------------------------------------------------------------------
@ -186,32 +183,27 @@ namespace agg
do
{
m_ren.copy_vline(x, y1, y2, c);
}
while(next_clip_box());
} while (next_clip_box());
}
//--------------------------------------------------------------------
void blend_hline(int x1, int y, int x2,
const color_type& c, cover_type cover)
void blend_hline(int x1, int y, int x2, const color_type& c, cover_type cover)
{
first_clip_box();
do
{
m_ren.blend_hline(x1, y, x2, c, cover);
}
while(next_clip_box());
} while (next_clip_box());
}
//--------------------------------------------------------------------
void blend_vline(int x, int y1, int y2,
const color_type& c, cover_type cover)
void blend_vline(int x, int y1, int y2, const color_type& c, cover_type cover)
{
first_clip_box();
do
{
m_ren.blend_vline(x, y1, y2, c, cover);
}
while(next_clip_box());
} while (next_clip_box());
}
//--------------------------------------------------------------------
@ -221,46 +213,38 @@ namespace agg
do
{
m_ren.copy_bar(x1, y1, x2, y2, c);
}
while(next_clip_box());
} while (next_clip_box());
}
//--------------------------------------------------------------------
void blend_bar(int x1, int y1, int x2, int y2,
const color_type& c, cover_type cover)
void blend_bar(int x1, int y1, int x2, int y2, const color_type& c, cover_type cover)
{
first_clip_box();
do
{
m_ren.blend_bar(x1, y1, x2, y2, c, cover);
}
while(next_clip_box());
} while (next_clip_box());
}
//--------------------------------------------------------------------
void blend_solid_hspan(int x, int y, int len,
const color_type& c, const cover_type* covers)
void blend_solid_hspan(int x, int y, int len, const color_type& c, const cover_type* covers)
{
first_clip_box();
do
{
m_ren.blend_solid_hspan(x, y, len, c, covers);
}
while(next_clip_box());
} while (next_clip_box());
}
//--------------------------------------------------------------------
void blend_solid_vspan(int x, int y, int len,
const color_type& c, const cover_type* covers)
void blend_solid_vspan(int x, int y, int len, const color_type& c, const cover_type* covers)
{
first_clip_box();
do
{
m_ren.blend_solid_vspan(x, y, len, c, covers);
} while (next_clip_box());
}
while(next_clip_box());
}
//--------------------------------------------------------------------
void copy_color_hspan(int x, int y, int len, const color_type* colors)
@ -269,12 +253,13 @@ namespace agg
do
{
m_ren.copy_color_hspan(x, y, len, colors);
}
while(next_clip_box());
} while (next_clip_box());
}
//--------------------------------------------------------------------
void blend_color_hspan(int x, int y, int len,
void blend_color_hspan(int x,
int y,
int len,
const color_type* colors,
const cover_type* covers,
cover_type cover = cover_full)
@ -283,12 +268,13 @@ namespace agg
do
{
m_ren.blend_color_hspan(x, y, len, colors, covers, cover);
}
while(next_clip_box());
} while (next_clip_box());
}
//--------------------------------------------------------------------
void blend_color_vspan(int x, int y, int len,
void blend_color_vspan(int x,
int y,
int len,
const color_type* colors,
const cover_type* covers,
cover_type cover = cover_full)
@ -297,22 +283,17 @@ namespace agg
do
{
m_ren.blend_color_vspan(x, y, len, colors, covers, cover);
}
while(next_clip_box());
} while (next_clip_box());
}
//--------------------------------------------------------------------
void copy_from(const rendering_buffer& from,
const rect_i* rc=0,
int x_to=0,
int y_to=0)
void copy_from(const rendering_buffer& from, const rect_i* rc = 0, int x_to = 0, int y_to = 0)
{
first_clip_box();
do
{
m_ren.copy_from(from, rc, x_to, y_to);
}
while(next_clip_box());
} while (next_clip_box());
}
//--------------------------------------------------------------------
@ -327,15 +308,12 @@ namespace agg
do
{
m_ren.blend_from(src, rect_src_ptr, dx, dy, cover);
} while (next_clip_box());
}
while(next_clip_box());
}
private:
renderer_mclip(const renderer_mclip<PixelFormat>&);
const renderer_mclip<PixelFormat>&
operator = (const renderer_mclip<PixelFormat>&);
const renderer_mclip<PixelFormat>& operator=(const renderer_mclip<PixelFormat>&);
base_ren_type m_ren;
pod_bvector<rect_i, 4> m_clip;
@ -343,7 +321,6 @@ namespace agg
rect_i m_bounds;
};
}
} // namespace agg
#endif

637
deps/agg/include/agg_renderer_outline_aa.h vendored
View file

File diff suppressed because it is too large Load diff

394
deps/agg/include/agg_renderer_outline_image.h vendored
View file

@ -22,21 +22,19 @@
#include "agg_rendering_buffer.h"
#include "agg_clip_liang_barsky.h"
namespace agg
{
namespace agg {
//========================================================line_image_scale
template<class Source> class line_image_scale
template<class Source>
class line_image_scale
{
public:
typedef typename Source::color_type color_type;
line_image_scale(const Source& src, double height) :
m_source(src),
m_height(height),
m_scale(src.height() / height)
{
}
line_image_scale(const Source& src, double height)
: m_source(src)
, m_height(height)
, m_scale(src.height() / height)
{}
double width() const { return m_source.width(); }
double height() const { return m_height; }
@ -61,49 +59,48 @@ namespace agg
double m_scale;
};
//======================================================line_image_pattern
template<class Filter> class line_image_pattern
template<class Filter>
class line_image_pattern
{
public:
typedef Filter filter_type;
typedef typename filter_type::color_type color_type;
//--------------------------------------------------------------------
line_image_pattern(const Filter& filter) :
m_filter(&filter),
m_dilation(filter.dilation() + 1),
m_dilation_hr(m_dilation * line_subpixel_scale),
m_data(),
m_width(0),
m_height(0),
m_width_hr(0),
m_half_height_hr(0),
m_offset_y_hr(0)
{
}
line_image_pattern(const Filter& filter)
: m_filter(&filter)
, m_dilation(filter.dilation() + 1)
, m_dilation_hr(m_dilation * line_subpixel_scale)
, m_data()
, m_width(0)
, m_height(0)
, m_width_hr(0)
, m_half_height_hr(0)
, m_offset_y_hr(0)
{}
// Create
//--------------------------------------------------------------------
template<class Source>
line_image_pattern(const Filter& filter, const Source& src) :
m_filter(&filter),
m_dilation(filter.dilation() + 1),
m_dilation_hr(m_dilation * line_subpixel_scale),
m_data(),
m_width(0),
m_height(0),
m_width_hr(0),
m_half_height_hr(0),
m_offset_y_hr(0)
line_image_pattern(const Filter& filter, const Source& src)
: m_filter(&filter)
, m_dilation(filter.dilation() + 1)
, m_dilation_hr(m_dilation * line_subpixel_scale)
, m_data()
, m_width(0)
, m_height(0)
, m_width_hr(0)
, m_half_height_hr(0)
, m_offset_y_hr(0)
{
create(src);
}
// Create
//--------------------------------------------------------------------
template<class Source> void create(const Source& src)
template<class Source>
void create(const Source& src)
{
m_height = uceil(src.height());
m_width = uceil(src.width());
@ -114,9 +111,7 @@ namespace agg
m_data.resize((m_width + m_dilation * 2) * (m_height + m_dilation * 2));
m_buf.attach(&m_data[0], m_width + m_dilation * 2,
m_height + m_dilation * 2,
m_width + m_dilation * 2);
m_buf.attach(&m_data[0], m_width + m_dilation * 2, m_height + m_dilation * 2, m_width + m_dilation * 2);
unsigned x, y;
color_type* d1;
color_type* d2;
@ -170,10 +165,7 @@ namespace agg
//--------------------------------------------------------------------
void pixel(color_type* p, int x, int y) const
{
m_filter->pixel_high_res(m_buf.rows(),
p,
x % m_width_hr + m_dilation_hr,
y + m_offset_y_hr);
m_filter->pixel_high_res(m_buf.rows(), p, x % m_width_hr + m_dilation_hr, y + m_offset_y_hr);
}
//--------------------------------------------------------------------
@ -181,8 +173,7 @@ namespace agg
private:
line_image_pattern(const line_image_pattern<filter_type>&);
const line_image_pattern<filter_type>&
operator = (const line_image_pattern<filter_type>&);
const line_image_pattern<filter_type>& operator=(const line_image_pattern<filter_type>&);
protected:
row_ptr_cache<color_type> m_buf;
@ -197,14 +188,9 @@ namespace agg
int m_offset_y_hr;
};
//=================================================line_image_pattern_pow2
template<class Filter> class line_image_pattern_pow2 :
public line_image_pattern<Filter>
template<class Filter>
class line_image_pattern_pow2 : public line_image_pattern<Filter>
{
public:
typedef Filter filter_type;
@ -212,19 +198,23 @@ namespace agg
typedef line_image_pattern<Filter> base_type;
//--------------------------------------------------------------------
line_image_pattern_pow2(const Filter& filter) :
line_image_pattern<Filter>(filter), m_mask(line_subpixel_mask) {}
line_image_pattern_pow2(const Filter& filter)
: line_image_pattern<Filter>(filter)
, m_mask(line_subpixel_mask)
{}
//--------------------------------------------------------------------
template<class Source>
line_image_pattern_pow2(const Filter& filter, const Source& src) :
line_image_pattern<Filter>(filter), m_mask(line_subpixel_mask)
line_image_pattern_pow2(const Filter& filter, const Source& src)
: line_image_pattern<Filter>(filter)
, m_mask(line_subpixel_mask)
{
create(src);
}
//--------------------------------------------------------------------
template<class Source> void create(const Source& src)
template<class Source>
void create(const Source& src)
{
line_image_pattern<Filter>::create(src);
m_mask = 1;
@ -241,47 +231,53 @@ namespace agg
//--------------------------------------------------------------------
void pixel(color_type* p, int x, int y) const
{
base_type::m_filter->pixel_high_res(
base_type::m_buf.rows(),
base_type::m_filter->pixel_high_res(base_type::m_buf.rows(),
p,
(x & m_mask) + base_type::m_dilation_hr,
y + base_type::m_offset_y_hr);
}
private:
unsigned m_mask;
};
//===================================================distance_interpolator4
class distance_interpolator4
{
public:
//---------------------------------------------------------------------
distance_interpolator4() {}
distance_interpolator4(int x1, int y1, int x2, int y2,
int sx, int sy, int ex, int ey,
int len, double scale, int x, int y) :
m_dx(x2 - x1),
m_dy(y2 - y1),
m_dx_start(line_mr(sx) - line_mr(x1)),
m_dy_start(line_mr(sy) - line_mr(y1)),
m_dx_end(line_mr(ex) - line_mr(x2)),
m_dy_end(line_mr(ey) - line_mr(y2)),
distance_interpolator4(int x1,
int y1,
int x2,
int y2,
int sx,
int sy,
int ex,
int ey,
int len,
double scale,
int x,
int y)
: m_dx(x2 - x1)
, m_dy(y2 - y1)
, m_dx_start(line_mr(sx) - line_mr(x1))
, m_dy_start(line_mr(sy) - line_mr(y1))
, m_dx_end(line_mr(ex) - line_mr(x2))
, m_dy_end(line_mr(ey) - line_mr(y2))
,
m_dist(iround(double(x + line_subpixel_scale / 2 - x2) * double(m_dy) -
double(y + line_subpixel_scale/2 - y2) * double(m_dx))),
double(y + line_subpixel_scale / 2 - y2) * double(m_dx)))
,
m_dist_start((line_mr(x + line_subpixel_scale / 2) - line_mr(sx)) * m_dy_start -
(line_mr(y + line_subpixel_scale/2) - line_mr(sy)) * m_dx_start),
(line_mr(y + line_subpixel_scale / 2) - line_mr(sy)) * m_dx_start)
,
m_dist_end((line_mr(x + line_subpixel_scale / 2) - line_mr(ex)) * m_dy_end -
(line_mr(y + line_subpixel_scale/2) - line_mr(ey)) * m_dx_end),
m_len(uround(len / scale))
(line_mr(y + line_subpixel_scale / 2) - line_mr(ey)) * m_dx_end)
, m_len(uround(len / scale))
{
double d = len * scale;
int dx = iround(((x2 - x1) * line_subpixel_scale) / d);
@ -463,50 +459,57 @@ namespace agg
int m_len;
};
//==================================================line_interpolator_image
template<class Renderer> class line_interpolator_image
template<class Renderer>
class line_interpolator_image
{
public:
typedef Renderer renderer_type;
typedef typename Renderer::color_type color_type;
//---------------------------------------------------------------------
enum max_half_width_e
{
max_half_width = 64
};
enum max_half_width_e { max_half_width = 64 };
//---------------------------------------------------------------------
line_interpolator_image(renderer_type& ren, const line_parameters& lp,
int sx, int sy, int ex, int ey,
line_interpolator_image(renderer_type& ren,
const line_parameters& lp,
int sx,
int sy,
int ex,
int ey,
int pattern_start,
double scale_x) :
m_lp(lp),
m_li(lp.vertical ? line_dbl_hr(lp.x2 - lp.x1) :
line_dbl_hr(lp.y2 - lp.y1),
lp.vertical ? lp.dy : lp.dx + 1),
m_di(lp.x1, lp.y1, lp.x2, lp.y2, sx, sy, ex, ey, lp.len, scale_x,
lp.x1 & ~line_subpixel_mask, lp.y1 & ~line_subpixel_mask),
m_ren(ren),
m_x(lp.x1 >> line_subpixel_shift),
m_y(lp.y1 >> line_subpixel_shift),
m_old_x(m_x),
m_old_y(m_y),
m_count((lp.vertical ? std::abs((lp.y2 >> line_subpixel_shift) - m_y) :
std::abs((lp.x2 >> line_subpixel_shift) - m_x))),
m_width(ren.subpixel_width()),
double scale_x)
: m_lp(lp)
, m_li(lp.vertical ? line_dbl_hr(lp.x2 - lp.x1) : line_dbl_hr(lp.y2 - lp.y1), lp.vertical ? lp.dy : lp.dx + 1)
, m_di(lp.x1,
lp.y1,
lp.x2,
lp.y2,
sx,
sy,
ex,
ey,
lp.len,
scale_x,
lp.x1 & ~line_subpixel_mask,
lp.y1 & ~line_subpixel_mask)
, m_ren(ren)
, m_x(lp.x1 >> line_subpixel_shift)
, m_y(lp.y1 >> line_subpixel_shift)
, m_old_x(m_x)
, m_old_y(m_y)
, m_count((lp.vertical ? std::abs((lp.y2 >> line_subpixel_shift) - m_y)
: std::abs((lp.x2 >> line_subpixel_shift) - m_x)))
, m_width(ren.subpixel_width())
,
// m_max_extent(m_width >> (line_subpixel_shift - 2)),
m_max_extent((m_width + line_subpixel_scale) >> line_subpixel_shift),
m_start(pattern_start + (m_max_extent + 2) * ren.pattern_width()),
m_step(0)
m_max_extent((m_width + line_subpixel_scale) >> line_subpixel_shift)
, m_start(pattern_start + (m_max_extent + 2) * ren.pattern_width())
, m_step(0)
{
agg::dda2_line_interpolator li(0, lp.vertical ?
(lp.dy * agg::line_subpixel_scale) :
(lp.dx * agg::line_subpixel_scale),
agg::dda2_line_interpolator li(0,
lp.vertical ? (lp.dy * agg::line_subpixel_scale)
: (lp.dx * agg::line_subpixel_scale),
lp.len);
unsigned i;
@ -514,7 +517,8 @@ namespace agg
for (i = 0; i < max_half_width; ++i)
{
m_dist_pos[i] = li.y();
if(m_dist_pos[i] >= stop) break;
if (m_dist_pos[i] >= stop)
break;
++li;
}
m_dist_pos[i] = 0x7FFF0000;
@ -531,29 +535,33 @@ namespace agg
m_y -= lp.inc;
m_x = (m_lp.x1 + m_li.y()) >> line_subpixel_shift;
if(lp.inc > 0) m_di.dec_y(m_x - m_old_x);
else m_di.inc_y(m_x - m_old_x);
if (lp.inc > 0)
m_di.dec_y(m_x - m_old_x);
else
m_di.inc_y(m_x - m_old_x);
m_old_x = m_x;
dist1_start = dist2_start = m_di.dist_start();
int dx = 0;
if(dist1_start < 0) ++npix;
if (dist1_start < 0)
++npix;
do
{
dist1_start += m_di.dy_start();
dist2_start -= m_di.dy_start();
if(dist1_start < 0) ++npix;
if(dist2_start < 0) ++npix;
if (dist1_start < 0)
++npix;
if (dist2_start < 0)
++npix;
++dx;
}
while(m_dist_pos[dx] <= m_width);
if(npix == 0) break;
} while (m_dist_pos[dx] <= m_width);
if (npix == 0)
break;
npix = 0;
}
while(--m_step >= -m_max_extent);
} while (--m_step >= -m_max_extent);
}
else
{
@ -564,29 +572,33 @@ namespace agg
m_x -= lp.inc;
m_y = (m_lp.y1 + m_li.y()) >> line_subpixel_shift;
if(lp.inc > 0) m_di.dec_x(m_y - m_old_y);
else m_di.inc_x(m_y - m_old_y);
if (lp.inc > 0)
m_di.dec_x(m_y - m_old_y);
else
m_di.inc_x(m_y - m_old_y);
m_old_y = m_y;
dist1_start = dist2_start = m_di.dist_start();
int dy = 0;
if(dist1_start < 0) ++npix;
if (dist1_start < 0)
++npix;
do
{
dist1_start -= m_di.dx_start();
dist2_start += m_di.dx_start();
if(dist1_start < 0) ++npix;
if(dist2_start < 0) ++npix;
if (dist1_start < 0)
++npix;
if (dist2_start < 0)
++npix;
++dy;
}
while(m_dist_pos[dy] <= m_width);
if(npix == 0) break;
} while (m_dist_pos[dy] <= m_width);
if (npix == 0)
break;
npix = 0;
}
while(--m_step >= -m_max_extent);
} while (--m_step >= -m_max_extent);
}
m_li.adjust_forward();
m_step -= m_max_extent;
@ -599,15 +611,18 @@ namespace agg
m_x += m_lp.inc;
m_y = (m_lp.y1 + m_li.y()) >> line_subpixel_shift;
if(m_lp.inc > 0) m_di.inc_x(m_y - m_old_y);
else m_di.dec_x(m_y - m_old_y);
if (m_lp.inc > 0)
m_di.inc_x(m_y - m_old_y);
else
m_di.dec_x(m_y - m_old_y);
m_old_y = m_y;
int s1 = m_di.dist() / m_lp.len;
int s2 = -s1;
if(m_lp.inc < 0) s1 = -s1;
if (m_lp.inc < 0)
s1 = -s1;
int dist_start;
int dist_pict;
@ -642,7 +657,8 @@ namespace agg
p1->clear();
if (dist_end > 0 && dist_start <= 0)
{
if(m_lp.inc > 0) dist = -dist;
if (m_lp.inc > 0)
dist = -dist;
m_ren.pixel(p1, dist_pict, s2 - dist);
++npix;
}
@ -663,21 +679,17 @@ namespace agg
p0->clear();
if (dist_end > 0 && dist_start <= 0)
{
if(m_lp.inc > 0) dist = -dist;
if (m_lp.inc > 0)
dist = -dist;
m_ren.pixel(p0, dist_pict, s2 + dist);
++npix;
}
++dy;
}
m_ren.blend_color_vspan(m_x,
m_y - dy + 1,
unsigned(p1 - p0),
p0);
m_ren.blend_color_vspan(m_x, m_y - dy + 1, unsigned(p1 - p0), p0);
return npix && ++m_step < m_count;
}
//---------------------------------------------------------------------
bool step_ver()
{
@ -685,15 +697,18 @@ namespace agg
m_y += m_lp.inc;
m_x = (m_lp.x1 + m_li.y()) >> line_subpixel_shift;
if(m_lp.inc > 0) m_di.inc_y(m_x - m_old_x);
else m_di.dec_y(m_x - m_old_x);
if (m_lp.inc > 0)
m_di.inc_y(m_x - m_old_x);
else
m_di.dec_y(m_x - m_old_x);
m_old_x = m_x;
int s1 = m_di.dist() / m_lp.len;
int s2 = -s1;
if(m_lp.inc > 0) s1 = -s1;
if (m_lp.inc > 0)
s1 = -s1;
int dist_start;
int dist_pict;
@ -728,7 +743,8 @@ namespace agg
p1->clear();
if (dist_end > 0 && dist_start <= 0)
{
if(m_lp.inc > 0) dist = -dist;
if (m_lp.inc > 0)
dist = -dist;
m_ren.pixel(p1, dist_pict, s2 + dist);
++npix;
}
@ -749,20 +765,17 @@ namespace agg
p0->clear();
if (dist_end > 0 && dist_start <= 0)
{
if(m_lp.inc > 0) dist = -dist;
if (m_lp.inc > 0)
dist = -dist;
m_ren.pixel(p0, dist_pict, s2 - dist);
++npix;
}
++dx;
}
m_ren.blend_color_hspan(m_x - dx + 1,
m_y,
unsigned(p1 - p0),
p0);
m_ren.blend_color_hspan(m_x - dx + 1, m_y, unsigned(p1 - p0), p0);
return npix && ++m_step < m_count;
}
//---------------------------------------------------------------------
int pattern_end() const { return m_start + m_di.len(); }
@ -773,8 +786,7 @@ namespace agg
private:
line_interpolator_image(const line_interpolator_image<Renderer>&);
const line_interpolator_image<Renderer>&
operator = (const line_interpolator_image<Renderer>&);
const line_interpolator_image<Renderer>& operator=(const line_interpolator_image<Renderer>&);
protected:
const line_parameters& m_lp;
@ -795,13 +807,6 @@ namespace agg
color_type m_colors[max_half_width * 2 + 4];
};
//===================================================renderer_outline_image
template<class BaseRenderer, class ImagePattern>
class renderer_outline_image
@ -813,15 +818,14 @@ namespace agg
typedef typename base_ren_type::color_type color_type;
typedef ImagePattern pattern_type;
//---------------------------------------------------------------------
renderer_outline_image(base_ren_type& ren, const pattern_type& patt) :
m_ren(&ren),
m_pattern(&patt),
m_start(0),
m_scale_x(1.0),
m_clip_box(0,0,0,0),
m_clipping(false)
renderer_outline_image(base_ren_type& ren, const pattern_type& patt)
: m_ren(&ren)
, m_pattern(&patt)
, m_start(0)
, m_scale_x(1.0)
, m_clip_box(0, 0, 0, 0)
, m_clipping(false)
{}
void attach(base_ren_type& ren) { m_ren = &ren; }
@ -854,10 +858,7 @@ namespace agg
double width() const { return double(subpixel_width()) / line_subpixel_scale; }
//-------------------------------------------------------------------------
void pixel(color_type* p, int x, int y) const
{
m_pattern->pixel(p, x, y);
}
void pixel(color_type* p, int x, int y) const { m_pattern->pixel(p, x, y); }
//-------------------------------------------------------------------------
void blend_color_hspan(int x, int y, unsigned len, const color_type* colors)
@ -877,32 +878,22 @@ namespace agg
//-------------------------------------------------------------------------
template<class Cmp>
void semidot(Cmp, int, int, int, int)
{
}
{}
//-------------------------------------------------------------------------
void pie(int, int, int, int, int, int)
{
}
void pie(int, int, int, int, int, int) {}
//-------------------------------------------------------------------------
void line0(const line_parameters&)
{
}
void line0(const line_parameters&) {}
//-------------------------------------------------------------------------
void line1(const line_parameters&, int, int)
{
}
void line1(const line_parameters&, int, int) {}
//-------------------------------------------------------------------------
void line2(const line_parameters&, int, int)
{
}
void line2(const line_parameters&, int, int) {}
//-------------------------------------------------------------------------
void line3_no_clip(const line_parameters& lp,
int sx, int sy, int ex, int ey)
void line3_no_clip(const line_parameters& lp, int sx, int sy, int ex, int ey)
{
if (lp.len > line_max_length)
{
@ -917,24 +908,22 @@ namespace agg
fix_degenerate_bisectrix_start(lp, &sx, &sy);
fix_degenerate_bisectrix_end(lp, &ex, &ey);
line_interpolator_image<self_type> li(*this, lp,
sx, sy,
ex, ey,
m_start, m_scale_x);
line_interpolator_image<self_type> li(*this, lp, sx, sy, ex, ey, m_start, m_scale_x);
if (li.vertical())
{
while(li.step_ver()) ;
while (li.step_ver())
;
}
else
{
while(li.step_hor()) ;
while (li.step_hor())
;
}
m_start += uround(lp.len / m_scale_x);
}
//-------------------------------------------------------------------------
void line3(const line_parameters& lp,
int sx, int sy, int ex, int ey)
void line3(const line_parameters& lp, int sx, int sy, int ex, int ey)
{
if (m_clipping)
{
@ -948,8 +937,7 @@ namespace agg
{
if (flags)
{
line_parameters lp2(x1, y1, x2, y2,
uround(calc_distance(x1, y1, x2, y2)));
line_parameters lp2(x1, y1, x2, y2, uround(calc_distance(x1, y1, x2, y2)));
if (flags & 1)
{
m_start += uround(calc_distance(lp.x1, lp.y1, x1, y1) / m_scale_x);
@ -1001,12 +989,6 @@ namespace agg
bool m_clipping;
};
}
} // namespace agg
#endif

48
deps/agg/include/agg_renderer_primitives.h vendored
View file

@ -25,30 +25,27 @@
#include "agg_dda_line.h"
#include "agg_ellipse_bresenham.h"
namespace agg
{
namespace agg {
//-----------------------------------------------------renderer_primitives
template<class BaseRenderer> class renderer_primitives
template<class BaseRenderer>
class renderer_primitives
{
public:
typedef BaseRenderer base_ren_type;
typedef typename base_ren_type::color_type color_type;
//--------------------------------------------------------------------
explicit renderer_primitives(base_ren_type& ren) :
m_ren(&ren),
m_fill_color(),
m_line_color(),
m_curr_x(0),
m_curr_y(0)
explicit renderer_primitives(base_ren_type& ren)
: m_ren(&ren)
, m_fill_color()
, m_line_color()
, m_curr_x(0)
, m_curr_y(0)
{}
void attach(base_ren_type& ren) { m_ren = &ren; }
//--------------------------------------------------------------------
static int coord(double c)
{
return iround(c * line_bresenham_interpolator::subpixel_scale);
}
static int coord(double c) { return iround(c * line_bresenham_interpolator::subpixel_scale); }
//--------------------------------------------------------------------
void fill_color(const color_type& c) { m_fill_color = c; }
@ -66,10 +63,7 @@ namespace agg
}
//--------------------------------------------------------------------
void solid_rectangle(int x1, int y1, int x2, int y2)
{
m_ren->blend_bar(x1, y1, x2, y2, m_fill_color, cover_full);
}
void solid_rectangle(int x1, int y1, int x2, int y2) { m_ren->blend_bar(x1, y1, x2, y2, m_fill_color, cover_full); }
//--------------------------------------------------------------------
void outlined_rectangle(int x1, int y1, int x2, int y2)
@ -93,8 +87,7 @@ namespace agg
m_ren->blend_pixel(x - dx, y - dy, m_line_color, cover_full);
m_ren->blend_pixel(x - dx, y + dy, m_line_color, cover_full);
++ei;
}
while(dy < 0);
} while (dy < 0);
}
//--------------------------------------------------------------------
@ -119,8 +112,7 @@ namespace agg
dx0 = dx;
dy0 = dy;
++ei;
}
while(dy < 0);
} while (dy < 0);
m_ren->blend_hline(x - dx0, y + dy0, x + dx0, m_fill_color, cover_full);
}
@ -147,8 +139,7 @@ namespace agg
m_ren->blend_hline(x - dx + 1, y - dy, x + dx - 1, m_fill_color, cover_full);
}
++ei;
}
while(dy < 0);
} while (dy < 0);
}
//--------------------------------------------------------------------
@ -166,7 +157,8 @@ namespace agg
return;
}
if(last) ++len;
if (last)
++len;
if (li.is_ver())
{
@ -174,8 +166,7 @@ namespace agg
{
m_ren->blend_pixel(li.x2(), li.y1(), m_line_color, cover_full);
li.vstep();
}
while(--len);
} while (--len);
}
else
{
@ -183,8 +174,7 @@ namespace agg
{
m_ren->blend_pixel(li.x1(), li.y2(), m_line_color, cover_full);
li.hstep();
}
while(--len);
} while (--len);
}
}
@ -219,6 +209,6 @@ namespace agg
int m_curr_y;
};
}
} // namespace agg
#endif

84
deps/agg/include/agg_renderer_raster_text.h vendored
View file

@ -18,8 +18,7 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//==============================================renderer_raster_htext_solid
template<class BaseRenderer, class GlyphGenerator>
@ -31,9 +30,9 @@ namespace agg
typedef typename glyph_gen_type::glyph_rect glyph_rect;
typedef typename ren_type::color_type color_type;
renderer_raster_htext_solid(ren_type& ren, glyph_gen_type& glyph) :
m_ren(&ren),
m_glyph(&glyph)
renderer_raster_htext_solid(ren_type& ren, glyph_gen_type& glyph)
: m_ren(&ren)
, m_glyph(&glyph)
{}
void attach(ren_type& ren) { m_ren = &ren; }
@ -56,18 +55,14 @@ namespace agg
{
for (i = r.y1; i <= r.y2; i++)
{
m_ren->blend_solid_hspan(r.x1, i, (r.x2 - r.x1 + 1),
m_color,
m_glyph->span(r.y2 - i));
m_ren->blend_solid_hspan(r.x1, i, (r.x2 - r.x1 + 1), m_color, m_glyph->span(r.y2 - i));
}
}
else
{
for (i = r.y1; i <= r.y2; i++)
{
m_ren->blend_solid_hspan(r.x1, i, (r.x2 - r.x1 + 1),
m_color,
m_glyph->span(i - r.y1));
m_ren->blend_solid_hspan(r.x1, i, (r.x2 - r.x1 + 1), m_color, m_glyph->span(i - r.y1));
}
}
}
@ -83,8 +78,6 @@ namespace agg
color_type m_color;
};
//=============================================renderer_raster_vtext_solid
template<class BaseRenderer, class GlyphGenerator>
class renderer_raster_vtext_solid
@ -95,11 +88,10 @@ namespace agg
typedef typename glyph_gen_type::glyph_rect glyph_rect;
typedef typename ren_type::color_type color_type;
renderer_raster_vtext_solid(ren_type& ren, glyph_gen_type& glyph) :
m_ren(&ren),
m_glyph(&glyph)
{
}
renderer_raster_vtext_solid(ren_type& ren, glyph_gen_type& glyph)
: m_ren(&ren)
, m_glyph(&glyph)
{}
//--------------------------------------------------------------------
void color(const color_type& c) { m_color = c; }
@ -120,18 +112,14 @@ namespace agg
{
for (i = r.y1; i <= r.y2; i++)
{
m_ren->blend_solid_vspan(i, r.x1, (r.x2 - r.x1 + 1),
m_color,
m_glyph->span(i - r.y1));
m_ren->blend_solid_vspan(i, r.x1, (r.x2 - r.x1 + 1), m_color, m_glyph->span(i - r.y1));
}
}
else
{
for (i = r.y1; i <= r.y2; i++)
{
m_ren->blend_solid_vspan(i, r.x1, (r.x2 - r.x1 + 1),
m_color,
m_glyph->span(r.y2 - i));
m_ren->blend_solid_vspan(i, r.x1, (r.x2 - r.x1 + 1), m_color, m_glyph->span(r.y2 - i));
}
}
}
@ -147,11 +135,6 @@ namespace agg
color_type m_color;
};
//===================================================renderer_raster_htext
template<class ScanlineRenderer, class GlyphGenerator>
class renderer_raster_htext
@ -174,18 +157,19 @@ namespace agg
const cover_type* covers;
const_span() {}
const_span(int x_, unsigned len_, const cover_type* covers_) :
x(x_), len(len_), covers(covers_)
const_span(int x_, unsigned len_, const cover_type* covers_)
: x(x_)
, len(len_)
, covers(covers_)
{}
};
typedef const const_span* const_iterator;
//----------------------------------------------------------------
scanline_single_span(int x, int y, unsigned len,
const cover_type* covers) :
m_y(y),
m_span(x, len, covers)
scanline_single_span(int x, int y, unsigned len, const cover_type* covers)
: m_y(y)
, m_span(x, len, covers)
{}
//----------------------------------------------------------------
@ -199,15 +183,11 @@ namespace agg
const_span m_span;
};
//--------------------------------------------------------------------
renderer_raster_htext(ren_type& ren, glyph_gen_type& glyph) :
m_ren(&ren),
m_glyph(&glyph)
{
}
renderer_raster_htext(ren_type& ren, glyph_gen_type& glyph)
: m_ren(&ren)
, m_glyph(&glyph)
{}
//--------------------------------------------------------------------
template<class CharT>
@ -225,22 +205,14 @@ namespace agg
{
for (i = r.y1; i <= r.y2; i++)
{
m_ren->render(
scanline_single_span(r.x1,
i,
(r.x2 - r.x1 + 1),
m_glyph->span(r.y2 - i)));
m_ren->render(scanline_single_span(r.x1, i, (r.x2 - r.x1 + 1), m_glyph->span(r.y2 - i)));
}
}
else
{
for (i = r.y1; i <= r.y2; i++)
{
m_ren->render(
scanline_single_span(r.x1,
i,
(r.x2 - r.x1 + 1),
m_glyph->span(i - r.y1)));
m_ren->render(scanline_single_span(r.x1, i, (r.x2 - r.x1 + 1), m_glyph->span(i - r.y1)));
}
}
}
@ -255,10 +227,6 @@ namespace agg
glyph_gen_type* m_glyph;
};
}
} // namespace agg
#endif

350
deps/agg/include/agg_renderer_scanline.h vendored
View file

@ -19,14 +19,11 @@
#include "agg_basics.h"
#include "agg_renderer_base.h"
namespace agg
{
namespace agg {
//================================================render_scanline_aa_solid
template<class Scanline, class BaseRenderer, class ColorT>
void render_scanline_aa_solid(const Scanline& sl,
BaseRenderer& ren,
const ColorT& color)
void render_scanline_aa_solid(const Scanline& sl, BaseRenderer& ren, const ColorT& color)
{
int y = sl.y();
unsigned num_spans = sl.num_spans();
@ -37,26 +34,21 @@ namespace agg
int x = span->x;
if (span->len > 0)
{
ren.blend_solid_hspan(x, y, (unsigned)span->len,
color,
span->covers);
ren.blend_solid_hspan(x, y, (unsigned)span->len, color, span->covers);
}
else
{
ren.blend_hline(x, y, (unsigned)(x - span->len - 1),
color,
*(span->covers));
ren.blend_hline(x, y, (unsigned)(x - span->len - 1), color, *(span->covers));
}
if(--num_spans == 0) break;
if (--num_spans == 0)
break;
++span;
}
}
//===============================================render_scanlines_aa_solid
template<class Rasterizer, class Scanline,
class BaseRenderer, class ColorT>
void render_scanlines_aa_solid(Rasterizer& ras, Scanline& sl,
BaseRenderer& ren, const ColorT& color)
template<class Rasterizer, class Scanline, class BaseRenderer, class ColorT>
void render_scanlines_aa_solid(Rasterizer& ras, Scanline& sl, BaseRenderer& ren, const ColorT& color)
{
if (ras.rewind_scanlines())
{
@ -76,19 +68,21 @@ namespace agg
}
//==============================================renderer_scanline_aa_solid
template<class BaseRenderer> class renderer_scanline_aa_solid
template<class BaseRenderer>
class renderer_scanline_aa_solid
{
public:
typedef BaseRenderer base_ren_type;
typedef typename base_ren_type::color_type color_type;
//--------------------------------------------------------------------
renderer_scanline_aa_solid() : m_ren(0) {}
explicit renderer_scanline_aa_solid(base_ren_type& ren) : m_ren(&ren) {}
void attach(base_ren_type& ren)
{
m_ren = &ren;
}
renderer_scanline_aa_solid()
: m_ren(0)
{}
explicit renderer_scanline_aa_solid(base_ren_type& ren)
: m_ren(&ren)
{}
void attach(base_ren_type& ren) { m_ren = &ren; }
//--------------------------------------------------------------------
void color(const color_type& c) { m_color = c; }
@ -98,7 +92,8 @@ namespace agg
void prepare() {}
//--------------------------------------------------------------------
template<class Scanline> void render(const Scanline& sl)
template<class Scanline>
void render(const Scanline& sl)
{
render_scanline_aa_solid(sl, *m_ren, m_color);
}
@ -108,12 +103,9 @@ namespace agg
color_type m_color;
};
//======================================================render_scanline_aa
template<class Scanline, class BaseRenderer,
class SpanAllocator, class SpanGenerator>
void render_scanline_aa(const Scanline& sl, BaseRenderer& ren,
SpanAllocator& alloc, SpanGenerator& span_gen)
template<class Scanline, class BaseRenderer, class SpanAllocator, class SpanGenerator>
void render_scanline_aa(const Scanline& sl, BaseRenderer& ren, SpanAllocator& alloc, SpanGenerator& span_gen)
{
int y = sl.y();
@ -125,22 +117,25 @@ namespace agg
int len = span->len;
const typename Scanline::cover_type* covers = span->covers;
if(len < 0) len = -len;
if (len < 0)
len = -len;
typename BaseRenderer::color_type* colors = alloc.allocate(len);
span_gen.generate(colors, x, y, len);
ren.blend_color_hspan(x, y, len, colors,
(span->len < 0) ? 0 : covers, *covers);
ren.blend_color_hspan(x, y, len, colors, (span->len < 0) ? 0 : covers, *covers);
if(--num_spans == 0) break;
if (--num_spans == 0)
break;
++span;
}
}
//======================================================render_scanline_aa_alpha
template<class Scanline, class BaseRenderer,
class SpanAllocator, class SpanGenerator>
void render_scanline_aa_alpha(const Scanline& sl, BaseRenderer& ren,
SpanAllocator& alloc, SpanGenerator& span_gen, unsigned alpha)
template<class Scanline, class BaseRenderer, class SpanAllocator, class SpanGenerator>
void render_scanline_aa_alpha(const Scanline& sl,
BaseRenderer& ren,
SpanAllocator& alloc,
SpanGenerator& span_gen,
unsigned alpha)
{
int y = sl.y();
@ -152,23 +147,25 @@ namespace agg
int len = span->len;
const typename Scanline::cover_type* covers = span->covers;
if(len < 0) len = -len;
if (len < 0)
len = -len;
typename BaseRenderer::color_type* colors = alloc.allocate(len);
span_gen.generate(colors, x, y, len);
ren.blend_color_hspan_alpha(x, y, len, colors, alpha,
(span->len < 0) ? 0 : covers, *covers);
ren.blend_color_hspan_alpha(x, y, len, colors, alpha, (span->len < 0) ? 0 : covers, *covers);
if(--num_spans == 0) break;
if (--num_spans == 0)
break;
++span;
}
}
//=====================================================render_scanlines_aa
template<class Rasterizer, class Scanline, class BaseRenderer,
class SpanAllocator, class SpanGenerator>
void render_scanlines_aa(Rasterizer& ras, Scanline& sl, BaseRenderer& ren,
SpanAllocator& alloc, SpanGenerator& span_gen)
template<class Rasterizer, class Scanline, class BaseRenderer, class SpanAllocator, class SpanGenerator>
void render_scanlines_aa(Rasterizer& ras,
Scanline& sl,
BaseRenderer& ren,
SpanAllocator& alloc,
SpanGenerator& span_gen)
{
if (ras.rewind_scanlines())
{
@ -191,17 +188,17 @@ namespace agg
typedef SpanGenerator span_gen_type;
//--------------------------------------------------------------------
renderer_scanline_aa() : m_ren(0), m_alloc(0), m_span_gen(0) {}
renderer_scanline_aa(base_ren_type& ren,
alloc_type& alloc,
span_gen_type& span_gen) :
m_ren(&ren),
m_alloc(&alloc),
m_span_gen(&span_gen)
renderer_scanline_aa()
: m_ren(0)
, m_alloc(0)
, m_span_gen(0)
{}
void attach(base_ren_type& ren,
alloc_type& alloc,
span_gen_type& span_gen)
renderer_scanline_aa(base_ren_type& ren, alloc_type& alloc, span_gen_type& span_gen)
: m_ren(&ren)
, m_alloc(&alloc)
, m_span_gen(&span_gen)
{}
void attach(base_ren_type& ren, alloc_type& alloc, span_gen_type& span_gen)
{
m_ren = &ren;
m_alloc = &alloc;
@ -212,7 +209,8 @@ namespace agg
void prepare() { m_span_gen->prepare(); }
//--------------------------------------------------------------------
template<class Scanline> void render(const Scanline& sl)
template<class Scanline>
void render(const Scanline& sl)
{
render_scanline_aa(sl, *m_ren, *m_alloc, *m_span_gen);
}
@ -223,7 +221,6 @@ namespace agg
span_gen_type* m_span_gen;
};
//====================================================renderer_scanline_aa
template<class BaseRenderer, class SpanAllocator, class SpanGenerator>
class renderer_scanline_aa_alpha
@ -234,19 +231,19 @@ namespace agg
typedef SpanGenerator span_gen_type;
//--------------------------------------------------------------------
renderer_scanline_aa_alpha() : m_ren(0), m_alloc(0), m_span_gen(0), m_alpha(1.0) {}
renderer_scanline_aa_alpha(base_ren_type& ren,
alloc_type& alloc,
span_gen_type& span_gen,
unsigned alpha) :
m_ren(&ren),
m_alloc(&alloc),
m_span_gen(&span_gen),
m_alpha(alpha)
renderer_scanline_aa_alpha()
: m_ren(0)
, m_alloc(0)
, m_span_gen(0)
, m_alpha(1.0)
{}
void attach(base_ren_type& ren,
alloc_type& alloc,
span_gen_type& span_gen)
renderer_scanline_aa_alpha(base_ren_type& ren, alloc_type& alloc, span_gen_type& span_gen, unsigned alpha)
: m_ren(&ren)
, m_alloc(&alloc)
, m_span_gen(&span_gen)
, m_alpha(alpha)
{}
void attach(base_ren_type& ren, alloc_type& alloc, span_gen_type& span_gen)
{
m_ren = &ren;
m_alloc = &alloc;
@ -257,7 +254,8 @@ namespace agg
void prepare() { m_span_gen->prepare(); }
//--------------------------------------------------------------------
template<class Scanline> void render(const Scanline& sl)
template<class Scanline>
void render(const Scanline& sl)
{
render_scanline_aa_alpha(sl, *m_ren, *m_alloc, *m_span_gen, m_alpha);
}
@ -269,34 +267,24 @@ namespace agg
unsigned m_alpha;
};
//===============================================render_scanline_bin_solid
template<class Scanline, class BaseRenderer, class ColorT>
void render_scanline_bin_solid(const Scanline& sl,
BaseRenderer& ren,
const ColorT& color)
void render_scanline_bin_solid(const Scanline& sl, BaseRenderer& ren, const ColorT& color)
{
unsigned num_spans = sl.num_spans();
typename Scanline::const_iterator span = sl.begin();
for (;;)
{
ren.blend_hline(span->x,
sl.y(),
span->x - 1 + ((span->len < 0) ?
-span->len :
span->len),
color,
cover_full);
if(--num_spans == 0) break;
ren.blend_hline(span->x, sl.y(), span->x - 1 + ((span->len < 0) ? -span->len : span->len), color, cover_full);
if (--num_spans == 0)
break;
++span;
}
}
//==============================================render_scanlines_bin_solid
template<class Rasterizer, class Scanline,
class BaseRenderer, class ColorT>
void render_scanlines_bin_solid(Rasterizer& ras, Scanline& sl,
BaseRenderer& ren, const ColorT& color)
template<class Rasterizer, class Scanline, class BaseRenderer, class ColorT>
void render_scanlines_bin_solid(Rasterizer& ras, Scanline& sl, BaseRenderer& ren, const ColorT& color)
{
if (ras.rewind_scanlines())
{
@ -322,12 +310,11 @@ namespace agg
{
ren.blend_hline(span->x,
sl.y(),
span->x - 1 + ((span->len < 0) ?
-span->len :
span->len),
span->x - 1 + ((span->len < 0) ? -span->len : span->len),
ren_color,
cover_full);
if(--num_spans == 0) break;
if (--num_spans == 0)
break;
++span;
}
}
@ -335,19 +322,21 @@ namespace agg
}
//=============================================renderer_scanline_bin_solid
template<class BaseRenderer> class renderer_scanline_bin_solid
template<class BaseRenderer>
class renderer_scanline_bin_solid
{
public:
typedef BaseRenderer base_ren_type;
typedef typename base_ren_type::color_type color_type;
//--------------------------------------------------------------------
renderer_scanline_bin_solid() : m_ren(0) {}
explicit renderer_scanline_bin_solid(base_ren_type& ren) : m_ren(&ren) {}
void attach(base_ren_type& ren)
{
m_ren = &ren;
}
renderer_scanline_bin_solid()
: m_ren(0)
{}
explicit renderer_scanline_bin_solid(base_ren_type& ren)
: m_ren(&ren)
{}
void attach(base_ren_type& ren) { m_ren = &ren; }
//--------------------------------------------------------------------
void color(const color_type& c) { m_color = c; }
@ -357,7 +346,8 @@ namespace agg
void prepare() {}
//--------------------------------------------------------------------
template<class Scanline> void render(const Scanline& sl)
template<class Scanline>
void render(const Scanline& sl)
{
render_scanline_bin_solid(sl, *m_ren, m_color);
}
@ -367,18 +357,9 @@ namespace agg
color_type m_color;
};
//======================================================render_scanline_bin
template<class Scanline, class BaseRenderer,
class SpanAllocator, class SpanGenerator>
void render_scanline_bin(const Scanline& sl, BaseRenderer& ren,
SpanAllocator& alloc, SpanGenerator& span_gen)
template<class Scanline, class BaseRenderer, class SpanAllocator, class SpanGenerator>
void render_scanline_bin(const Scanline& sl, BaseRenderer& ren, SpanAllocator& alloc, SpanGenerator& span_gen)
{
int y = sl.y();
@ -388,20 +369,24 @@ namespace agg
{
int x = span->x;
int len = span->len;
if(len < 0) len = -len;
if (len < 0)
len = -len;
typename BaseRenderer::color_type* colors = alloc.allocate(len);
span_gen.generate(colors, x, y, len);
ren.blend_color_hspan(x, y, len, colors, 0, cover_full);
if(--num_spans == 0) break;
if (--num_spans == 0)
break;
++span;
}
}
//=====================================================render_scanlines_bin
template<class Rasterizer, class Scanline, class BaseRenderer,
class SpanAllocator, class SpanGenerator>
void render_scanlines_bin(Rasterizer& ras, Scanline& sl, BaseRenderer& ren,
SpanAllocator& alloc, SpanGenerator& span_gen)
template<class Rasterizer, class Scanline, class BaseRenderer, class SpanAllocator, class SpanGenerator>
void render_scanlines_bin(Rasterizer& ras,
Scanline& sl,
BaseRenderer& ren,
SpanAllocator& alloc,
SpanGenerator& span_gen)
{
if (ras.rewind_scanlines())
{
@ -424,17 +409,17 @@ namespace agg
typedef SpanGenerator span_gen_type;
//--------------------------------------------------------------------
renderer_scanline_bin() : m_ren(0), m_alloc(0), m_span_gen(0) {}
renderer_scanline_bin(base_ren_type& ren,
alloc_type& alloc,
span_gen_type& span_gen) :
m_ren(&ren),
m_alloc(&alloc),
m_span_gen(&span_gen)
renderer_scanline_bin()
: m_ren(0)
, m_alloc(0)
, m_span_gen(0)
{}
void attach(base_ren_type& ren,
alloc_type& alloc,
span_gen_type& span_gen)
renderer_scanline_bin(base_ren_type& ren, alloc_type& alloc, span_gen_type& span_gen)
: m_ren(&ren)
, m_alloc(&alloc)
, m_span_gen(&span_gen)
{}
void attach(base_ren_type& ren, alloc_type& alloc, span_gen_type& span_gen)
{
m_ren = &ren;
m_alloc = &alloc;
@ -445,7 +430,8 @@ namespace agg
void prepare() { m_span_gen->prepare(); }
//--------------------------------------------------------------------
template<class Scanline> void render(const Scanline& sl)
template<class Scanline>
void render(const Scanline& sl)
{
render_scanline_bin(sl, *m_ren, *m_alloc, *m_span_gen);
}
@ -456,7 +442,6 @@ namespace agg
span_gen_type* m_span_gen;
};
//========================================================render_scanlines
template<class Rasterizer, class Scanline, class Renderer>
void render_scanlines(Rasterizer& ras, Scanline& sl, Renderer& ren)
@ -472,10 +457,8 @@ namespace agg
}
}
//========================================================render_all_paths
template<class Rasterizer, class Scanline, class Renderer,
class VertexSource, class ColorStorage, class PathId>
template<class Rasterizer, class Scanline, class Renderer, class VertexSource, class ColorStorage, class PathId>
void render_all_paths(Rasterizer& ras,
Scanline& sl,
Renderer& r,
@ -493,11 +476,6 @@ namespace agg
}
}
//=============================================render_scanlines_compound
template<class Rasterizer,
class ScanlineAA,
@ -552,18 +530,11 @@ namespace agg
for (;;)
{
len = span_aa->len;
sh.generate_span(color_span,
span_aa->x,
sl_aa.y(),
len,
style);
sh.generate_span(color_span, span_aa->x, sl_aa.y(), len, style);
ren.blend_color_hspan(span_aa->x,
sl_aa.y(),
span_aa->len,
color_span,
span_aa->covers);
if(--num_spans == 0) break;
ren.blend_color_hspan(span_aa->x, sl_aa.y(), span_aa->len, color_span, span_aa->covers);
if (--num_spans == 0)
break;
++span_aa;
}
}
@ -579,11 +550,10 @@ namespace agg
num_spans = sl_bin.num_spans();
for (;;)
{
memset(mix_buffer + span_bin->x - min_x,
0,
span_bin->len * sizeof(color_type));
memset(mix_buffer + span_bin->x - min_x, 0, span_bin->len * sizeof(color_type));
if(--num_spans == 0) break;
if (--num_spans == 0)
break;
++span_bin;
}
@ -622,9 +592,9 @@ namespace agg
}
++colors;
++covers;
}
while(--len);
if(--num_spans == 0) break;
} while (--len);
if (--num_spans == 0)
break;
++span_aa;
}
}
@ -637,11 +607,7 @@ namespace agg
len = span_aa->len;
colors = mix_buffer + span_aa->x - min_x;
cspan = color_span;
sh.generate_span(cspan,
span_aa->x,
sl_aa.y(),
len,
style);
sh.generate_span(cspan, span_aa->x, sl_aa.y(), len, style);
covers = span_aa->covers;
do
{
@ -656,9 +622,9 @@ namespace agg
++cspan;
++colors;
++covers;
}
while(--len);
if(--num_spans == 0) break;
} while (--len);
if (--num_spans == 0)
break;
++span_aa;
}
}
@ -677,7 +643,8 @@ namespace agg
mix_buffer + span_bin->x - min_x,
0,
cover_full);
if(--num_spans == 0) break;
if (--num_spans == 0)
break;
++span_bin;
}
} // if(ras.sweep_scanline(sl_bin, -1))
@ -687,11 +654,7 @@ namespace agg
}
//=======================================render_scanlines_compound_layered
template<class Rasterizer,
class ScanlineAA,
class BaseRenderer,
class SpanAllocator,
class StyleHandler>
template<class Rasterizer, class ScanlineAA, class BaseRenderer, class SpanAllocator, class StyleHandler>
void render_scanlines_compound_layered(Rasterizer& ras,
ScanlineAA& sl_aa,
BaseRenderer& ren,
@ -738,18 +701,11 @@ namespace agg
for (;;)
{
len = span_aa->len;
sh.generate_span(color_span,
span_aa->x,
sl_aa.y(),
len,
style);
sh.generate_span(color_span, span_aa->x, sl_aa.y(), len, style);
ren.blend_color_hspan(span_aa->x,
sl_aa.y(),
span_aa->len,
color_span,
span_aa->covers);
if(--num_spans == 0) break;
ren.blend_color_hspan(span_aa->x, sl_aa.y(), span_aa->len, color_span, span_aa->covers);
if (--num_spans == 0)
break;
++span_aa;
}
}
@ -762,13 +718,9 @@ namespace agg
if (sl_len)
{
memset(mix_buffer + sl_start - min_x,
0,
sl_len * sizeof(color_type));
memset(mix_buffer + sl_start - min_x, 0, sl_len * sizeof(color_type));
memset(cover_buffer + sl_start - min_x,
0,
sl_len * sizeof(cover_type));
memset(cover_buffer + sl_start - min_x, 0, sl_len * sizeof(cover_type));
int sl_y = 0x7FFFFFFF;
unsigned i;
@ -813,9 +765,9 @@ namespace agg
++colors;
++src_covers;
++dst_covers;
}
while(--len);
if(--num_spans == 0) break;
} while (--len);
if (--num_spans == 0)
break;
++span_aa;
}
}
@ -828,11 +780,7 @@ namespace agg
len = span_aa->len;
colors = mix_buffer + span_aa->x - min_x;
cspan = color_span;
sh.generate_span(cspan,
span_aa->x,
sl_aa.y(),
len,
style);
sh.generate_span(cspan, span_aa->x, sl_aa.y(), len, style);
src_covers = span_aa->covers;
dst_covers = cover_buffer + span_aa->x - min_x;
do
@ -851,27 +799,21 @@ namespace agg
++colors;
++src_covers;
++dst_covers;
}
while(--len);
if(--num_spans == 0) break;
} while (--len);
if (--num_spans == 0)
break;
++span_aa;
}
}
}
}
ren.blend_color_hspan(sl_start,
sl_y,
sl_len,
mix_buffer + sl_start - min_x,
0,
cover_full);
ren.blend_color_hspan(sl_start, sl_y, sl_len, mix_buffer + sl_start - min_x, 0, cover_full);
} // if(sl_len)
} // if(num_styles == 1) ... else
} // while((num_styles = ras.sweep_styles()) > 0)
} // if(ras.rewind_scanlines())
}
}
} // namespace agg
#endif

115
deps/agg/include/agg_rendering_buffer.h vendored
View file

@ -22,37 +22,35 @@
#include "agg_array.h"
namespace agg
{
namespace agg {
//===========================================================row_accessor
template<class T> class row_accessor
template<class T>
class row_accessor
{
public:
typedef const_row_info<T> row_data;
//-------------------------------------------------------------------
row_accessor() :
m_buf(0),
m_start(0),
m_width(0),
m_height(0),
m_stride(0)
{
}
row_accessor()
: m_buf(0)
, m_start(0)
, m_width(0)
, m_height(0)
, m_stride(0)
{}
//--------------------------------------------------------------------
row_accessor(T* buf, unsigned width, unsigned height, int stride) :
m_buf(0),
m_start(0),
m_width(0),
m_height(0),
m_stride(0)
row_accessor(T* buf, unsigned width, unsigned height, int stride)
: m_buf(0)
, m_start(0)
, m_width(0)
, m_height(0)
, m_stride(0)
{
attach(buf, width, height, stride);
}
//--------------------------------------------------------------------
void attach(T* buf, unsigned width, unsigned height, int stride)
{
@ -72,32 +70,25 @@ namespace agg
AGG_INLINE unsigned width() const { return m_width; }
AGG_INLINE unsigned height() const { return m_height; }
AGG_INLINE int stride() const { return m_stride; }
AGG_INLINE unsigned stride_abs() const
{
return (m_stride < 0) ? unsigned(-m_stride) : unsigned(m_stride);
}
AGG_INLINE unsigned stride_abs() const { return (m_stride < 0) ? unsigned(-m_stride) : unsigned(m_stride); }
//--------------------------------------------------------------------
AGG_INLINE T* row_ptr(int, int y, unsigned)
{
return m_start + y * m_stride;
}
AGG_INLINE T* row_ptr(int, int y, unsigned) { return m_start + y * m_stride; }
AGG_INLINE T* row_ptr(int y) { return m_start + y * m_stride; }
AGG_INLINE const T* row_ptr(int y) const { return m_start + y * m_stride; }
AGG_INLINE row_data row (int y) const
{
return row_data(0, m_width-1, row_ptr(y));
}
AGG_INLINE row_data row(int y) const { return row_data(0, m_width - 1, row_ptr(y)); }
//--------------------------------------------------------------------
template<class RenBuf>
void copy_from(const RenBuf& src)
{
unsigned h = height();
if(src.height() < h) h = src.height();
if (src.height() < h)
h = src.height();
unsigned l = stride_abs();
if(src.stride_abs() < l) l = src.stride_abs();
if (src.stride_abs() < l)
l = src.stride_abs();
l *= sizeof(T);
@ -135,32 +126,29 @@ namespace agg
int m_stride; // Number of bytes per row. Can be < 0
};
//==========================================================row_ptr_cache
template<class T> class row_ptr_cache
template<class T>
class row_ptr_cache
{
public:
typedef const_row_info<T> row_data;
//-------------------------------------------------------------------
row_ptr_cache() :
m_buf(0),
m_rows(),
m_width(0),
m_height(0),
m_stride(0)
{
}
row_ptr_cache()
: m_buf(0)
, m_rows()
, m_width(0)
, m_height(0)
, m_stride(0)
{}
//--------------------------------------------------------------------
row_ptr_cache(T* buf, unsigned width, unsigned height, int stride) :
m_buf(0),
m_rows(),
m_width(0),
m_height(0),
m_stride(0)
row_ptr_cache(T* buf, unsigned width, unsigned height, int stride)
: m_buf(0)
, m_rows()
, m_width(0)
, m_height(0)
, m_stride(0)
{
attach(buf, width, height, stride);
}
@ -204,22 +192,13 @@ namespace agg
AGG_INLINE unsigned width() const { return m_width; }
AGG_INLINE unsigned height() const { return m_height; }
AGG_INLINE int stride() const { return m_stride; }
AGG_INLINE unsigned stride_abs() const
{
return (m_stride < 0) ? unsigned(-m_stride) : unsigned(m_stride);
}
AGG_INLINE unsigned stride_abs() const { return (m_stride < 0) ? unsigned(-m_stride) : unsigned(m_stride); }
//--------------------------------------------------------------------
AGG_INLINE T* row_ptr(int, int y, unsigned)
{
return m_rows[y];
}
AGG_INLINE T* row_ptr(int, int y, unsigned) { return m_rows[y]; }
AGG_INLINE T* row_ptr(int y) { return m_rows[y]; }
AGG_INLINE const T* row_ptr(int y) const { return m_rows[y]; }
AGG_INLINE row_data row (int y) const
{
return row_data(0, m_width-1, m_rows[y]);
}
AGG_INLINE row_data row(int y) const { return row_data(0, m_width - 1, m_rows[y]); }
//--------------------------------------------------------------------
T const* const* rows() const { return &m_rows[0]; }
@ -229,10 +208,12 @@ namespace agg
void copy_from(const RenBuf& src)
{
unsigned h = height();
if(src.height() < h) h = src.height();
if (src.height() < h)
h = src.height();
unsigned l = stride_abs();
if(src.stride_abs() < l) l = src.stride_abs();
if (src.stride_abs() < l)
l = src.stride_abs();
l *= sizeof(T);
@ -270,9 +251,6 @@ namespace agg
int m_stride; // Number of bytes per row. Can be < 0
};
//========================================================rendering_buffer
//
// The definition of the main type for accessing the rows in the frame
@ -299,7 +277,6 @@ namespace agg
// typedef row_accessor<int8u> rendering_buffer;
#endif
}
} // namespace agg
#endif

46
deps/agg/include/agg_rendering_buffer_dynarow.h vendored
View file

@ -22,8 +22,7 @@
#include "agg_array.h"
namespace agg
{
namespace agg {
//===============================================rendering_buffer_dynarow
// Rendering buffer class with dynamic allocation of the rows.
@ -38,28 +37,23 @@ namespace agg
typedef row_info<int8u> row_data;
//-------------------------------------------------------------------
~rendering_buffer_dynarow()
{
init(0,0,0);
}
~rendering_buffer_dynarow() { init(0, 0, 0); }
//-------------------------------------------------------------------
rendering_buffer_dynarow() :
m_rows(),
m_width(0),
m_height(0),
m_byte_width(0)
{
}
rendering_buffer_dynarow()
: m_rows()
, m_width(0)
, m_height(0)
, m_byte_width(0)
{}
// Allocate and clear the buffer
//--------------------------------------------------------------------
rendering_buffer_dynarow(unsigned width, unsigned height,
unsigned byte_width) :
m_rows(height),
m_width(width),
m_height(height),
m_byte_width(byte_width)
rendering_buffer_dynarow(unsigned width, unsigned height, unsigned byte_width)
: m_rows(height)
, m_width(width)
, m_height(height)
, m_byte_width(byte_width)
{
memset(&m_rows[0], 0, sizeof(row_data) * height);
}
@ -97,8 +91,14 @@ namespace agg
int x2 = x + len - 1;
if (r->ptr)
{
if(x < r->x1) { r->x1 = x; }
if(x2 > r->x2) { r->x2 = x2; }
if (x < r->x1)
{
r->x1 = x;
}
if (x2 > r->x2)
{
r->x2 = x2;
}
}
else
{
@ -130,8 +130,6 @@ namespace agg
unsigned m_byte_width; // Width in bytes
};
}
} // namespace agg
#endif

9
deps/agg/include/agg_rounded_rect.h vendored
View file

@ -23,8 +23,7 @@
#include "agg_basics.h"
#include "agg_arc.h"
namespace agg
{
namespace agg {
//------------------------------------------------------------rounded_rect
//
// See Implemantation agg_rounded_rect.cpp
@ -39,8 +38,7 @@ namespace agg
void radius(double r);
void radius(double rx, double ry);
void radius(double rx_bottom, double ry_bottom, double rx_top, double ry_top);
void radius(double rx1, double ry1, double rx2, double ry2,
double rx3, double ry3, double rx4, double ry4);
void radius(double rx1, double ry1, double rx2, double ry2, double rx3, double ry3, double rx4, double ry4);
void normalize_radius();
void approximation_scale(double s) { m_arc.approximation_scale(s); }
@ -66,7 +64,6 @@ namespace agg
arc m_arc;
};
}
} // namespace agg
#endif

64
deps/agg/include/agg_scanline_bin.h vendored
View file

@ -30,8 +30,7 @@
#include "agg_array.h"
namespace agg
{
namespace agg {
//=============================================================scanline_bin
//
@ -54,12 +53,11 @@ namespace agg
typedef const span* const_iterator;
//--------------------------------------------------------------------
scanline_bin() :
m_last_x(0x7FFFFFF0),
m_spans(),
m_cur_span(0)
{
}
scanline_bin()
: m_last_x(0x7FFFFFF0)
, m_spans()
, m_cur_span(0)
{}
//--------------------------------------------------------------------
void reset(int min_x, int max_x)
@ -106,16 +104,10 @@ namespace agg
}
//--------------------------------------------------------------------
void add_cells(int x, unsigned len, const void*)
{
add_span(x, len, 0);
}
void add_cells(int x, unsigned len, const void*) { add_span(x, len, 0); }
//--------------------------------------------------------------------
void finalize(int y)
{
m_y = y;
}
void finalize(int y) { m_y = y; }
//--------------------------------------------------------------------
void reset_spans()
@ -139,11 +131,6 @@ namespace agg
span* m_cur_span;
};
//===========================================================scanline32_bin
class scanline32_bin
{
@ -154,21 +141,23 @@ namespace agg
struct span
{
span() {}
span(coord_type x_, coord_type len_) : x(x_), len(len_) {}
span(coord_type x_, coord_type len_)
: x(x_)
, len(len_)
{}
coord_type x;
coord_type len;
};
typedef pod_bvector<span, 4> span_array_type;
//--------------------------------------------------------------------
class const_iterator
{
public:
const_iterator(const span_array_type& spans) :
m_spans(spans),
m_span_idx(0)
const_iterator(const span_array_type& spans)
: m_spans(spans)
, m_span_idx(0)
{}
const span& operator*() const { return m_spans[m_span_idx]; }
@ -181,9 +170,11 @@ namespace agg
unsigned m_span_idx;
};
//--------------------------------------------------------------------
scanline32_bin() : m_max_len(0), m_last_x(0x7FFFFFF0) {}
scanline32_bin()
: m_max_len(0)
, m_last_x(0x7FFFFFF0)
{}
//--------------------------------------------------------------------
void reset(int, int)
@ -221,16 +212,10 @@ namespace agg
}
//--------------------------------------------------------------------
void add_cells(int x, unsigned len, const void*)
{
add_span(x, len, 0);
}
void add_cells(int x, unsigned len, const void*) { add_span(x, len, 0); }
//--------------------------------------------------------------------
void finalize(int y)
{
m_y = y;
}
void finalize(int y) { m_y = y; }
//--------------------------------------------------------------------
void reset_spans()
@ -254,11 +239,6 @@ namespace agg
span_array_type m_spans;
};
}
} // namespace agg
#endif

839
deps/agg/include/agg_scanline_boolean_algebra.h vendored
View file

File diff suppressed because it is too large Load diff

76
deps/agg/include/agg_scanline_p.h vendored
View file

@ -29,8 +29,7 @@
#include "agg_array.h"
namespace agg
{
namespace agg {
//=============================================================scanline_p8
//
@ -57,14 +56,13 @@ namespace agg
typedef span* iterator;
typedef const span* const_iterator;
scanline_p8() :
m_last_x(0x7FFFFFF0),
m_covers(),
m_cover_ptr(0),
m_spans(),
m_cur_span(0)
{
}
scanline_p8()
: m_last_x(0x7FFFFFF0)
, m_covers()
, m_cover_ptr(0)
, m_spans()
, m_cur_span(0)
{}
//--------------------------------------------------------------------
void reset(int min_x, int max_x)
@ -122,9 +120,7 @@ namespace agg
//--------------------------------------------------------------------
void add_span(int x, unsigned len, unsigned cover)
{
if(x == m_last_x+1 &&
m_cur_span->len < 0 &&
cover == *m_cur_span->covers)
if (x == m_last_x + 1 && m_cur_span->len < 0 && cover == *m_cur_span->covers)
{
m_cur_span->len -= (int16)len;
}
@ -140,10 +136,7 @@ namespace agg
}
//--------------------------------------------------------------------
void finalize(int y)
{
m_y = y;
}
void finalize(int y) { m_y = y; }
//--------------------------------------------------------------------
void reset_spans()
@ -171,13 +164,6 @@ namespace agg
span* m_cur_span;
};
//==========================================================scanline32_p8
class scanline32_p8
{
@ -189,8 +175,11 @@ namespace agg
struct span
{
span() {}
span(coord_type x_, coord_type len_, const cover_type* covers_) :
x(x_), len(len_), covers(covers_) {}
span(coord_type x_, coord_type len_, const cover_type* covers_)
: x(x_)
, len(len_)
, covers(covers_)
{}
coord_type x;
coord_type len; // If negative, it's a solid span, covers is valid
@ -198,14 +187,13 @@ namespace agg
};
typedef pod_bvector<span, 4> span_array_type;
//--------------------------------------------------------------------
class const_iterator
{
public:
const_iterator(const span_array_type& spans) :
m_spans(spans),
m_span_idx(0)
const_iterator(const span_array_type& spans)
: m_spans(spans)
, m_span_idx(0)
{}
const span& operator*() const { return m_spans[m_span_idx]; }
@ -219,13 +207,12 @@ namespace agg
};
//--------------------------------------------------------------------
scanline32_p8() :
m_max_len(0),
m_last_x(0x7FFFFFF0),
m_covers(),
m_cover_ptr(0)
{
}
scanline32_p8()
: m_max_len(0)
, m_last_x(0x7FFFFFF0)
, m_covers()
, m_cover_ptr(0)
{}
//--------------------------------------------------------------------
void reset(int min_x, int max_x)
@ -275,10 +262,7 @@ namespace agg
//--------------------------------------------------------------------
void add_span(int x, unsigned len, unsigned cover)
{
if(x == m_last_x+1 &&
m_spans.size() &&
m_spans.last().len < 0 &&
cover == *m_spans.last().covers)
if (x == m_last_x + 1 && m_spans.size() && m_spans.last().len < 0 && cover == *m_spans.last().covers)
{
m_spans.last().len -= coord_type(len);
}
@ -291,10 +275,7 @@ namespace agg
}
//--------------------------------------------------------------------
void finalize(int y)
{
m_y = y;
}
void finalize(int y) { m_y = y; }
//--------------------------------------------------------------------
void reset_spans()
@ -321,9 +302,6 @@ namespace agg
span_array_type m_spans;
};
}
} // namespace agg
#endif

242
deps/agg/include/agg_scanline_storage_aa.h vendored
View file

@ -29,12 +29,11 @@
#include <cmath>
#include "agg_array.h"
namespace agg
{
namespace agg {
//----------------------------------------------scanline_cell_storage
template<class T> class scanline_cell_storage
template<class T>
class scanline_cell_storage
{
struct extra_span
{
@ -46,30 +45,25 @@ namespace agg
typedef T value_type;
//---------------------------------------------------------------
~scanline_cell_storage()
{
remove_all();
}
~scanline_cell_storage() { remove_all(); }
//---------------------------------------------------------------
scanline_cell_storage() :
m_cells(128-2),
m_extra_storage()
scanline_cell_storage()
: m_cells(128 - 2)
, m_extra_storage()
{}
// Copying
//---------------------------------------------------------------
scanline_cell_storage(const scanline_cell_storage<T>& v) :
m_cells(v.m_cells),
m_extra_storage()
scanline_cell_storage(const scanline_cell_storage<T>& v)
: m_cells(v.m_cells)
, m_extra_storage()
{
copy_extra_storage(v);
}
//---------------------------------------------------------------
const scanline_cell_storage<T>&
operator = (const scanline_cell_storage<T>& v)
const scanline_cell_storage<T>& operator=(const scanline_cell_storage<T>& v)
{
remove_all();
m_cells = v.m_cells;
@ -83,8 +77,7 @@ namespace agg
int i;
for (i = m_extra_storage.size() - 1; i >= 0; --i)
{
pod_allocator<T>::deallocate(m_extra_storage[i].ptr,
m_extra_storage[i].len);
pod_allocator<T>::deallocate(m_extra_storage[i].ptr, m_extra_storage[i].len);
}
m_extra_storage.remove_all();
m_cells.remove_all();
@ -113,11 +106,13 @@ namespace agg
{
if (idx >= 0)
{
if((unsigned)idx >= m_cells.size()) return 0;
if ((unsigned)idx >= m_cells.size())
return 0;
return &m_cells[(unsigned)idx];
}
unsigned i = unsigned(-idx - 1);
if(i >= m_extra_storage.size()) return 0;
if (i >= m_extra_storage.size())
return 0;
return m_extra_storage[i].ptr;
}
@ -126,11 +121,13 @@ namespace agg
{
if (idx >= 0)
{
if((unsigned)idx >= m_cells.size()) return 0;
if ((unsigned)idx >= m_cells.size())
return 0;
return &m_cells[(unsigned)idx];
}
unsigned i = unsigned(-idx - 1);
if(i >= m_extra_storage.size()) return 0;
if (i >= m_extra_storage.size())
return 0;
return m_extra_storage[i].ptr;
}
@ -153,13 +150,9 @@ namespace agg
pod_bvector<extra_span, 6> m_extra_storage;
};
//-----------------------------------------------scanline_storage_aa
template<class T> class scanline_storage_aa
template<class T>
class scanline_storage_aa
{
public:
typedef T cover_type;
@ -180,7 +173,6 @@ namespace agg
unsigned start_span;
};
//---------------------------------------------------------------
class embedded_scanline
{
@ -197,10 +189,12 @@ namespace agg
const T* covers;
};
const_iterator() : m_storage(0) {}
const_iterator(const embedded_scanline& sl) :
m_storage(sl.m_storage),
m_span_idx(sl.m_scanline.start_span)
const_iterator()
: m_storage(0)
{}
const_iterator(const embedded_scanline& sl)
: m_storage(sl.m_storage)
, m_span_idx(sl.m_scanline.start_span)
{
init_span();
}
@ -230,10 +224,9 @@ namespace agg
friend class const_iterator;
//-----------------------------------------------------------
embedded_scanline(const scanline_storage_aa& storage) :
m_storage(&storage)
embedded_scanline(const scanline_storage_aa& storage)
: m_storage(&storage)
{
init(0);
}
@ -257,17 +250,17 @@ namespace agg
unsigned m_scanline_idx;
};
//---------------------------------------------------------------
scanline_storage_aa() :
m_covers(),
m_spans(256-2), // Block increment size
m_scanlines(),
m_min_x( 0x7FFFFFFF),
m_min_y( 0x7FFFFFFF),
m_max_x(-0x7FFFFFFF),
m_max_y(-0x7FFFFFFF),
m_cur_scanline(0)
scanline_storage_aa()
: m_covers()
, m_spans(256 - 2)
, // Block increment size
m_scanlines()
, m_min_x(0x7FFFFFFF)
, m_min_y(0x7FFFFFFF)
, m_max_x(-0x7FFFFFFF)
, m_max_y(-0x7FFFFFFF)
, m_cur_scanline(0)
{
m_fake_scanline.y = 0;
m_fake_scanline.num_spans = 0;
@ -292,13 +285,16 @@ namespace agg
}
//---------------------------------------------------------------
template<class Scanline> void render(const Scanline& sl)
template<class Scanline>
void render(const Scanline& sl)
{
scanline_data sl_this;
int y = sl.y();
if(y < m_min_y) m_min_y = y;
if(y > m_max_y) m_max_y = y;
if (y < m_min_y)
m_min_y = y;
if (y > m_max_y)
m_max_y = y;
sl_this.y = y;
sl_this.num_spans = sl.num_spans();
@ -313,21 +309,21 @@ namespace agg
sp.x = span_iterator->x;
sp.len = span_iterator->len;
int len = std::abs(int(sp.len));
sp.covers_id =
m_covers.add_cells(span_iterator->covers,
unsigned(len));
sp.covers_id = m_covers.add_cells(span_iterator->covers, unsigned(len));
m_spans.add(sp);
int x1 = sp.x;
int x2 = sp.x + len - 1;
if(x1 < m_min_x) m_min_x = x1;
if(x2 > m_max_x) m_max_x = x2;
if(--num_spans == 0) break;
if (x1 < m_min_x)
m_min_x = x1;
if (x2 > m_max_x)
m_max_x = x2;
if (--num_spans == 0)
break;
++span_iterator;
}
m_scanlines.add(sl_this);
}
//---------------------------------------------------------------
// Iterate scanlines interface
int min_x() const { return m_min_x; }
@ -342,14 +338,15 @@ namespace agg
return m_scanlines.size() > 0;
}
//---------------------------------------------------------------
template<class Scanline> bool sweep_scanline(Scanline& sl)
template<class Scanline>
bool sweep_scanline(Scanline& sl)
{
sl.reset_spans();
for (;;)
{
if(m_cur_scanline >= m_scanlines.size()) return false;
if (m_cur_scanline >= m_scanlines.size())
return false;
const scanline_data& sl_this = m_scanlines[m_cur_scanline];
unsigned num_spans = sl_this.num_spans;
@ -366,8 +363,7 @@ namespace agg
{
sl.add_cells(sp.x, sp.len, covers);
}
}
while(--num_spans);
} while (--num_spans);
++m_cur_scanline;
if (sl.num_spans())
{
@ -378,18 +374,17 @@ namespace agg
return true;
}
//---------------------------------------------------------------
// Specialization for embedded_scanline
bool sweep_scanline(embedded_scanline& sl)
{
do
{
if(m_cur_scanline >= m_scanlines.size()) return false;
if (m_cur_scanline >= m_scanlines.size())
return false;
sl.init(m_cur_scanline);
++m_cur_scanline;
}
while(sl.num_spans() == 0);
} while (sl.num_spans() == 0);
return true;
}
@ -420,13 +415,11 @@ namespace agg
{
size += sizeof(T) * unsigned(sp.len); // covers
}
}
while(--num_spans);
} while (--num_spans);
}
return size;
}
//---------------------------------------------------------------
static void write_int32(int8u* dst, int32 val)
{
@ -436,7 +429,6 @@ namespace agg
dst[3] = ((const int8u*)&val)[3];
}
//---------------------------------------------------------------
void serialize(int8u* data) const
{
@ -487,13 +479,11 @@ namespace agg
memcpy(data, covers, unsigned(sp.len) * sizeof(T));
data += sizeof(T) * unsigned(sp.len);
}
}
while(--num_spans);
} while (--num_spans);
write_int32(size_ptr, int32(unsigned(data - size_ptr)));
}
}
//---------------------------------------------------------------
const scanline_data& scanline_by_index(unsigned i) const
{
@ -501,16 +491,10 @@ namespace agg
}
//---------------------------------------------------------------
const span_data& span_by_index(unsigned i) const
{
return (i < m_spans.size()) ? m_spans[i] : m_fake_span;
}
const span_data& span_by_index(unsigned i) const { return (i < m_spans.size()) ? m_spans[i] : m_fake_span; }
//---------------------------------------------------------------
const T* covers_by_index(int i) const
{
return m_covers[i];
}
const T* covers_by_index(int i) const { return m_covers[i]; }
private:
scanline_cell_storage<T> m_covers;
@ -525,16 +509,13 @@ namespace agg
unsigned m_cur_scanline;
};
typedef scanline_storage_aa<int8u> scanline_storage_aa8; //--------scanline_storage_aa8
typedef scanline_storage_aa<int16u> scanline_storage_aa16; //--------scanline_storage_aa16
typedef scanline_storage_aa<int32u> scanline_storage_aa32; //--------scanline_storage_aa32
//------------------------------------------serialized_scanlines_adaptor_aa
template<class T> class serialized_scanlines_adaptor_aa
template<class T>
class serialized_scanlines_adaptor_aa
{
public:
typedef T cover_type;
@ -556,10 +537,12 @@ namespace agg
const T* covers;
};
const_iterator() : m_ptr(0) {}
const_iterator(const embedded_scanline& sl) :
m_ptr(sl.m_ptr),
m_dx(sl.m_dx)
const_iterator()
: m_ptr(0)
{}
const_iterator(const embedded_scanline& sl)
: m_ptr(sl.m_ptr)
, m_dx(sl.m_dx)
{
init_span();
}
@ -605,9 +588,12 @@ namespace agg
friend class const_iterator;
//-----------------------------------------------------------------
embedded_scanline() : m_ptr(0), m_y(0), m_num_spans(0) {}
embedded_scanline()
: m_ptr(0)
, m_y(0)
, m_num_spans(0)
{}
//-----------------------------------------------------------------
void reset(int, int) {}
@ -615,7 +601,6 @@ namespace agg
int y() const { return m_y; }
const_iterator begin() const { return const_iterator(*this); }
private:
//-----------------------------------------------------------------
int read_int32()
@ -645,34 +630,31 @@ namespace agg
int m_dx;
};
public:
//--------------------------------------------------------------------
serialized_scanlines_adaptor_aa() :
m_data(0),
m_end(0),
m_ptr(0),
m_dx(0),
m_dy(0),
m_min_x(0x7FFFFFFF),
m_min_y(0x7FFFFFFF),
m_max_x(-0x7FFFFFFF),
m_max_y(-0x7FFFFFFF)
serialized_scanlines_adaptor_aa()
: m_data(0)
, m_end(0)
, m_ptr(0)
, m_dx(0)
, m_dy(0)
, m_min_x(0x7FFFFFFF)
, m_min_y(0x7FFFFFFF)
, m_max_x(-0x7FFFFFFF)
, m_max_y(-0x7FFFFFFF)
{}
//--------------------------------------------------------------------
serialized_scanlines_adaptor_aa(const int8u* data, unsigned size,
double dx, double dy) :
m_data(data),
m_end(data + size),
m_ptr(data),
m_dx(iround(dx)),
m_dy(iround(dy)),
m_min_x(0x7FFFFFFF),
m_min_y(0x7FFFFFFF),
m_max_x(-0x7FFFFFFF),
m_max_y(-0x7FFFFFFF)
serialized_scanlines_adaptor_aa(const int8u* data, unsigned size, double dx, double dy)
: m_data(data)
, m_end(data + size)
, m_ptr(data)
, m_dx(iround(dx))
, m_dy(iround(dy))
, m_min_x(0x7FFFFFFF)
, m_min_y(0x7FFFFFFF)
, m_max_x(-0x7FFFFFFF)
, m_max_y(-0x7FFFFFFF)
{}
//--------------------------------------------------------------------
@ -735,12 +717,14 @@ namespace agg
int max_y() const { return m_max_y; }
//--------------------------------------------------------------------
template<class Scanline> bool sweep_scanline(Scanline& sl)
template<class Scanline>
bool sweep_scanline(Scanline& sl)
{
sl.reset_spans();
for (;;)
{
if(m_ptr >= m_end) return false;
if (m_ptr >= m_end)
return false;
read_int32(); // Skip scanline size in bytes
int y = read_int32() + m_dy;
@ -761,8 +745,7 @@ namespace agg
sl.add_cells(x, len, m_ptr);
m_ptr += len * sizeof(T);
}
}
while(--num_spans);
} while (--num_spans);
if (sl.num_spans())
{
@ -773,20 +756,19 @@ namespace agg
return true;
}
//--------------------------------------------------------------------
// Specialization for embedded_scanline
bool sweep_scanline(embedded_scanline& sl)
{
do
{
if(m_ptr >= m_end) return false;
if (m_ptr >= m_end)
return false;
unsigned byte_size = read_int32u();
sl.init(m_ptr, m_dx, m_dy);
m_ptr += byte_size - sizeof(int32);
}
while(sl.num_spans() == 0);
} while (sl.num_spans() == 0);
return true;
}
@ -802,14 +784,12 @@ namespace agg
int m_max_y;
};
typedef serialized_scanlines_adaptor_aa<int8u> serialized_scanlines_adaptor_aa8; //----serialized_scanlines_adaptor_aa8
typedef serialized_scanlines_adaptor_aa<int16u> serialized_scanlines_adaptor_aa16; //----serialized_scanlines_adaptor_aa16
typedef serialized_scanlines_adaptor_aa<int32u> serialized_scanlines_adaptor_aa32; //----serialized_scanlines_adaptor_aa32
}
typedef serialized_scanlines_adaptor_aa<int16u>
serialized_scanlines_adaptor_aa16; //----serialized_scanlines_adaptor_aa16
typedef serialized_scanlines_adaptor_aa<int32u>
serialized_scanlines_adaptor_aa32; //----serialized_scanlines_adaptor_aa32
} // namespace agg
#endif

185
deps/agg/include/agg_scanline_storage_bin.h vendored
View file

@ -21,7 +21,6 @@
//
//----------------------------------------------------------------------------
#ifndef AGG_SCANLINE_STORAGE_BIN_INCLUDED
#define AGG_SCANLINE_STORAGE_BIN_INCLUDED
@ -30,9 +29,7 @@
#include <cmath>
#include "agg_array.h"
namespace agg
{
namespace agg {
//-----------------------------------------------scanline_storage_bin
class scanline_storage_bin
@ -53,7 +50,6 @@ namespace agg
unsigned start_span;
};
//---------------------------------------------------------------
class embedded_scanline
{
@ -63,10 +59,12 @@ namespace agg
class const_iterator
{
public:
const_iterator() : m_storage(0) {}
const_iterator(const embedded_scanline& sl) :
m_storage(sl.m_storage),
m_span_idx(sl.m_scanline.start_span)
const_iterator()
: m_storage(0)
{}
const_iterator(const embedded_scanline& sl)
: m_storage(sl.m_storage)
, m_span_idx(sl.m_scanline.start_span)
{
m_span = m_storage->span_by_index(m_span_idx);
}
@ -88,10 +86,9 @@ namespace agg
friend class const_iterator;
//-----------------------------------------------------------
embedded_scanline(const scanline_storage_bin& storage) :
m_storage(&storage)
embedded_scanline(const scanline_storage_bin& storage)
: m_storage(&storage)
{
setup(0);
}
@ -115,16 +112,16 @@ namespace agg
unsigned m_scanline_idx;
};
//---------------------------------------------------------------
scanline_storage_bin() :
m_spans(256-2), // Block increment size
m_scanlines(),
m_min_x( 0x7FFFFFFF),
m_min_y( 0x7FFFFFFF),
m_max_x(-0x7FFFFFFF),
m_max_y(-0x7FFFFFFF),
m_cur_scanline(0)
scanline_storage_bin()
: m_spans(256 - 2)
, // Block increment size
m_scanlines()
, m_min_x(0x7FFFFFFF)
, m_min_y(0x7FFFFFFF)
, m_max_x(-0x7FFFFFFF)
, m_max_y(-0x7FFFFFFF)
, m_cur_scanline(0)
{
m_fake_scanline.y = 0;
m_fake_scanline.num_spans = 0;
@ -147,13 +144,16 @@ namespace agg
}
//---------------------------------------------------------------
template<class Scanline> void render(const Scanline& sl)
template<class Scanline>
void render(const Scanline& sl)
{
scanline_data sl_this;
int y = sl.y();
if(y < m_min_y) m_min_y = y;
if(y > m_max_y) m_max_y = y;
if (y < m_min_y)
m_min_y = y;
if (y > m_max_y)
m_max_y = y;
sl_this.y = y;
sl_this.num_spans = sl.num_spans();
@ -169,15 +169,17 @@ namespace agg
m_spans.add(sp);
int x1 = sp.x;
int x2 = sp.x + sp.len - 1;
if(x1 < m_min_x) m_min_x = x1;
if(x2 > m_max_x) m_max_x = x2;
if(--num_spans == 0) break;
if (x1 < m_min_x)
m_min_x = x1;
if (x2 > m_max_x)
m_max_x = x2;
if (--num_spans == 0)
break;
++span_iterator;
}
m_scanlines.add(sl_this);
}
//---------------------------------------------------------------
// Iterate scanlines interface
int min_x() const { return m_min_x; }
@ -192,14 +194,15 @@ namespace agg
return m_scanlines.size() > 0;
}
//---------------------------------------------------------------
template<class Scanline> bool sweep_scanline(Scanline& sl)
template<class Scanline>
bool sweep_scanline(Scanline& sl)
{
sl.reset_spans();
for (;;)
{
if(m_cur_scanline >= m_scanlines.size()) return false;
if (m_cur_scanline >= m_scanlines.size())
return false;
const scanline_data& sl_this = m_scanlines[m_cur_scanline];
unsigned num_spans = sl_this.num_spans;
@ -208,8 +211,7 @@ namespace agg
{
const span_data& sp = m_spans[span_idx++];
sl.add_span(sp.x, sp.len, cover_full);
}
while(--num_spans);
} while (--num_spans);
++m_cur_scanline;
if (sl.num_spans())
@ -221,22 +223,20 @@ namespace agg
return true;
}
//---------------------------------------------------------------
// Specialization for embedded_scanline
bool sweep_scanline(embedded_scanline& sl)
{
do
{
if(m_cur_scanline >= m_scanlines.size()) return false;
if (m_cur_scanline >= m_scanlines.size())
return false;
sl.setup(m_cur_scanline);
++m_cur_scanline;
}
while(sl.num_spans() == 0);
} while (sl.num_spans() == 0);
return true;
}
//---------------------------------------------------------------
unsigned byte_size() const
{
@ -251,7 +251,6 @@ namespace agg
return size;
}
//---------------------------------------------------------------
static void write_int32(int8u* dst, int32 val)
{
@ -261,7 +260,6 @@ namespace agg
dst[3] = ((const int8u*)&val)[3];
}
//---------------------------------------------------------------
void serialize(int8u* data) const
{
@ -297,12 +295,10 @@ namespace agg
write_int32(data, sp.len); // len
data += sizeof(int32);
}
while(--num_spans);
} while (--num_spans);
}
}
//---------------------------------------------------------------
const scanline_data& scanline_by_index(unsigned i) const
{
@ -310,11 +306,7 @@ namespace agg
}
//---------------------------------------------------------------
const span_data& span_by_index(unsigned i) const
{
return (i < m_spans.size()) ? m_spans[i] : m_fake_span;
}
const span_data& span_by_index(unsigned i) const { return (i < m_spans.size()) ? m_spans[i] : m_fake_span; }
private:
pod_bvector<span_data, 10> m_spans;
@ -328,18 +320,6 @@ namespace agg
unsigned m_cur_scanline;
};
//---------------------------------------serialized_scanlines_adaptor_bin
class serialized_scanlines_adaptor_bin
{
@ -361,10 +341,12 @@ namespace agg
int32 len;
};
const_iterator() : m_ptr(0) {}
const_iterator(const embedded_scanline& sl) :
m_ptr(sl.m_ptr),
m_dx(sl.m_dx)
const_iterator()
: m_ptr(0)
{}
const_iterator(const embedded_scanline& sl)
: m_ptr(sl.m_ptr)
, m_dx(sl.m_dx)
{
m_span.x = read_int32() + m_dx;
m_span.len = read_int32();
@ -397,9 +379,12 @@ namespace agg
friend class const_iterator;
//----------------------------------------------------------------
embedded_scanline() : m_ptr(0), m_y(0), m_num_spans(0) {}
embedded_scanline()
: m_ptr(0)
, m_y(0)
, m_num_spans(0)
{}
//----------------------------------------------------------------
void reset(int, int) {}
@ -407,7 +392,6 @@ namespace agg
int y() const { return m_y; }
const_iterator begin() const { return const_iterator(*this); }
private:
//----------------------------------------------------------------
int read_int32()
@ -437,34 +421,31 @@ namespace agg
int m_dx;
};
public:
//--------------------------------------------------------------------
serialized_scanlines_adaptor_bin() :
m_data(0),
m_end(0),
m_ptr(0),
m_dx(0),
m_dy(0),
m_min_x(0x7FFFFFFF),
m_min_y(0x7FFFFFFF),
m_max_x(-0x7FFFFFFF),
m_max_y(-0x7FFFFFFF)
serialized_scanlines_adaptor_bin()
: m_data(0)
, m_end(0)
, m_ptr(0)
, m_dx(0)
, m_dy(0)
, m_min_x(0x7FFFFFFF)
, m_min_y(0x7FFFFFFF)
, m_max_x(-0x7FFFFFFF)
, m_max_y(-0x7FFFFFFF)
{}
//--------------------------------------------------------------------
serialized_scanlines_adaptor_bin(const int8u* data, unsigned size,
double dx, double dy) :
m_data(data),
m_end(data + size),
m_ptr(data),
m_dx(iround(dx)),
m_dy(iround(dy)),
m_min_x(0x7FFFFFFF),
m_min_y(0x7FFFFFFF),
m_max_x(-0x7FFFFFFF),
m_max_y(-0x7FFFFFFF)
serialized_scanlines_adaptor_bin(const int8u* data, unsigned size, double dx, double dy)
: m_data(data)
, m_end(data + size)
, m_ptr(data)
, m_dx(iround(dx))
, m_dy(iround(dy))
, m_min_x(0x7FFFFFFF)
, m_min_y(0x7FFFFFFF)
, m_max_x(-0x7FFFFFFF)
, m_max_y(-0x7FFFFFFF)
{}
//--------------------------------------------------------------------
@ -516,12 +497,14 @@ namespace agg
int max_y() const { return m_max_y; }
//--------------------------------------------------------------------
template<class Scanline> bool sweep_scanline(Scanline& sl)
template<class Scanline>
bool sweep_scanline(Scanline& sl)
{
sl.reset_spans();
for (;;)
{
if(m_ptr >= m_end) return false;
if (m_ptr >= m_end)
return false;
int y = read_int32() + m_dy;
unsigned num_spans = read_int32();
@ -531,10 +514,10 @@ namespace agg
int x = read_int32() + m_dx;
int len = read_int32();
if(len < 0) len = -len;
if (len < 0)
len = -len;
sl.add_span(x, unsigned(len), cover_full);
}
while(--num_spans);
} while (--num_spans);
if (sl.num_spans())
{
@ -545,14 +528,14 @@ namespace agg
return true;
}
//--------------------------------------------------------------------
// Specialization for embedded_scanline
bool sweep_scanline(embedded_scanline& sl)
{
do
{
if(m_ptr >= m_end) return false;
if (m_ptr >= m_end)
return false;
sl.init(m_ptr, m_dx, m_dy);
@ -561,8 +544,7 @@ namespace agg
read_int32(); // Y
int num_spans = read_int32(); // num_spans
m_ptr += num_spans * sizeof(int32) * 2;
}
while(sl.num_spans() == 0);
} while (sl.num_spans() == 0);
return true;
}
@ -578,9 +560,6 @@ namespace agg
int m_max_y;
};
}
} // namespace agg
#endif

109
deps/agg/include/agg_scanline_u.h vendored
View file

@ -26,8 +26,7 @@
#include "agg_array.h"
namespace agg
{
namespace agg {
//=============================================================scanline_u8
//
// Unpacked scanline container class
@ -125,10 +124,10 @@ namespace agg
typedef const span* const_iterator;
//--------------------------------------------------------------------
scanline_u8() :
m_min_x(0),
m_last_x(0x7FFFFFF0),
m_cur_span(0)
scanline_u8()
: m_min_x(0)
, m_last_x(0x7FFFFFF0)
, m_cur_span(0)
{}
//--------------------------------------------------------------------
@ -203,10 +202,7 @@ namespace agg
}
//--------------------------------------------------------------------
void finalize(int y)
{
m_y = y;
}
void finalize(int y) { m_y = y; }
//--------------------------------------------------------------------
void reset_spans()
@ -234,9 +230,6 @@ namespace agg
span* m_cur_span;
};
//==========================================================scanline_u8_am
//
// The scanline container with alpha-masking
@ -251,8 +244,14 @@ namespace agg
typedef base_type::cover_type cover_type;
typedef base_type::coord_type coord_type;
scanline_u8_am() : base_type(), m_alpha_mask(0) {}
scanline_u8_am(const AlphaMask& am) : base_type(), m_alpha_mask(&am) {}
scanline_u8_am()
: base_type()
, m_alpha_mask(0)
{}
scanline_u8_am(const AlphaMask& am)
: base_type()
, m_alpha_mask(&am)
{}
//--------------------------------------------------------------------
void finalize(int span_y)
@ -264,13 +263,9 @@ namespace agg
unsigned count = base_type::num_spans();
do
{
m_alpha_mask->combine_hspan(span->x,
base_type::y(),
span->covers,
span->len);
m_alpha_mask->combine_hspan(span->x, base_type::y(), span->covers, span->len);
++span;
}
while(--count);
} while (--count);
}
}
@ -278,9 +273,6 @@ namespace agg
const AlphaMask* m_alpha_mask;
};
//===========================================================scanline32_u8
class scanline32_u8
{
@ -293,8 +285,11 @@ namespace agg
struct span
{
span() {}
span(coord_type x_, coord_type len_, cover_type* covers_) :
x(x_), len(len_), covers(covers_) {}
span(coord_type x_, coord_type len_, cover_type* covers_)
: x(x_)
, len(len_)
, covers(covers_)
{}
coord_type x;
coord_type len;
@ -307,9 +302,9 @@ namespace agg
class const_iterator
{
public:
const_iterator(const span_array_type& spans) :
m_spans(spans),
m_span_idx(0)
const_iterator(const span_array_type& spans)
: m_spans(spans)
, m_span_idx(0)
{}
const span& operator*() const { return m_spans[m_span_idx]; }
@ -326,9 +321,9 @@ namespace agg
class iterator
{
public:
iterator(span_array_type& spans) :
m_spans(spans),
m_span_idx(0)
iterator(span_array_type& spans)
: m_spans(spans)
, m_span_idx(0)
{}
span& operator*() { return m_spans[m_span_idx]; }
@ -341,13 +336,11 @@ namespace agg
unsigned m_span_idx;
};
//--------------------------------------------------------------------
scanline32_u8() :
m_min_x(0),
m_last_x(0x7FFFFFF0),
m_covers()
scanline32_u8()
: m_min_x(0)
, m_last_x(0x7FFFFFF0)
, m_covers()
{}
//--------------------------------------------------------------------
@ -390,9 +383,7 @@ namespace agg
}
else
{
m_spans.add(span(coord_type(x + m_min_x),
coord_type(len),
&m_covers[x]));
m_spans.add(span(coord_type(x + m_min_x), coord_type(len), &m_covers[x]));
}
m_last_x = x + len - 1;
}
@ -408,18 +399,13 @@ namespace agg
}
else
{
m_spans.add(span(coord_type(x + m_min_x),
coord_type(len),
&m_covers[x]));
m_spans.add(span(coord_type(x + m_min_x), coord_type(len), &m_covers[x]));
}
m_last_x = x + len - 1;
}
//--------------------------------------------------------------------
void finalize(int y)
{
m_y = y;
}
void finalize(int y) { m_y = y; }
//--------------------------------------------------------------------
void reset_spans()
@ -446,9 +432,6 @@ namespace agg
span_array_type m_spans;
};
//========================================================scanline32_u8_am
//
// The scanline container with alpha-masking
@ -464,9 +447,14 @@ namespace agg
typedef base_type::cover_type cover_type;
typedef base_type::coord_type coord_type;
scanline32_u8_am() : base_type(), m_alpha_mask(0) {}
scanline32_u8_am(const AlphaMask& am) : base_type(), m_alpha_mask(&am) {}
scanline32_u8_am()
: base_type()
, m_alpha_mask(0)
{}
scanline32_u8_am(const AlphaMask& am)
: base_type()
, m_alpha_mask(&am)
{}
//--------------------------------------------------------------------
void finalize(int span_y)
@ -478,13 +466,9 @@ namespace agg
unsigned count = base_type::num_spans();
do
{
m_alpha_mask->combine_hspan(span->x,
base_type::y(),
span->covers,
span->len);
m_alpha_mask->combine_hspan(span->x, base_type::y(), span->covers, span->len);
++span;
}
while(--count);
} while (--count);
}
}
@ -492,9 +476,6 @@ namespace agg
const AlphaMask* m_alpha_mask;
};
}
} // namespace agg
#endif

12
deps/agg/include/agg_shorten_path.h vendored
View file

@ -19,8 +19,7 @@
#include "agg_basics.h"
#include "agg_vertex_sequence.h"
namespace agg
{
namespace agg {
//===========================================================shorten_path
template<class VertexSequence>
@ -35,7 +34,8 @@ namespace agg
while (n)
{
d = vs[n].dist;
if(d > s) break;
if (d > s)
break;
vs.remove_last();
s -= d;
--n;
@ -54,13 +54,13 @@ namespace agg
double y = prev.y + (last.y - prev.y) * d;
last.x = x;
last.y = y;
if(!prev(last)) vs.remove_last();
if (!prev(last))
vs.remove_last();
vs.close(closed != 0);
}
}
}
}
} // namespace agg
#endif

19
deps/agg/include/agg_simul_eq.h vendored
View file

@ -22,11 +22,11 @@
#include <cmath>
#include "agg_basics.h"
namespace agg
{
namespace agg {
//=============================================================swap_arrays
template<class T> void swap_arrays(T* a1, T* a2, unsigned n)
template<class T>
void swap_arrays(T* a1, T* a2, unsigned n)
{
unsigned i;
for (i = 0; i < n; i++)
@ -37,7 +37,6 @@ namespace agg
}
}
//============================================================matrix_pivot
template<unsigned Rows, unsigned Cols>
struct matrix_pivot
@ -72,15 +71,12 @@ namespace agg
}
};
//===============================================================simul_eq
template<unsigned Size, unsigned RightCols>
struct simul_eq
{
static bool solve(const double left[Size][Size],
const double right[Size][RightCols],
double result[Size][RightCols])
static bool
solve(const double left[Size][Size], const double right[Size][RightCols], double result[Size][RightCols])
{
unsigned i, j, k;
double a1;
@ -123,7 +119,6 @@ namespace agg
}
}
for (k = 0; k < RightCols; k++)
{
int m;
@ -138,10 +133,8 @@ namespace agg
}
return true;
}
};
}
} // namespace agg
#endif

11
deps/agg/include/agg_span_allocator.h vendored
View file

@ -18,10 +18,10 @@
#include "agg_array.h"
namespace agg
{
namespace agg {
//----------------------------------------------------------span_allocator
template<class ColorT> class span_allocator
template<class ColorT>
class span_allocator
{
public:
typedef ColorT color_type;
@ -46,9 +46,6 @@ namespace agg
private:
pod_array<color_type> m_span;
};
}
} // namespace agg
#endif

14
deps/agg/include/agg_span_converter.h vendored
View file

@ -18,16 +18,18 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//----------------------------------------------------------span_converter
template<class SpanGenerator, class SpanConverter> class span_converter
template<class SpanGenerator, class SpanConverter>
class span_converter
{
public:
typedef typename SpanGenerator::color_type color_type;
span_converter(SpanGenerator& span_gen, SpanConverter& span_cnv) :
m_span_gen(&span_gen), m_span_cnv(&span_cnv) {}
span_converter(SpanGenerator& span_gen, SpanConverter& span_cnv)
: m_span_gen(&span_gen)
, m_span_cnv(&span_cnv)
{}
void attach_generator(SpanGenerator& span_gen) { m_span_gen = &span_gen; }
void attach_converter(SpanConverter& span_cnv) { m_span_cnv = &span_cnv; }
@ -51,6 +53,6 @@ namespace agg
SpanConverter* m_span_cnv;
};
}
} // namespace agg
#endif

88
deps/agg/include/agg_span_gouraud.h vendored
View file

@ -19,11 +19,11 @@
#include "agg_basics.h"
#include "agg_math.h"
namespace agg
{
namespace agg {
//============================================================span_gouraud
template<class ColorT> class span_gouraud
template<class ColorT>
class span_gouraud
{
public:
typedef ColorT color_type;
@ -36,8 +36,8 @@ namespace agg
};
//--------------------------------------------------------------------
span_gouraud() :
m_vertex(0)
span_gouraud()
: m_vertex(0)
{
m_cmd[0] = path_cmd_stop;
}
@ -46,11 +46,14 @@ namespace agg
span_gouraud(const color_type& c1,
const color_type& c2,
const color_type& c3,
double x1, double y1,
double x2, double y2,
double x3, double y3,
double d) :
m_vertex(0)
double x1,
double y1,
double x2,
double y2,
double x3,
double y3,
double d)
: m_vertex(0)
{
colors(c1, c2, c3);
triangle(x1, y1, x2, y2, x3, y3, d);
@ -71,10 +74,7 @@ namespace agg
// It's necessary to achieve numerical stability.
// However, the coordinates to interpolate colors are calculated
// as miter joins (calc_intersection).
void triangle(double x1, double y1,
double x2, double y2,
double x3, double y3,
double d)
void triangle(double x1, double y1, double x2, double y2, double x3, double y3, double d)
{
m_coord[0].x = m_x[0] = x1;
m_coord[0].y = m_y[0] = y1;
@ -89,22 +89,48 @@ namespace agg
if (d != 0.0)
{
dilate_triangle(m_coord[0].x, m_coord[0].y,
m_coord[1].x, m_coord[1].y,
m_coord[2].x, m_coord[2].y,
m_x, m_y, d);
dilate_triangle(m_coord[0].x,
m_coord[0].y,
m_coord[1].x,
m_coord[1].y,
m_coord[2].x,
m_coord[2].y,
m_x,
m_y,
d);
calc_intersection(m_x[4], m_y[4], m_x[5], m_y[5],
m_x[0], m_y[0], m_x[1], m_y[1],
&m_coord[0].x, &m_coord[0].y);
calc_intersection(m_x[4],
m_y[4],
m_x[5],
m_y[5],
m_x[0],
m_y[0],
m_x[1],
m_y[1],
&m_coord[0].x,
&m_coord[0].y);
calc_intersection(m_x[0], m_y[0], m_x[1], m_y[1],
m_x[2], m_y[2], m_x[3], m_y[3],
&m_coord[1].x, &m_coord[1].y);
calc_intersection(m_x[0],
m_y[0],
m_x[1],
m_y[1],
m_x[2],
m_y[2],
m_x[3],
m_y[3],
&m_coord[1].x,
&m_coord[1].y);
calc_intersection(m_x[2], m_y[2], m_x[3], m_y[3],
m_x[4], m_y[4], m_x[5], m_y[5],
&m_coord[2].x, &m_coord[2].y);
calc_intersection(m_x[2],
m_y[2],
m_x[3],
m_y[3],
m_x[4],
m_y[4],
m_x[5],
m_y[5],
&m_coord[2].x,
&m_coord[2].y);
m_cmd[3] = path_cmd_line_to;
m_cmd[4] = path_cmd_line_to;
m_cmd[5] = path_cmd_line_to;
@ -114,10 +140,7 @@ namespace agg
//--------------------------------------------------------------------
// Vertex Source Interface to feed the coordinates to the rasterizer
void rewind(unsigned)
{
m_vertex = 0;
}
void rewind(unsigned) { m_vertex = 0; }
//--------------------------------------------------------------------
unsigned vertex(double* x, double* y)
@ -166,7 +189,6 @@ namespace agg
unsigned m_vertex;
};
}
} // namespace agg
#endif

63
deps/agg/include/agg_span_gouraud_gray.h vendored
View file

@ -29,22 +29,18 @@
#include "agg_dda_line.h"
#include "agg_span_gouraud.h"
namespace agg
{
namespace agg {
//=======================================================span_gouraud_gray
template<class ColorT> class span_gouraud_gray : public span_gouraud<ColorT>
template<class ColorT>
class span_gouraud_gray : public span_gouraud<ColorT>
{
public:
typedef ColorT color_type;
typedef typename color_type::value_type value_type;
typedef span_gouraud<color_type> base_type;
typedef typename base_type::coord_type coord_type;
enum subpixel_scale_e
{
subpixel_shift = 4,
subpixel_scale = 1 << subpixel_shift
};
enum subpixel_scale_e { subpixel_shift = 4, subpixel_scale = 1 << subpixel_shift };
private:
//--------------------------------------------------------------------
@ -66,8 +62,10 @@ namespace agg
void calc(double y)
{
double k = (y - m_y1) * m_1dy;
if(k < 0.0) k = 0.0;
if(k > 1.0) k = 1.0;
if (k < 0.0)
k = 0.0;
if (k > 1.0)
k = 1.0;
m_v = m_v1 + iround(m_dv * k);
m_a = m_a1 + iround(m_da * k);
m_x = iround((m_x1 + m_dx * k) * subpixel_scale);
@ -86,18 +84,20 @@ namespace agg
int m_x;
};
public:
//--------------------------------------------------------------------
span_gouraud_gray() {}
span_gouraud_gray(const color_type& c1,
const color_type& c2,
const color_type& c3,
double x1, double y1,
double x2, double y2,
double x3, double y3,
double d = 0) :
base_type(c1, c2, c3, x1, y1, x2, y2, x3, y3, d)
double x1,
double y1,
double x2,
double y2,
double x3,
double y3,
double d = 0)
: base_type(c1, c2, c3, x1, y1, x2, y2, x3, y3, d)
{}
//--------------------------------------------------------------------
@ -108,9 +108,7 @@ namespace agg
m_y2 = int(coord[1].y);
m_swap = cross_product(coord[0].x, coord[0].y,
coord[2].x, coord[2].y,
coord[1].x, coord[1].y) < 0.0;
m_swap = cross_product(coord[0].x, coord[0].y, coord[2].x, coord[2].y, coord[1].x, coord[1].y) < 0.0;
m_c1.init(coord[0], coord[2]);
m_c2.init(coord[0], coord[1]);
@ -152,7 +150,8 @@ namespace agg
// and protect it from division by zero
//-------------------------
int nlen = std::abs(pc2->m_x - pc1->m_x);
if(nlen <= 0) nlen = 1;
if (nlen <= 0)
nlen = 1;
dda_line_interpolator<14> v(pc1->m_v, pc2->m_v, nlen);
dda_line_interpolator<14> a(pc1->m_a, pc2->m_a, nlen);
@ -180,8 +179,14 @@ namespace agg
{
vv = v.y();
va = a.y();
if(vv < 0) vv = 0; if(vv > lim) vv = lim;
if(va < 0) va = 0; if(va > lim) va = lim;
if (vv < 0)
vv = 0;
if (vv > lim)
vv = lim;
if (va < 0)
va = 0;
if (va > lim)
va = lim;
span->v = (value_type)vv;
span->a = (value_type)va;
v += subpixel_scale;
@ -215,8 +220,14 @@ namespace agg
{
vv = v.y();
va = a.y();
if(vv < 0) vv = 0; if(vv > lim) vv = lim;
if(va < 0) va = 0; if(va > lim) va = lim;
if (vv < 0)
vv = 0;
if (vv > lim)
vv = lim;
if (va < 0)
va = 0;
if (va > lim)
va = lim;
span->v = (value_type)vv;
span->a = (value_type)va;
v += subpixel_scale;
@ -226,7 +237,6 @@ namespace agg
}
}
private:
bool m_swap;
int m_y2;
@ -235,7 +245,6 @@ namespace agg
gray_calc m_c3;
};
}
} // namespace agg
#endif

82
deps/agg/include/agg_span_gouraud_rgba.h vendored
View file

@ -29,22 +29,18 @@
#include "agg_dda_line.h"
#include "agg_span_gouraud.h"
namespace agg
{
namespace agg {
//=======================================================span_gouraud_rgba
template<class ColorT> class span_gouraud_rgba : public span_gouraud<ColorT>
template<class ColorT>
class span_gouraud_rgba : public span_gouraud<ColorT>
{
public:
typedef ColorT color_type;
typedef typename ColorT::value_type value_type;
typedef span_gouraud<color_type> base_type;
typedef typename base_type::coord_type coord_type;
enum subpixel_scale_e
{
subpixel_shift = 4,
subpixel_scale = 1 << subpixel_shift
};
enum subpixel_scale_e { subpixel_shift = 4, subpixel_scale = 1 << subpixel_shift };
private:
//--------------------------------------------------------------------
@ -70,8 +66,10 @@ namespace agg
void calc(double y)
{
double k = (y - m_y1) * m_1dy;
if(k < 0.0) k = 0.0;
if(k > 1.0) k = 1.0;
if (k < 0.0)
k = 0.0;
if (k > 1.0)
k = 1.0;
m_r = m_r1 + iround(m_dr * k);
m_g = m_g1 + iround(m_dg * k);
m_b = m_b1 + iround(m_db * k);
@ -105,11 +103,14 @@ namespace agg
span_gouraud_rgba(const color_type& c1,
const color_type& c2,
const color_type& c3,
double x1, double y1,
double x2, double y2,
double x3, double y3,
double d = 0) :
base_type(c1, c2, c3, x1, y1, x2, y2, x3, y3, d)
double x1,
double y1,
double x2,
double y2,
double x3,
double y3,
double d = 0)
: base_type(c1, c2, c3, x1, y1, x2, y2, x3, y3, d)
{}
//--------------------------------------------------------------------
@ -120,9 +121,7 @@ namespace agg
m_y2 = int(coord[1].y);
m_swap = cross_product(coord[0].x, coord[0].y,
coord[2].x, coord[2].y,
coord[1].x, coord[1].y) < 0.0;
m_swap = cross_product(coord[0].x, coord[0].y, coord[2].x, coord[2].y, coord[1].x, coord[1].y) < 0.0;
m_rgba1.init(coord[0], coord[2]);
m_rgba2.init(coord[0], coord[1]);
@ -164,7 +163,8 @@ namespace agg
// and protect it from division by zero
//-------------------------
int nlen = std::abs(pc2->m_x - pc1->m_x);
if(nlen <= 0) nlen = 1;
if (nlen <= 0)
nlen = 1;
dda_line_interpolator<14> r(pc1->m_r, pc2->m_r, nlen);
dda_line_interpolator<14> g(pc1->m_g, pc2->m_g, nlen);
@ -198,10 +198,22 @@ namespace agg
vg = g.y();
vb = b.y();
va = a.y();
if(vr < 0) vr = 0; if(vr > lim) vr = lim;
if(vg < 0) vg = 0; if(vg > lim) vg = lim;
if(vb < 0) vb = 0; if(vb > lim) vb = lim;
if(va < 0) va = 0; if(va > lim) va = lim;
if (vr < 0)
vr = 0;
if (vr > lim)
vr = lim;
if (vg < 0)
vg = 0;
if (vg > lim)
vg = lim;
if (vb < 0)
vb = 0;
if (vb > lim)
vb = lim;
if (va < 0)
va = 0;
if (va > lim)
va = lim;
span->r = (value_type)vr;
span->g = (value_type)vg;
span->b = (value_type)vb;
@ -245,10 +257,22 @@ namespace agg
vg = g.y();
vb = b.y();
va = a.y();
if(vr < 0) vr = 0; if(vr > lim) vr = lim;
if(vg < 0) vg = 0; if(vg > lim) vg = lim;
if(vb < 0) vb = 0; if(vb > lim) vb = lim;
if(va < 0) va = 0; if(va > lim) va = lim;
if (vr < 0)
vr = 0;
if (vr > lim)
vr = lim;
if (vg < 0)
vg = 0;
if (vg > lim)
vg = lim;
if (vb < 0)
vb = 0;
if (vb > lim)
vb = lim;
if (va < 0)
va = 0;
if (va > lim)
va = lim;
span->r = (value_type)vr;
span->g = (value_type)vg;
span->b = (value_type)vb;
@ -270,8 +294,6 @@ namespace agg
rgba_calc m_rgba3;
};
}
} // namespace agg
#endif

152
deps/agg/include/agg_span_gradient.h vendored
View file

@ -23,35 +23,23 @@
#include "agg_math.h"
#include "agg_array.h"
namespace agg {
namespace agg
{
enum gradient_subpixel_scale_e
{
enum gradient_subpixel_scale_e {
gradient_subpixel_shift = 4, //-----gradient_subpixel_shift
gradient_subpixel_scale = 1 << gradient_subpixel_shift, //-----gradient_subpixel_scale
gradient_subpixel_mask = gradient_subpixel_scale - 1 //-----gradient_subpixel_mask
};
//==========================================================span_gradient
template<class ColorT,
class Interpolator,
class GradientF,
class ColorF>
template<class ColorT, class Interpolator, class GradientF, class ColorF>
class span_gradient
{
public:
typedef Interpolator interpolator_type;
typedef ColorT color_type;
enum downscale_shift_e
{
downscale_shift = interpolator_type::subpixel_shift -
gradient_subpixel_shift
};
enum downscale_shift_e { downscale_shift = interpolator_type::subpixel_shift - gradient_subpixel_shift };
//--------------------------------------------------------------------
span_gradient() {}
@ -60,12 +48,13 @@ namespace agg
span_gradient(interpolator_type& inter,
const GradientF& gradient_function,
const ColorF& color_function,
double d1, double d2) :
m_interpolator(&inter),
m_gradient_function(&gradient_function),
m_color_function(&color_function),
m_d1(iround(d1 * gradient_subpixel_scale)),
m_d2(iround(d2 * gradient_subpixel_scale))
double d1,
double d2)
: m_interpolator(&inter)
, m_gradient_function(&gradient_function)
, m_color_function(&color_function)
, m_d1(iround(d1 * gradient_subpixel_scale))
, m_d2(iround(d2 * gradient_subpixel_scale))
{}
//--------------------------------------------------------------------
@ -89,20 +78,21 @@ namespace agg
void generate(color_type* span, int x, int y, unsigned len)
{
int dd = m_d2 - m_d1;
if(dd < 1) dd = 1;
if (dd < 1)
dd = 1;
m_interpolator->begin(x + 0.5, y + 0.5, len);
do
{
m_interpolator->coordinates(&x, &y);
int d = m_gradient_function->calculate(x >> downscale_shift,
y >> downscale_shift, m_d2);
int d = m_gradient_function->calculate(x >> downscale_shift, y >> downscale_shift, m_d2);
d = ((d - m_d1) * (int)m_color_function->size()) / dd;
if(d < 0) d = 0;
if(d >= (int)m_color_function->size()) d = m_color_function->size() - 1;
if (d < 0)
d = 0;
if (d >= (int)m_color_function->size())
d = m_color_function->size() - 1;
*span++ = (*m_color_function)[d];
++(*m_interpolator);
}
while(--len);
} while (--len);
}
private:
@ -113,9 +103,6 @@ namespace agg
int m_d2;
};
//=====================================================gradient_linear_color
template<class ColorT>
struct gradient_linear_color
@ -123,15 +110,14 @@ namespace agg
typedef ColorT color_type;
gradient_linear_color() {}
gradient_linear_color(const color_type& c1, const color_type& c2,
unsigned size = 256) :
m_c1(c1), m_c2(c2), m_size(size) {}
gradient_linear_color(const color_type& c1, const color_type& c2, unsigned size = 256)
: m_c1(c1)
, m_c2(c2)
, m_size(size)
{}
unsigned size() const { return m_size; }
color_type operator [] (unsigned v) const
{
return m_c1.gradient(m_c2, double(v) / double(m_size - 1));
}
color_type operator[](unsigned v) const { return m_c1.gradient(m_c2, double(v) / double(m_size - 1)); }
void colors(const color_type& c1, const color_type& c2, unsigned size = 256)
{
@ -145,31 +131,19 @@ namespace agg
unsigned m_size;
};
//==========================================================gradient_circle
class gradient_circle
{
// Actually the same as radial. Just for compatibility
public:
static AGG_INLINE int calculate(int x, int y, int)
{
return int(fast_sqrt(x*x + y*y));
}
static AGG_INLINE int calculate(int x, int y, int) { return int(fast_sqrt(x * x + y * y)); }
};
//==========================================================gradient_radial
class gradient_radial
{
public:
static AGG_INLINE int calculate(int x, int y, int)
{
return int(fast_sqrt(x*x + y*y));
}
static AGG_INLINE int calculate(int x, int y, int) { return int(fast_sqrt(x * x + y * y)); }
};
//========================================================gradient_radial_d
@ -187,19 +161,19 @@ namespace agg
{
public:
//---------------------------------------------------------------------
gradient_radial_focus() :
m_r(100 * gradient_subpixel_scale),
m_fx(0),
m_fy(0)
gradient_radial_focus()
: m_r(100 * gradient_subpixel_scale)
, m_fx(0)
, m_fy(0)
{
update_values();
}
//---------------------------------------------------------------------
gradient_radial_focus(double r, double fx, double fy) :
m_r (iround(r * gradient_subpixel_scale)),
m_fx(iround(fx * gradient_subpixel_scale)),
m_fy(iround(fy * gradient_subpixel_scale))
gradient_radial_focus(double r, double fx, double fy)
: m_r(iround(r * gradient_subpixel_scale))
, m_fx(iround(fx * gradient_subpixel_scale))
, m_fy(iround(fy * gradient_subpixel_scale))
{
update_values();
}
@ -244,8 +218,20 @@ namespace agg
double d = (m_r2 - (m_fx2 + m_fy2));
if (d == 0)
{
if(m_fx) { if(m_fx < 0) ++m_fx; else --m_fx; }
if(m_fy) { if(m_fy < 0) ++m_fy; else --m_fy; }
if (m_fx)
{
if (m_fx < 0)
++m_fx;
else
--m_fx;
}
if (m_fy)
{
if (m_fy < 0)
++m_fy;
else
--m_fy;
}
m_fx2 = double(m_fx) * double(m_fx);
m_fy2 = double(m_fy) * double(m_fy);
d = (m_r2 - (m_fx2 + m_fy2));
@ -262,7 +248,6 @@ namespace agg
double m_mul;
};
//==============================================================gradient_x
class gradient_x
{
@ -270,7 +255,6 @@ namespace agg
static int calculate(int x, int, int) { return x; }
};
//==============================================================gradient_y
class gradient_y
{
@ -294,20 +278,14 @@ namespace agg
class gradient_xy
{
public:
static AGG_INLINE int calculate(int x, int y, int d)
{
return std::abs(x) * std::abs(y) / d;
}
static AGG_INLINE int calculate(int x, int y, int d) { return std::abs(x) * std::abs(y) / d; }
};
//========================================================gradient_sqrt_xy
class gradient_sqrt_xy
{
public:
static AGG_INLINE int calculate(int x, int y, int)
{
return fast_sqrt(std::abs(x) * std::abs(y));
}
static AGG_INLINE int calculate(int x, int y, int) { return fast_sqrt(std::abs(x) * std::abs(y)); }
};
//==========================================================gradient_conic
@ -321,16 +299,19 @@ namespace agg
};
//=================================================gradient_repeat_adaptor
template<class GradientF> class gradient_repeat_adaptor
template<class GradientF>
class gradient_repeat_adaptor
{
public:
gradient_repeat_adaptor(const GradientF& gradient) :
m_gradient(&gradient) {}
gradient_repeat_adaptor(const GradientF& gradient)
: m_gradient(&gradient)
{}
AGG_INLINE int calculate(int x, int y, int d) const
{
int ret = m_gradient->calculate(x, y, d) % d;
if(ret < 0) ret += d;
if (ret < 0)
ret += d;
return ret;
}
@ -339,18 +320,22 @@ namespace agg
};
//================================================gradient_reflect_adaptor
template<class GradientF> class gradient_reflect_adaptor
template<class GradientF>
class gradient_reflect_adaptor
{
public:
gradient_reflect_adaptor(const GradientF& gradient) :
m_gradient(&gradient) {}
gradient_reflect_adaptor(const GradientF& gradient)
: m_gradient(&gradient)
{}
AGG_INLINE int calculate(int x, int y, int d) const
{
int d2 = d << 1;
int ret = m_gradient->calculate(x, y, d) % d2;
if(ret < 0) ret += d2;
if(ret >= d) ret = d2 - ret;
if (ret < 0)
ret += d2;
if (ret >= d)
ret = d2 - ret;
return ret;
}
@ -358,7 +343,6 @@ namespace agg
const GradientF* m_gradient;
};
}
} // namespace agg
#endif

48
deps/agg/include/agg_span_gradient_alpha.h vendored
View file

@ -18,13 +18,9 @@
#include "agg_span_gradient.h"
namespace agg
{
namespace agg {
//======================================================span_gradient_alpha
template<class ColorT,
class Interpolator,
class GradientF,
class AlphaF>
template<class ColorT, class Interpolator, class GradientF, class AlphaF>
class span_gradient_alpha
{
public:
@ -32,11 +28,7 @@ namespace agg
typedef ColorT color_type;
typedef typename color_type::value_type alpha_type;
enum downscale_shift_e
{
downscale_shift = interpolator_type::subpixel_shift - gradient_subpixel_shift
};
enum downscale_shift_e { downscale_shift = interpolator_type::subpixel_shift - gradient_subpixel_shift };
//--------------------------------------------------------------------
span_gradient_alpha() {}
@ -45,12 +37,13 @@ namespace agg
span_gradient_alpha(interpolator_type& inter,
const GradientF& gradient_function,
const AlphaF& alpha_function,
double d1, double d2) :
m_interpolator(&inter),
m_gradient_function(&gradient_function),
m_alpha_function(&alpha_function),
m_d1(iround(d1 * gradient_subpixel_scale)),
m_d2(iround(d2 * gradient_subpixel_scale))
double d1,
double d2)
: m_interpolator(&inter)
, m_gradient_function(&gradient_function)
, m_alpha_function(&alpha_function)
, m_d1(iround(d1 * gradient_subpixel_scale))
, m_d2(iround(d2 * gradient_subpixel_scale))
{}
//--------------------------------------------------------------------
@ -74,21 +67,22 @@ namespace agg
void generate(color_type* span, int x, int y, unsigned len)
{
int dd = m_d2 - m_d1;
if(dd < 1) dd = 1;
if (dd < 1)
dd = 1;
m_interpolator->begin(x + 0.5, y + 0.5, len);
do
{
m_interpolator->coordinates(&x, &y);
int d = m_gradient_function->calculate(x >> downscale_shift,
y >> downscale_shift, m_d2);
int d = m_gradient_function->calculate(x >> downscale_shift, y >> downscale_shift, m_d2);
d = ((d - m_d1) * (int)m_alpha_function->size()) / dd;
if(d < 0) d = 0;
if(d >= (int)m_alpha_function->size()) d = m_alpha_function->size() - 1;
if (d < 0)
d = 0;
if (d >= (int)m_alpha_function->size())
d = m_alpha_function->size() - 1;
span->a = (*m_alpha_function)[d];
++span;
++(*m_interpolator);
}
while(--len);
} while (--len);
}
private:
@ -99,9 +93,9 @@ namespace agg
int m_d2;
};
//=======================================================gradient_alpha_x
template<class ColorT> struct gradient_alpha_x
template<class ColorT>
struct gradient_alpha_x
{
typedef typename ColorT::value_type alpha_type;
alpha_type operator[](alpha_type x) const { return x; }
@ -121,6 +115,6 @@ namespace agg
alpha_type operator[](alpha_type x) const { return 255 - x; }
};
}
} // namespace agg
#endif

114
deps/agg/include/agg_span_image_filter.h vendored
View file

@ -23,11 +23,11 @@
#include "agg_image_filters.h"
#include "agg_span_interpolator_linear.h"
namespace agg
{
namespace agg {
//-------------------------------------------------------span_image_filter
template<class Source, class Interpolator> class span_image_filter
template<class Source, class Interpolator>
class span_image_filter
{
public:
typedef Source source_type;
@ -35,16 +35,14 @@ namespace agg
//--------------------------------------------------------------------
span_image_filter() {}
span_image_filter(source_type& src,
interpolator_type& interpolator,
const image_filter_lut* filter) :
m_src(&src),
m_interpolator(&interpolator),
m_filter(filter),
m_dx_dbl(0.5),
m_dy_dbl(0.5),
m_dx_int(image_subpixel_scale / 2),
m_dy_int(image_subpixel_scale / 2)
span_image_filter(source_type& src, interpolator_type& interpolator, const image_filter_lut* filter)
: m_src(&src)
, m_interpolator(&interpolator)
, m_filter(filter)
, m_dx_dbl(0.5)
, m_dy_dbl(0.5)
, m_dx_int(image_subpixel_scale / 2)
, m_dy_int(image_subpixel_scale / 2)
{}
void attach(source_type& v) { m_src = &v; }
@ -86,13 +84,9 @@ namespace agg
unsigned m_dy_int;
};
//==============================================span_image_resample_affine
template<class Source>
class span_image_resample_affine :
public span_image_filter<Source, span_interpolator_linear<trans_affine> >
class span_image_resample_affine : public span_image_filter<Source, span_interpolator_linear<trans_affine>>
{
public:
typedef Source source_type;
@ -100,23 +94,20 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
//--------------------------------------------------------------------
span_image_resample_affine() :
m_scale_limit(200.0),
m_blur_x(1.0),
m_blur_y(1.0)
span_image_resample_affine()
: m_scale_limit(200.0)
, m_blur_x(1.0)
, m_blur_y(1.0)
{}
//--------------------------------------------------------------------
span_image_resample_affine(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, &filter),
m_scale_limit(200.0),
m_blur_x(1.0),
m_blur_y(1.0)
span_image_resample_affine(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
: base_type(src, inter, &filter)
, m_scale_limit(200.0)
, m_blur_x(1.0)
, m_blur_y(1.0)
{}
//--------------------------------------------------------------------
int scale_limit() const { return uround(m_scale_limit); }
void scale_limit(int v) { m_scale_limit = v; }
@ -142,17 +133,23 @@ namespace agg
scale_y = scale_y * m_scale_limit / (scale_x * scale_y);
}
if(scale_x < 1) scale_x = 1;
if(scale_y < 1) scale_y = 1;
if (scale_x < 1)
scale_x = 1;
if (scale_y < 1)
scale_y = 1;
if(scale_x > m_scale_limit) scale_x = m_scale_limit;
if(scale_y > m_scale_limit) scale_y = m_scale_limit;
if (scale_x > m_scale_limit)
scale_x = m_scale_limit;
if (scale_y > m_scale_limit)
scale_y = m_scale_limit;
scale_x *= m_blur_x;
scale_y *= m_blur_y;
if(scale_x < 1) scale_x = 1;
if(scale_y < 1) scale_y = 1;
if (scale_x < 1)
scale_x = 1;
if (scale_y < 1)
scale_y = 1;
m_rx = uround(scale_x * double(image_subpixel_scale));
m_rx_inv = uround(1.0 / scale_x * double(image_subpixel_scale));
@ -173,12 +170,9 @@ namespace agg
double m_blur_y;
};
//=====================================================span_image_resample
template<class Source, class Interpolator>
class span_image_resample :
public span_image_filter<Source, Interpolator>
class span_image_resample : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
@ -186,20 +180,18 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
//--------------------------------------------------------------------
span_image_resample() :
m_scale_limit(20),
m_blur_x(image_subpixel_scale),
m_blur_y(image_subpixel_scale)
span_image_resample()
: m_scale_limit(20)
, m_blur_x(image_subpixel_scale)
, m_blur_y(image_subpixel_scale)
{}
//--------------------------------------------------------------------
span_image_resample(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, &filter),
m_scale_limit(20),
m_blur_x(image_subpixel_scale),
m_blur_y(image_subpixel_scale)
span_image_resample(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
: base_type(src, inter, &filter)
, m_scale_limit(20)
, m_blur_x(image_subpixel_scale)
, m_blur_y(image_subpixel_scale)
{}
//--------------------------------------------------------------------
@ -211,14 +203,15 @@ namespace agg
double blur_y() const { return double(m_blur_y) / double(image_subpixel_scale); }
void blur_x(double v) { m_blur_x = uround(v * double(image_subpixel_scale)); }
void blur_y(double v) { m_blur_y = uround(v * double(image_subpixel_scale)); }
void blur(double v) { m_blur_x =
m_blur_y = uround(v * double(image_subpixel_scale)); }
void blur(double v) { m_blur_x = m_blur_y = uround(v * double(image_subpixel_scale)); }
protected:
AGG_INLINE void adjust_scale(int* rx, int* ry)
{
if(*rx < image_subpixel_scale) *rx = image_subpixel_scale;
if(*ry < image_subpixel_scale) *ry = image_subpixel_scale;
if (*rx < image_subpixel_scale)
*rx = image_subpixel_scale;
if (*ry < image_subpixel_scale)
*ry = image_subpixel_scale;
if (*rx > image_subpixel_scale * m_scale_limit)
{
*rx = image_subpixel_scale * m_scale_limit;
@ -229,8 +222,10 @@ namespace agg
}
*rx = (*rx * m_blur_x) >> image_subpixel_shift;
*ry = (*ry * m_blur_y) >> image_subpixel_shift;
if(*rx < image_subpixel_scale) *rx = image_subpixel_scale;
if(*ry < image_subpixel_scale) *ry = image_subpixel_scale;
if (*rx < image_subpixel_scale)
*rx = image_subpixel_scale;
if (*ry < image_subpixel_scale)
*ry = image_subpixel_scale;
}
int m_scale_limit;
@ -238,9 +233,6 @@ namespace agg
int m_blur_y;
};
}
} // namespace agg
#endif

297
deps/agg/include/agg_span_image_filter_gray.h vendored
View file

@ -27,14 +27,11 @@
#include "agg_color_gray.h"
#include "agg_span_image_filter.h"
namespace agg
{
namespace agg {
//==============================================span_image_filter_gray_nn
template<class Source, class Interpolator>
class span_image_filter_gray_nn :
public span_image_filter<Source, Interpolator>
class span_image_filter_gray_nn : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
@ -43,31 +40,23 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum base_scale_e
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_gray_nn() {}
span_image_filter_gray_nn(source_type& src,
interpolator_type& inter) :
base_type(src, inter, 0)
span_image_filter_gray_nn(source_type& src, interpolator_type& inter)
: base_type(src, inter, 0)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
do
{
base_type::interpolator().coordinates(&x, &y);
span->v = *(const value_type*)
base_type::source().span(x >> image_subpixel_shift,
y >> image_subpixel_shift,
1);
span->v =
*(const value_type*)base_type::source().span(x >> image_subpixel_shift, y >> image_subpixel_shift, 1);
span->a = base_mask;
++span;
++base_type::interpolator();
@ -75,12 +64,9 @@ namespace agg
}
};
//=========================================span_image_filter_gray_bilinear
template<class Source, class Interpolator>
class span_image_filter_gray_bilinear :
public span_image_filter<Source, Interpolator>
class span_image_filter_gray_bilinear : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
@ -89,25 +75,18 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum base_scale_e
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_gray_bilinear() {}
span_image_filter_gray_bilinear(source_type& src,
interpolator_type& inter) :
base_type(src, inter, 0)
span_image_filter_gray_bilinear(source_type& src, interpolator_type& inter)
: base_type(src, inter, 0)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
calc_type fg;
const value_type* fg_ptr;
do
@ -149,11 +128,9 @@ namespace agg
}
};
//====================================span_image_filter_gray_bilinear_clip
template<class Source, class Interpolator>
class span_image_filter_gray_bilinear_clip :
public span_image_filter<Source, Interpolator>
class span_image_filter_gray_bilinear_clip : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
@ -162,19 +139,13 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum base_scale_e
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_gray_bilinear_clip() {}
span_image_filter_gray_bilinear_clip(source_type& src,
const color_type& back_color,
interpolator_type& inter) :
base_type(src, inter, 0),
m_back_color(back_color)
span_image_filter_gray_bilinear_clip(source_type& src, const color_type& back_color, interpolator_type& inter)
: base_type(src, inter, 0)
, m_back_color(back_color)
{}
const color_type& background_color() const { return m_back_color; }
void background_color(const color_type& v) { m_back_color = v; }
@ -182,8 +153,7 @@ namespace agg
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
calc_type fg;
calc_type src_alpha;
value_type back_v = m_back_color.v;
@ -207,8 +177,7 @@ namespace agg
int x_lr = x_hr >> image_subpixel_shift;
int y_lr = y_hr >> image_subpixel_shift;
if(x_lr >= 0 && y_lr >= 0 &&
x_lr < maxx && y_lr < maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr < maxx && y_lr < maxy)
{
fg = image_subpixel_scale * image_subpixel_scale / 2;
@ -231,27 +200,22 @@ namespace agg
else
{
unsigned weight;
if(x_lr < -1 || y_lr < -1 ||
x_lr > maxx || y_lr > maxy)
if (x_lr < -1 || y_lr < -1 || x_lr > maxx || y_lr > maxy)
{
fg = back_v;
src_alpha = back_a;
}
else
{
fg =
src_alpha = image_subpixel_scale * image_subpixel_scale / 2;
fg = src_alpha = image_subpixel_scale * image_subpixel_scale / 2;
x_hr &= image_subpixel_mask;
y_hr &= image_subpixel_mask;
weight = (image_subpixel_scale - x_hr) *
(image_subpixel_scale - y_hr);
if(x_lr >= 0 && y_lr >= 0 &&
x_lr <= maxx && y_lr <= maxy)
weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg += weight *
*((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
fg += weight * *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
src_alpha += weight * base_mask;
}
else
@ -263,11 +227,9 @@ namespace agg
x_lr++;
weight = x_hr * (image_subpixel_scale - y_hr);
if(x_lr >= 0 && y_lr >= 0 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg += weight *
*((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
fg += weight * *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
src_alpha += weight * base_mask;
}
else
@ -280,11 +242,9 @@ namespace agg
y_lr++;
weight = (image_subpixel_scale - x_hr) * y_hr;
if(x_lr >= 0 && y_lr >= 0 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg += weight *
*((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
fg += weight * *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
src_alpha += weight * base_mask;
}
else
@ -296,11 +256,9 @@ namespace agg
x_lr++;
weight = x_hr * y_hr;
if(x_lr >= 0 && y_lr >= 0 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg += weight *
*((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
fg += weight * *((const value_type*)base_type::source().row_ptr(y_lr) + x_lr);
src_alpha += weight * base_mask;
}
else
@ -321,16 +279,14 @@ namespace agg
} while (--len);
}
private:
color_type m_back_color;
};
//==============================================span_image_filter_gray_2x2
template<class Source, class Interpolator>
class span_image_filter_gray_2x2 :
public span_image_filter<Source, Interpolator>
class span_image_filter_gray_2x2 : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
@ -339,33 +295,24 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum base_scale_e
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_gray_2x2() {}
span_image_filter_gray_2x2(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, &filter)
span_image_filter_gray_2x2(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
: base_type(src, inter, &filter)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
calc_type fg;
const value_type* fg_ptr;
const int16* weight_array = base_type::filter().weight_array() +
((base_type::filter().diameter()/2 - 1) <<
image_subpixel_shift);
const int16* weight_array =
base_type::filter().weight_array() + ((base_type::filter().diameter() / 2 - 1) << image_subpixel_shift);
do
{
int x_hr;
@ -386,35 +333,28 @@ namespace agg
y_hr &= image_subpixel_mask;
fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, 2);
weight = (weight_array[x_hr + image_subpixel_scale] *
weight_array[y_hr + image_subpixel_scale] +
weight = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr + image_subpixel_scale] +
image_filter_scale / 2) >>
image_filter_shift;
fg += weight * *fg_ptr;
fg_ptr = (const value_type*)base_type::source().next_x();
weight = (weight_array[x_hr] *
weight_array[y_hr + image_subpixel_scale] +
image_filter_scale / 2) >>
weight = (weight_array[x_hr] * weight_array[y_hr + image_subpixel_scale] + image_filter_scale / 2) >>
image_filter_shift;
fg += weight * *fg_ptr;
fg_ptr = (const value_type*)base_type::source().next_y();
weight = (weight_array[x_hr + image_subpixel_scale] *
weight_array[y_hr] +
image_filter_scale / 2) >>
weight = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr] + image_filter_scale / 2) >>
image_filter_shift;
fg += weight * *fg_ptr;
fg_ptr = (const value_type*)base_type::source().next_x();
weight = (weight_array[x_hr] *
weight_array[y_hr] +
image_filter_scale / 2) >>
image_filter_shift;
weight = (weight_array[x_hr] * weight_array[y_hr] + image_filter_scale / 2) >> image_filter_shift;
fg += weight * *fg_ptr;
fg >>= image_filter_shift;
if(fg > base_mask) fg = base_mask;
if (fg > base_mask)
fg = base_mask;
span->v = (value_type)fg;
span->a = base_mask;
@ -424,12 +364,9 @@ namespace agg
}
};
//==================================================span_image_filter_gray
template<class Source, class Interpolator>
class span_image_filter_gray :
public span_image_filter<Source, Interpolator>
class span_image_filter_gray : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
@ -438,25 +375,18 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum base_scale_e
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_gray() {}
span_image_filter_gray(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, &filter)
span_image_filter_gray(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
: base_type(src, inter, &filter)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
int fg;
const value_type* fg_ptr;
@ -487,9 +417,7 @@ namespace agg
unsigned y_count = diameter;
y_hr = image_subpixel_mask - (y_hr & image_subpixel_mask);
fg_ptr = (const value_type*)base_type::source().span(x_lr + start,
y_lr + start,
diameter);
fg_ptr = (const value_type*)base_type::source().span(x_lr + start, y_lr + start, diameter);
for (;;)
{
x_count = diameter;
@ -497,23 +425,24 @@ namespace agg
x_hr = image_subpixel_mask - x_fract;
for (;;)
{
fg += *fg_ptr *
((weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
image_filter_shift);
if(--x_count == 0) break;
fg += *fg_ptr * ((weight_y * weight_array[x_hr] + image_filter_scale / 2) >> image_filter_shift);
if (--x_count == 0)
break;
x_hr += image_subpixel_scale;
fg_ptr = (const value_type*)base_type::source().next_x();
}
if(--y_count == 0) break;
if (--y_count == 0)
break;
y_hr += image_subpixel_scale;
fg_ptr = (const value_type*)base_type::source().next_y();
}
fg >>= image_filter_shift;
if(fg < 0) fg = 0;
if(fg > base_mask) fg = base_mask;
if (fg < 0)
fg = 0;
if (fg > base_mask)
fg = base_mask;
span->v = (value_type)fg;
span->a = base_mask;
@ -524,12 +453,9 @@ namespace agg
}
};
//=========================================span_image_resample_gray_affine
template<class Source>
class span_image_resample_gray_affine :
public span_image_resample_affine<Source>
class span_image_resample_gray_affine : public span_image_resample_affine<Source>
{
public:
typedef Source source_type;
@ -538,8 +464,7 @@ namespace agg
typedef typename base_type::interpolator_type interpolator_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::long_type long_type;
enum base_scale_e
{
enum base_scale_e {
base_shift = color_type::base_shift,
base_mask = color_type::base_mask,
downscale_shift = image_filter_shift
@ -547,18 +472,14 @@ namespace agg
//--------------------------------------------------------------------
span_image_resample_gray_affine() {}
span_image_resample_gray_affine(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, filter)
span_image_resample_gray_affine(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
: base_type(src, inter, filter)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
long_type fg;
@ -566,9 +487,7 @@ namespace agg
int filter_scale = diameter << image_subpixel_shift;
int radius_x = (diameter * base_type::m_rx) >> 1;
int radius_y = (diameter * base_type::m_ry) >> 1;
int len_x_lr =
(diameter * base_type::m_rx + image_subpixel_mask) >>
image_subpixel_shift;
int len_x_lr = (diameter * base_type::m_rx + image_subpixel_mask) >> image_subpixel_shift;
const int16* weight_array = base_type::filter().weight_array();
@ -582,42 +501,41 @@ namespace agg
fg = image_filter_scale / 2;
int y_lr = y >> image_subpixel_shift;
int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) *
base_type::m_ry_inv) >>
image_subpixel_shift;
int y_hr =
((image_subpixel_mask - (y & image_subpixel_mask)) * base_type::m_ry_inv) >> image_subpixel_shift;
int total_weight = 0;
int x_lr = x >> image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) *
base_type::m_rx_inv) >>
image_subpixel_shift;
int x_hr =
((image_subpixel_mask - (x & image_subpixel_mask)) * base_type::m_rx_inv) >> image_subpixel_shift;
int x_hr2 = x_hr;
const value_type* fg_ptr =
(const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
for (;;)
{
int weight_y = weight_array[y_hr];
x_hr = x_hr2;
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
downscale_shift;
int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
fg += *fg_ptr * weight;
total_weight += weight;
x_hr += base_type::m_rx_inv;
if(x_hr >= filter_scale) break;
if (x_hr >= filter_scale)
break;
fg_ptr = (const value_type*)base_type::source().next_x();
}
y_hr += base_type::m_ry_inv;
if(y_hr >= filter_scale) break;
if (y_hr >= filter_scale)
break;
fg_ptr = (const value_type*)base_type::source().next_y();
}
fg /= total_weight;
if(fg < 0) fg = 0;
if(fg > base_mask) fg = base_mask;
if (fg < 0)
fg = 0;
if (fg > base_mask)
fg = base_mask;
span->v = (value_type)fg;
span->a = base_mask;
@ -628,12 +546,9 @@ namespace agg
}
};
//================================================span_image_resample_gray
template<class Source, class Interpolator>
class span_image_resample_gray :
public span_image_resample<Source, Interpolator>
class span_image_resample_gray : public span_image_resample<Source, Interpolator>
{
public:
typedef Source source_type;
@ -642,8 +557,7 @@ namespace agg
typedef span_image_resample<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::long_type long_type;
enum base_scale_e
{
enum base_scale_e {
base_shift = color_type::base_shift,
base_mask = color_type::base_mask,
downscale_shift = image_filter_shift
@ -651,17 +565,14 @@ namespace agg
//--------------------------------------------------------------------
span_image_resample_gray() {}
span_image_resample_gray(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, filter)
span_image_resample_gray(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
: base_type(src, inter, filter)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
long_type fg;
int diameter = base_type::filter().diameter();
@ -683,9 +594,7 @@ namespace agg
int radius_x = (diameter * rx) >> 1;
int radius_y = (diameter * ry) >> 1;
int len_x_lr =
(diameter * rx + image_subpixel_mask) >>
image_subpixel_shift;
int len_x_lr = (diameter * rx + image_subpixel_mask) >> image_subpixel_shift;
x += base_type::filter_dx_int() - radius_x;
y += base_type::filter_dy_int() - radius_y;
@ -693,17 +602,12 @@ namespace agg
fg = image_filter_scale / 2;
int y_lr = y >> image_subpixel_shift;
int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) *
ry_inv) >>
image_subpixel_shift;
int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * ry_inv) >> image_subpixel_shift;
int total_weight = 0;
int x_lr = x >> image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) *
rx_inv) >>
image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * rx_inv) >> image_subpixel_shift;
int x_hr2 = x_hr;
const value_type* fg_ptr =
(const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
for (;;)
{
@ -711,23 +615,25 @@ namespace agg
x_hr = x_hr2;
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
downscale_shift;
int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
fg += *fg_ptr * weight;
total_weight += weight;
x_hr += rx_inv;
if(x_hr >= filter_scale) break;
if (x_hr >= filter_scale)
break;
fg_ptr = (const value_type*)base_type::source().next_x();
}
y_hr += ry_inv;
if(y_hr >= filter_scale) break;
if (y_hr >= filter_scale)
break;
fg_ptr = (const value_type*)base_type::source().next_y();
}
fg /= total_weight;
if(fg < 0) fg = 0;
if(fg > base_mask) fg = base_mask;
if (fg < 0)
fg = 0;
if (fg > base_mask)
fg = base_mask;
span->v = (value_type)fg;
span->a = base_mask;
@ -738,11 +644,6 @@ namespace agg
}
};
}
} // namespace agg
#endif

361
deps/agg/include/agg_span_image_filter_rgb.h vendored
View file

@ -27,14 +27,11 @@
#include "agg_color_rgba.h"
#include "agg_span_image_filter.h"
namespace agg
{
namespace agg {
//===============================================span_image_filter_rgb_nn
template<class Source, class Interpolator>
class span_image_filter_rgb_nn :
public span_image_filter<Source, Interpolator>
class span_image_filter_rgb_nn : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
@ -44,31 +41,23 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum base_scale_e
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_rgb_nn() {}
span_image_filter_rgb_nn(source_type& src,
interpolator_type& inter) :
base_type(src, inter, 0)
span_image_filter_rgb_nn(source_type& src, interpolator_type& inter)
: base_type(src, inter, 0)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
do
{
base_type::interpolator().coordinates(&x, &y);
const value_type* fg_ptr = (const value_type*)
base_type::source().span(x >> image_subpixel_shift,
y >> image_subpixel_shift,
1);
const value_type* fg_ptr =
(const value_type*)base_type::source().span(x >> image_subpixel_shift, y >> image_subpixel_shift, 1);
span->r = fg_ptr[order_type::R];
span->g = fg_ptr[order_type::G];
span->b = fg_ptr[order_type::B];
@ -80,12 +69,9 @@ namespace agg
}
};
//==========================================span_image_filter_rgb_bilinear
template<class Source, class Interpolator>
class span_image_filter_rgb_bilinear :
public span_image_filter<Source, Interpolator>
class span_image_filter_rgb_bilinear : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
@ -95,25 +81,18 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum base_scale_e
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_rgb_bilinear() {}
span_image_filter_rgb_bilinear(source_type& src,
interpolator_type& inter) :
base_type(src, inter, 0)
span_image_filter_rgb_bilinear(source_type& src, interpolator_type& inter)
: base_type(src, inter, 0)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
calc_type fg[3];
const value_type* fg_ptr;
do
@ -131,16 +110,13 @@ namespace agg
unsigned weight;
fg[0] =
fg[1] =
fg[2] = image_subpixel_scale * image_subpixel_scale / 2;
fg[0] = fg[1] = fg[2] = image_subpixel_scale * image_subpixel_scale / 2;
x_hr &= image_subpixel_mask;
y_hr &= image_subpixel_mask;
fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, 2);
weight = (image_subpixel_scale - x_hr) *
(image_subpixel_scale - y_hr);
weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr;
@ -175,12 +151,9 @@ namespace agg
}
};
//=====================================span_image_filter_rgb_bilinear_clip
template<class Source, class Interpolator>
class span_image_filter_rgb_bilinear_clip :
public span_image_filter<Source, Interpolator>
class span_image_filter_rgb_bilinear_clip : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
@ -190,19 +163,13 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum base_scale_e
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_rgb_bilinear_clip() {}
span_image_filter_rgb_bilinear_clip(source_type& src,
const color_type& back_color,
interpolator_type& inter) :
base_type(src, inter, 0),
m_back_color(back_color)
span_image_filter_rgb_bilinear_clip(source_type& src, const color_type& back_color, interpolator_type& inter)
: base_type(src, inter, 0)
, m_back_color(back_color)
{}
const color_type& background_color() const { return m_back_color; }
void background_color(const color_type& v) { m_back_color = v; }
@ -210,8 +177,7 @@ namespace agg
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
calc_type fg[3];
calc_type src_alpha;
value_type back_r = m_back_color.r;
@ -238,21 +204,16 @@ namespace agg
int y_lr = y_hr >> image_subpixel_shift;
unsigned weight;
if(x_lr >= 0 && y_lr >= 0 &&
x_lr < maxx && y_lr < maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr < maxx && y_lr < maxy)
{
fg[0] =
fg[1] =
fg[2] = image_subpixel_scale * image_subpixel_scale / 2;
fg[0] = fg[1] = fg[2] = image_subpixel_scale * image_subpixel_scale / 2;
x_hr &= image_subpixel_mask;
y_hr &= image_subpixel_mask;
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
weight = (image_subpixel_scale - x_hr) *
(image_subpixel_scale - y_hr);
weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr++;
@ -263,8 +224,7 @@ namespace agg
fg[2] += weight * *fg_ptr++;
++y_lr;
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
weight = (image_subpixel_scale - x_hr) * y_hr;
fg[0] += weight * *fg_ptr++;
@ -283,8 +243,7 @@ namespace agg
}
else
{
if(x_lr < -1 || y_lr < -1 ||
x_lr > maxx || y_lr > maxy)
if (x_lr < -1 || y_lr < -1 || x_lr > maxx || y_lr > maxy)
{
fg[order_type::R] = back_r;
fg[order_type::G] = back_g;
@ -293,21 +252,15 @@ namespace agg
}
else
{
fg[0] =
fg[1] =
fg[2] =
src_alpha = image_subpixel_scale * image_subpixel_scale / 2;
fg[0] = fg[1] = fg[2] = src_alpha = image_subpixel_scale * image_subpixel_scale / 2;
x_hr &= image_subpixel_mask;
y_hr &= image_subpixel_mask;
weight = (image_subpixel_scale - x_hr) *
(image_subpixel_scale - y_hr);
if(x_lr >= 0 && y_lr >= 0 &&
x_lr <= maxx && y_lr <= maxy)
weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
@ -325,11 +278,9 @@ namespace agg
x_lr++;
weight = x_hr * (image_subpixel_scale - y_hr);
if(x_lr >= 0 && y_lr >= 0 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
@ -348,11 +299,9 @@ namespace agg
y_lr++;
weight = (image_subpixel_scale - x_hr) * y_hr;
if(x_lr >= 0 && y_lr >= 0 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
@ -370,11 +319,9 @@ namespace agg
x_lr++;
weight = x_hr * y_hr;
if(x_lr >= 0 && y_lr >= 0 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + x_lr + x_lr + x_lr;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
@ -405,16 +352,14 @@ namespace agg
} while (--len);
}
private:
color_type m_back_color;
};
//===============================================span_image_filter_rgb_2x2
template<class Source, class Interpolator>
class span_image_filter_rgb_2x2 :
public span_image_filter<Source, Interpolator>
class span_image_filter_rgb_2x2 : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
@ -424,33 +369,24 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum base_scale_e
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_rgb_2x2() {}
span_image_filter_rgb_2x2(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, &filter)
span_image_filter_rgb_2x2(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
: base_type(src, inter, &filter)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
calc_type fg[3];
const value_type* fg_ptr;
const int16* weight_array = base_type::filter().weight_array() +
((base_type::filter().diameter()/2 - 1) <<
image_subpixel_shift);
const int16* weight_array =
base_type::filter().weight_array() + ((base_type::filter().diameter() / 2 - 1) << image_subpixel_shift);
do
{
int x_hr;
@ -471,8 +407,7 @@ namespace agg
y_hr &= image_subpixel_mask;
fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, 2);
weight = (weight_array[x_hr + image_subpixel_scale] *
weight_array[y_hr + image_subpixel_scale] +
weight = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr + image_subpixel_scale] +
image_filter_scale / 2) >>
image_filter_shift;
fg[0] += weight * *fg_ptr++;
@ -480,28 +415,21 @@ namespace agg
fg[2] += weight * *fg_ptr;
fg_ptr = (const value_type*)base_type::source().next_x();
weight = (weight_array[x_hr] *
weight_array[y_hr + image_subpixel_scale] +
image_filter_scale / 2) >>
weight = (weight_array[x_hr] * weight_array[y_hr + image_subpixel_scale] + image_filter_scale / 2) >>
image_filter_shift;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr;
fg_ptr = (const value_type*)base_type::source().next_y();
weight = (weight_array[x_hr + image_subpixel_scale] *
weight_array[y_hr] +
image_filter_scale / 2) >>
weight = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr] + image_filter_scale / 2) >>
image_filter_shift;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr;
fg_ptr = (const value_type*)base_type::source().next_x();
weight = (weight_array[x_hr] *
weight_array[y_hr] +
image_filter_scale / 2) >>
image_filter_shift;
weight = (weight_array[x_hr] * weight_array[y_hr] + image_filter_scale / 2) >> image_filter_shift;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr;
@ -510,9 +438,12 @@ namespace agg
fg[1] >>= image_filter_shift;
fg[2] >>= image_filter_shift;
if(fg[order_type::R] > base_mask) fg[order_type::R] = base_mask;
if(fg[order_type::G] > base_mask) fg[order_type::G] = base_mask;
if(fg[order_type::B] > base_mask) fg[order_type::B] = base_mask;
if (fg[order_type::R] > base_mask)
fg[order_type::R] = base_mask;
if (fg[order_type::G] > base_mask)
fg[order_type::G] = base_mask;
if (fg[order_type::B] > base_mask)
fg[order_type::B] = base_mask;
span->r = (value_type)fg[order_type::R];
span->g = (value_type)fg[order_type::G];
@ -526,12 +457,9 @@ namespace agg
}
};
//===================================================span_image_filter_rgb
template<class Source, class Interpolator>
class span_image_filter_rgb :
public span_image_filter<Source, Interpolator>
class span_image_filter_rgb : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
@ -541,25 +469,18 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum base_scale_e
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_rgb() {}
span_image_filter_rgb(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, &filter)
span_image_filter_rgb(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
: base_type(src, inter, &filter)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
int fg[3];
const value_type* fg_ptr;
@ -590,9 +511,7 @@ namespace agg
unsigned y_count = diameter;
y_hr = image_subpixel_mask - (y_hr & image_subpixel_mask);
fg_ptr = (const value_type*)base_type::source().span(x_lr + start,
y_lr + start,
diameter);
fg_ptr = (const value_type*)base_type::source().span(x_lr + start, y_lr + start, diameter);
for (;;)
{
x_count = diameter;
@ -600,20 +519,20 @@ namespace agg
x_hr = image_subpixel_mask - x_fract;
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
image_filter_shift;
int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> image_filter_shift;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr;
if(--x_count == 0) break;
if (--x_count == 0)
break;
x_hr += image_subpixel_scale;
fg_ptr = (const value_type*)base_type::source().next_x();
}
if(--y_count == 0) break;
if (--y_count == 0)
break;
y_hr += image_subpixel_scale;
fg_ptr = (const value_type*)base_type::source().next_y();
}
@ -622,13 +541,19 @@ namespace agg
fg[1] >>= image_filter_shift;
fg[2] >>= image_filter_shift;
if(fg[0] < 0) fg[0] = 0;
if(fg[1] < 0) fg[1] = 0;
if(fg[2] < 0) fg[2] = 0;
if (fg[0] < 0)
fg[0] = 0;
if (fg[1] < 0)
fg[1] = 0;
if (fg[2] < 0)
fg[2] = 0;
if(fg[order_type::R] > base_mask) fg[order_type::R] = base_mask;
if(fg[order_type::G] > base_mask) fg[order_type::G] = base_mask;
if(fg[order_type::B] > base_mask) fg[order_type::B] = base_mask;
if (fg[order_type::R] > base_mask)
fg[order_type::R] = base_mask;
if (fg[order_type::G] > base_mask)
fg[order_type::G] = base_mask;
if (fg[order_type::B] > base_mask)
fg[order_type::B] = base_mask;
span->r = (value_type)fg[order_type::R];
span->g = (value_type)fg[order_type::G];
@ -642,12 +567,9 @@ namespace agg
}
};
//==========================================span_image_resample_rgb_affine
template<class Source>
class span_image_resample_rgb_affine :
public span_image_resample_affine<Source>
class span_image_resample_rgb_affine : public span_image_resample_affine<Source>
{
public:
typedef Source source_type;
@ -657,8 +579,7 @@ namespace agg
typedef typename base_type::interpolator_type interpolator_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::long_type long_type;
enum base_scale_e
{
enum base_scale_e {
base_shift = color_type::base_shift,
base_mask = color_type::base_mask,
downscale_shift = image_filter_shift
@ -666,18 +587,14 @@ namespace agg
//--------------------------------------------------------------------
span_image_resample_rgb_affine() {}
span_image_resample_rgb_affine(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, filter)
span_image_resample_rgb_affine(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
: base_type(src, inter, filter)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
long_type fg[3];
@ -685,9 +602,7 @@ namespace agg
int filter_scale = diameter << image_subpixel_shift;
int radius_x = (diameter * base_type::m_rx) >> 1;
int radius_y = (diameter * base_type::m_ry) >> 1;
int len_x_lr =
(diameter * base_type::m_rx + image_subpixel_mask) >>
image_subpixel_shift;
int len_x_lr = (diameter * base_type::m_rx + image_subpixel_mask) >> image_subpixel_shift;
const int16* weight_array = base_type::filter().weight_array();
@ -701,38 +616,35 @@ namespace agg
fg[0] = fg[1] = fg[2] = image_filter_scale / 2;
int y_lr = y >> image_subpixel_shift;
int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) *
base_type::m_ry_inv) >>
image_subpixel_shift;
int y_hr =
((image_subpixel_mask - (y & image_subpixel_mask)) * base_type::m_ry_inv) >> image_subpixel_shift;
int total_weight = 0;
int x_lr = x >> image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) *
base_type::m_rx_inv) >>
image_subpixel_shift;
int x_hr =
((image_subpixel_mask - (x & image_subpixel_mask)) * base_type::m_rx_inv) >> image_subpixel_shift;
int x_hr2 = x_hr;
const value_type* fg_ptr =
(const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
for (;;)
{
int weight_y = weight_array[y_hr];
x_hr = x_hr2;
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
downscale_shift;
int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
fg[0] += *fg_ptr++ * weight;
fg[1] += *fg_ptr++ * weight;
fg[2] += *fg_ptr * weight;
total_weight += weight;
x_hr += base_type::m_rx_inv;
if(x_hr >= filter_scale) break;
if (x_hr >= filter_scale)
break;
fg_ptr = (const value_type*)base_type::source().next_x();
}
y_hr += base_type::m_ry_inv;
if(y_hr >= filter_scale) break;
if (y_hr >= filter_scale)
break;
fg_ptr = (const value_type*)base_type::source().next_y();
}
@ -740,13 +652,19 @@ namespace agg
fg[1] /= total_weight;
fg[2] /= total_weight;
if(fg[0] < 0) fg[0] = 0;
if(fg[1] < 0) fg[1] = 0;
if(fg[2] < 0) fg[2] = 0;
if (fg[0] < 0)
fg[0] = 0;
if (fg[1] < 0)
fg[1] = 0;
if (fg[2] < 0)
fg[2] = 0;
if(fg[order_type::R] > base_mask) fg[order_type::R] = base_mask;
if(fg[order_type::G] > base_mask) fg[order_type::G] = base_mask;
if(fg[order_type::B] > base_mask) fg[order_type::B] = base_mask;
if (fg[order_type::R] > base_mask)
fg[order_type::R] = base_mask;
if (fg[order_type::G] > base_mask)
fg[order_type::G] = base_mask;
if (fg[order_type::B] > base_mask)
fg[order_type::B] = base_mask;
span->r = (value_type)fg[order_type::R];
span->g = (value_type)fg[order_type::G];
@ -759,12 +677,9 @@ namespace agg
}
};
//=================================================span_image_resample_rgb
template<class Source, class Interpolator>
class span_image_resample_rgb :
public span_image_resample<Source, Interpolator>
class span_image_resample_rgb : public span_image_resample<Source, Interpolator>
{
public:
typedef Source source_type;
@ -774,8 +689,7 @@ namespace agg
typedef span_image_resample<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::long_type long_type;
enum base_scale_e
{
enum base_scale_e {
base_shift = color_type::base_shift,
base_mask = color_type::base_mask,
downscale_shift = image_filter_shift
@ -783,17 +697,14 @@ namespace agg
//--------------------------------------------------------------------
span_image_resample_rgb() {}
span_image_resample_rgb(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, filter)
span_image_resample_rgb(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
: base_type(src, inter, filter)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
long_type fg[3];
int diameter = base_type::filter().diameter();
@ -815,9 +726,7 @@ namespace agg
int radius_x = (diameter * rx) >> 1;
int radius_y = (diameter * ry) >> 1;
int len_x_lr =
(diameter * rx + image_subpixel_mask) >>
image_subpixel_shift;
int len_x_lr = (diameter * rx + image_subpixel_mask) >> image_subpixel_shift;
x += base_type::filter_dx_int() - radius_x;
y += base_type::filter_dy_int() - radius_y;
@ -825,17 +734,12 @@ namespace agg
fg[0] = fg[1] = fg[2] = image_filter_scale / 2;
int y_lr = y >> image_subpixel_shift;
int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) *
ry_inv) >>
image_subpixel_shift;
int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * ry_inv) >> image_subpixel_shift;
int total_weight = 0;
int x_lr = x >> image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) *
rx_inv) >>
image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * rx_inv) >> image_subpixel_shift;
int x_hr2 = x_hr;
const value_type* fg_ptr =
(const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
for (;;)
{
@ -843,19 +747,19 @@ namespace agg
x_hr = x_hr2;
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
downscale_shift;
int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
fg[0] += *fg_ptr++ * weight;
fg[1] += *fg_ptr++ * weight;
fg[2] += *fg_ptr * weight;
total_weight += weight;
x_hr += rx_inv;
if(x_hr >= filter_scale) break;
if (x_hr >= filter_scale)
break;
fg_ptr = (const value_type*)base_type::source().next_x();
}
y_hr += ry_inv;
if(y_hr >= filter_scale) break;
if (y_hr >= filter_scale)
break;
fg_ptr = (const value_type*)base_type::source().next_y();
}
@ -863,13 +767,19 @@ namespace agg
fg[1] /= total_weight;
fg[2] /= total_weight;
if(fg[0] < 0) fg[0] = 0;
if(fg[1] < 0) fg[1] = 0;
if(fg[2] < 0) fg[2] = 0;
if (fg[0] < 0)
fg[0] = 0;
if (fg[1] < 0)
fg[1] = 0;
if (fg[2] < 0)
fg[2] = 0;
if(fg[order_type::R] > base_mask) fg[order_type::R] = base_mask;
if(fg[order_type::G] > base_mask) fg[order_type::G] = base_mask;
if(fg[order_type::B] > base_mask) fg[order_type::B] = base_mask;
if (fg[order_type::R] > base_mask)
fg[order_type::R] = base_mask;
if (fg[order_type::G] > base_mask)
fg[order_type::G] = base_mask;
if (fg[order_type::B] > base_mask)
fg[order_type::B] = base_mask;
span->r = (value_type)fg[order_type::R];
span->g = (value_type)fg[order_type::G];
@ -882,11 +792,6 @@ namespace agg
}
};
}
} // namespace agg
#endif

383
deps/agg/include/agg_span_image_filter_rgba.h vendored
View file

@ -27,14 +27,11 @@
#include "agg_color_rgba.h"
#include "agg_span_image_filter.h"
namespace agg
{
namespace agg {
//==============================================span_image_filter_rgba_nn
template<class Source, class Interpolator>
class span_image_filter_rgba_nn :
public span_image_filter<Source, Interpolator>
class span_image_filter_rgba_nn : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
@ -44,31 +41,23 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum base_scale_e
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_rgba_nn() {}
span_image_filter_rgba_nn(source_type& src,
interpolator_type& inter) :
base_type(src, inter, 0)
span_image_filter_rgba_nn(source_type& src, interpolator_type& inter)
: base_type(src, inter, 0)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
do
{
base_type::interpolator().coordinates(&x, &y);
const value_type* fg_ptr = (const value_type*)
base_type::source().span(x >> image_subpixel_shift,
y >> image_subpixel_shift,
1);
const value_type* fg_ptr =
(const value_type*)base_type::source().span(x >> image_subpixel_shift, y >> image_subpixel_shift, 1);
span->r = fg_ptr[order_type::R];
span->g = fg_ptr[order_type::G];
span->b = fg_ptr[order_type::B];
@ -80,12 +69,9 @@ namespace agg
}
};
//=========================================span_image_filter_rgba_bilinear
template<class Source, class Interpolator>
class span_image_filter_rgba_bilinear :
public span_image_filter<Source, Interpolator>
class span_image_filter_rgba_bilinear : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
@ -95,25 +81,18 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum base_scale_e
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_rgba_bilinear() {}
span_image_filter_rgba_bilinear(source_type& src,
interpolator_type& inter) :
base_type(src, inter, 0)
span_image_filter_rgba_bilinear(source_type& src, interpolator_type& inter)
: base_type(src, inter, 0)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
calc_type fg[4];
const value_type* fg_ptr;
@ -133,17 +112,13 @@ namespace agg
unsigned weight;
fg[0] =
fg[1] =
fg[2] =
fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
fg[0] = fg[1] = fg[2] = fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
x_hr &= image_subpixel_mask;
y_hr &= image_subpixel_mask;
fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, 2);
weight = (image_subpixel_scale - x_hr) *
(image_subpixel_scale - y_hr);
weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr++;
@ -182,11 +157,9 @@ namespace agg
}
};
//====================================span_image_filter_rgba_bilinear_clip
template<class Source, class Interpolator>
class span_image_filter_rgba_bilinear_clip :
public span_image_filter<Source, Interpolator>
class span_image_filter_rgba_bilinear_clip : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
@ -196,29 +169,21 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum base_scale_e
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_rgba_bilinear_clip() {}
span_image_filter_rgba_bilinear_clip(source_type& src,
const color_type& back_color,
interpolator_type& inter) :
base_type(src, inter, 0),
m_back_color(back_color)
span_image_filter_rgba_bilinear_clip(source_type& src, const color_type& back_color, interpolator_type& inter)
: base_type(src, inter, 0)
, m_back_color(back_color)
{}
const color_type& background_color() const { return m_back_color; }
void background_color(const color_type& v) { m_back_color = v; }
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
calc_type fg[4];
value_type back_r = m_back_color.r;
@ -245,22 +210,16 @@ namespace agg
unsigned weight;
if(x_lr >= 0 && y_lr >= 0 &&
x_lr < maxx && y_lr < maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr < maxx && y_lr < maxy)
{
fg[0] =
fg[1] =
fg[2] =
fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
fg[0] = fg[1] = fg[2] = fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
x_hr &= image_subpixel_mask;
y_hr &= image_subpixel_mask;
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + (x_lr << 2);
weight = (image_subpixel_scale - x_hr) *
(image_subpixel_scale - y_hr);
weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr++;
@ -273,8 +232,7 @@ namespace agg
fg[3] += weight * *fg_ptr++;
++y_lr;
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + (x_lr << 2);
weight = (image_subpixel_scale - x_hr) * y_hr;
fg[0] += weight * *fg_ptr++;
@ -295,8 +253,7 @@ namespace agg
}
else
{
if(x_lr < -1 || y_lr < -1 ||
x_lr > maxx || y_lr > maxy)
if (x_lr < -1 || y_lr < -1 || x_lr > maxx || y_lr > maxy)
{
fg[order_type::R] = back_r;
fg[order_type::G] = back_g;
@ -305,21 +262,15 @@ namespace agg
}
else
{
fg[0] =
fg[1] =
fg[2] =
fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
fg[0] = fg[1] = fg[2] = fg[3] = image_subpixel_scale * image_subpixel_scale / 2;
x_hr &= image_subpixel_mask;
y_hr &= image_subpixel_mask;
weight = (image_subpixel_scale - x_hr) *
(image_subpixel_scale - y_hr);
if(x_lr >= 0 && y_lr >= 0 &&
x_lr <= maxx && y_lr <= maxy)
weight = (image_subpixel_scale - x_hr) * (image_subpixel_scale - y_hr);
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
@ -337,11 +288,9 @@ namespace agg
x_lr++;
weight = x_hr * (image_subpixel_scale - y_hr);
if(x_lr >= 0 && y_lr >= 0 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
@ -360,11 +309,9 @@ namespace agg
y_lr++;
weight = (image_subpixel_scale - x_hr) * y_hr;
if(x_lr >= 0 && y_lr >= 0 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
@ -382,11 +329,9 @@ namespace agg
x_lr++;
weight = x_hr * y_hr;
if(x_lr >= 0 && y_lr >= 0 &&
x_lr <= maxx && y_lr <= maxy)
if (x_lr >= 0 && y_lr >= 0 && x_lr <= maxx && y_lr <= maxy)
{
fg_ptr = (const value_type*)
base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg_ptr = (const value_type*)base_type::source().row_ptr(y_lr) + (x_lr << 2);
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
@ -417,15 +362,14 @@ namespace agg
} while (--len);
}
private:
color_type m_back_color;
};
//==============================================span_image_filter_rgba_2x2
template<class Source, class Interpolator>
class span_image_filter_rgba_2x2 :
public span_image_filter<Source, Interpolator>
class span_image_filter_rgba_2x2 : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
@ -435,33 +379,24 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum base_scale_e
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_rgba_2x2() {}
span_image_filter_rgba_2x2(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, &filter)
span_image_filter_rgba_2x2(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
: base_type(src, inter, &filter)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
calc_type fg[4];
const value_type* fg_ptr;
const int16* weight_array = base_type::filter().weight_array() +
((base_type::filter().diameter()/2 - 1) <<
image_subpixel_shift);
const int16* weight_array =
base_type::filter().weight_array() + ((base_type::filter().diameter() / 2 - 1) << image_subpixel_shift);
do
{
@ -483,8 +418,7 @@ namespace agg
y_hr &= image_subpixel_mask;
fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, 2);
weight = (weight_array[x_hr + image_subpixel_scale] *
weight_array[y_hr + image_subpixel_scale] +
weight = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr + image_subpixel_scale] +
image_filter_scale / 2) >>
image_filter_shift;
fg[0] += weight * *fg_ptr++;
@ -493,9 +427,7 @@ namespace agg
fg[3] += weight * *fg_ptr;
fg_ptr = (const value_type*)base_type::source().next_x();
weight = (weight_array[x_hr] *
weight_array[y_hr + image_subpixel_scale] +
image_filter_scale / 2) >>
weight = (weight_array[x_hr] * weight_array[y_hr + image_subpixel_scale] + image_filter_scale / 2) >>
image_filter_shift;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
@ -503,9 +435,7 @@ namespace agg
fg[3] += weight * *fg_ptr;
fg_ptr = (const value_type*)base_type::source().next_y();
weight = (weight_array[x_hr + image_subpixel_scale] *
weight_array[y_hr] +
image_filter_scale / 2) >>
weight = (weight_array[x_hr + image_subpixel_scale] * weight_array[y_hr] + image_filter_scale / 2) >>
image_filter_shift;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
@ -513,10 +443,7 @@ namespace agg
fg[3] += weight * *fg_ptr;
fg_ptr = (const value_type*)base_type::source().next_x();
weight = (weight_array[x_hr] *
weight_array[y_hr] +
image_filter_scale / 2) >>
image_filter_shift;
weight = (weight_array[x_hr] * weight_array[y_hr] + image_filter_scale / 2) >> image_filter_shift;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr++;
@ -527,10 +454,14 @@ namespace agg
fg[2] >>= image_filter_shift;
fg[3] >>= image_filter_shift;
if(fg[order_type::A] > base_mask) fg[order_type::A] = base_mask;
if(fg[order_type::R] > fg[order_type::A]) fg[order_type::R] = fg[order_type::A];
if(fg[order_type::G] > fg[order_type::A]) fg[order_type::G] = fg[order_type::A];
if(fg[order_type::B] > fg[order_type::A]) fg[order_type::B] = fg[order_type::A];
if (fg[order_type::A] > base_mask)
fg[order_type::A] = base_mask;
if (fg[order_type::R] > fg[order_type::A])
fg[order_type::R] = fg[order_type::A];
if (fg[order_type::G] > fg[order_type::A])
fg[order_type::G] = fg[order_type::A];
if (fg[order_type::B] > fg[order_type::A])
fg[order_type::B] = fg[order_type::A];
span->r = (value_type)fg[order_type::R];
span->g = (value_type)fg[order_type::G];
@ -543,12 +474,9 @@ namespace agg
}
};
//==================================================span_image_filter_rgba
template<class Source, class Interpolator>
class span_image_filter_rgba :
public span_image_filter<Source, Interpolator>
class span_image_filter_rgba : public span_image_filter<Source, Interpolator>
{
public:
typedef Source source_type;
@ -558,25 +486,18 @@ namespace agg
typedef span_image_filter<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::calc_type calc_type;
enum base_scale_e
{
base_shift = color_type::base_shift,
base_mask = color_type::base_mask
};
enum base_scale_e { base_shift = color_type::base_shift, base_mask = color_type::base_mask };
//--------------------------------------------------------------------
span_image_filter_rgba() {}
span_image_filter_rgba(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, &filter)
span_image_filter_rgba(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
: base_type(src, inter, &filter)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
int fg[4];
const value_type* fg_ptr;
@ -607,9 +528,7 @@ namespace agg
unsigned y_count = diameter;
y_hr = image_subpixel_mask - (y_hr & image_subpixel_mask);
fg_ptr = (const value_type*)base_type::source().span(x_lr + start,
y_lr + start,
diameter);
fg_ptr = (const value_type*)base_type::source().span(x_lr + start, y_lr + start, diameter);
for (;;)
{
x_count = diameter;
@ -617,21 +536,21 @@ namespace agg
x_hr = image_subpixel_mask - x_fract;
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
image_filter_shift;
int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> image_filter_shift;
fg[0] += weight * *fg_ptr++;
fg[1] += weight * *fg_ptr++;
fg[2] += weight * *fg_ptr++;
fg[3] += weight * *fg_ptr;
if(--x_count == 0) break;
if (--x_count == 0)
break;
x_hr += image_subpixel_scale;
fg_ptr = (const value_type*)base_type::source().next_x();
}
if(--y_count == 0) break;
if (--y_count == 0)
break;
y_hr += image_subpixel_scale;
fg_ptr = (const value_type*)base_type::source().next_y();
}
@ -641,15 +560,23 @@ namespace agg
fg[2] >>= image_filter_shift;
fg[3] >>= image_filter_shift;
if(fg[0] < 0) fg[0] = 0;
if(fg[1] < 0) fg[1] = 0;
if(fg[2] < 0) fg[2] = 0;
if(fg[3] < 0) fg[3] = 0;
if (fg[0] < 0)
fg[0] = 0;
if (fg[1] < 0)
fg[1] = 0;
if (fg[2] < 0)
fg[2] = 0;
if (fg[3] < 0)
fg[3] = 0;
if(fg[order_type::A] > base_mask) fg[order_type::A] = base_mask;
if(fg[order_type::R] > fg[order_type::A]) fg[order_type::R] = fg[order_type::A];
if(fg[order_type::G] > fg[order_type::A]) fg[order_type::G] = fg[order_type::A];
if(fg[order_type::B] > fg[order_type::A]) fg[order_type::B] = fg[order_type::A];
if (fg[order_type::A] > base_mask)
fg[order_type::A] = base_mask;
if (fg[order_type::R] > fg[order_type::A])
fg[order_type::R] = fg[order_type::A];
if (fg[order_type::G] > fg[order_type::A])
fg[order_type::G] = fg[order_type::A];
if (fg[order_type::B] > fg[order_type::A])
fg[order_type::B] = fg[order_type::A];
span->r = (value_type)fg[order_type::R];
span->g = (value_type)fg[order_type::G];
@ -662,12 +589,9 @@ namespace agg
}
};
//========================================span_image_resample_rgba_affine
template<class Source>
class span_image_resample_rgba_affine :
public span_image_resample_affine<Source>
class span_image_resample_rgba_affine : public span_image_resample_affine<Source>
{
public:
typedef Source source_type;
@ -677,8 +601,7 @@ namespace agg
typedef typename base_type::interpolator_type interpolator_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::long_type long_type;
enum base_scale_e
{
enum base_scale_e {
base_shift = color_type::base_shift,
base_mask = color_type::base_mask,
downscale_shift = image_filter_shift
@ -686,18 +609,14 @@ namespace agg
//--------------------------------------------------------------------
span_image_resample_rgba_affine() {}
span_image_resample_rgba_affine(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, filter)
span_image_resample_rgba_affine(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
: base_type(src, inter, filter)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
long_type fg[4];
@ -705,9 +624,7 @@ namespace agg
int filter_scale = diameter << image_subpixel_shift;
int radius_x = (diameter * base_type::m_rx) >> 1;
int radius_y = (diameter * base_type::m_ry) >> 1;
int len_x_lr =
(diameter * base_type::m_rx + image_subpixel_mask) >>
image_subpixel_shift;
int len_x_lr = (diameter * base_type::m_rx + image_subpixel_mask) >> image_subpixel_shift;
const int16* weight_array = base_type::filter().weight_array();
@ -721,27 +638,22 @@ namespace agg
fg[0] = fg[1] = fg[2] = fg[3] = image_filter_scale / 2;
int y_lr = y >> image_subpixel_shift;
int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) *
base_type::m_ry_inv) >>
image_subpixel_shift;
int y_hr =
((image_subpixel_mask - (y & image_subpixel_mask)) * base_type::m_ry_inv) >> image_subpixel_shift;
int total_weight = 0;
int x_lr = x >> image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) *
base_type::m_rx_inv) >>
image_subpixel_shift;
int x_hr =
((image_subpixel_mask - (x & image_subpixel_mask)) * base_type::m_rx_inv) >> image_subpixel_shift;
int x_hr2 = x_hr;
const value_type* fg_ptr =
(const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
for (;;)
{
int weight_y = weight_array[y_hr];
x_hr = x_hr2;
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
downscale_shift;
int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
fg[0] += *fg_ptr++ * weight;
fg[1] += *fg_ptr++ * weight;
@ -749,11 +661,13 @@ namespace agg
fg[3] += *fg_ptr++ * weight;
total_weight += weight;
x_hr += base_type::m_rx_inv;
if(x_hr >= filter_scale) break;
if (x_hr >= filter_scale)
break;
fg_ptr = (const value_type*)base_type::source().next_x();
}
y_hr += base_type::m_ry_inv;
if(y_hr >= filter_scale) break;
if (y_hr >= filter_scale)
break;
fg_ptr = (const value_type*)base_type::source().next_y();
}
@ -762,15 +676,23 @@ namespace agg
fg[2] /= total_weight;
fg[3] /= total_weight;
if(fg[0] < 0) fg[0] = 0;
if(fg[1] < 0) fg[1] = 0;
if(fg[2] < 0) fg[2] = 0;
if(fg[3] < 0) fg[3] = 0;
if (fg[0] < 0)
fg[0] = 0;
if (fg[1] < 0)
fg[1] = 0;
if (fg[2] < 0)
fg[2] = 0;
if (fg[3] < 0)
fg[3] = 0;
if(fg[order_type::A] > base_mask) fg[order_type::A] = base_mask;
if(fg[order_type::R] > fg[order_type::A]) fg[order_type::R] = fg[order_type::A];
if(fg[order_type::G] > fg[order_type::A]) fg[order_type::G] = fg[order_type::A];
if(fg[order_type::B] > fg[order_type::A]) fg[order_type::B] = fg[order_type::A];
if (fg[order_type::A] > base_mask)
fg[order_type::A] = base_mask;
if (fg[order_type::R] > fg[order_type::A])
fg[order_type::R] = fg[order_type::A];
if (fg[order_type::G] > fg[order_type::A])
fg[order_type::G] = fg[order_type::A];
if (fg[order_type::B] > fg[order_type::A])
fg[order_type::B] = fg[order_type::A];
span->r = (value_type)fg[order_type::R];
span->g = (value_type)fg[order_type::G];
@ -783,12 +705,9 @@ namespace agg
}
};
//==============================================span_image_resample_rgba
template<class Source, class Interpolator>
class span_image_resample_rgba :
public span_image_resample<Source, Interpolator>
class span_image_resample_rgba : public span_image_resample<Source, Interpolator>
{
public:
typedef Source source_type;
@ -798,8 +717,7 @@ namespace agg
typedef span_image_resample<source_type, interpolator_type> base_type;
typedef typename color_type::value_type value_type;
typedef typename color_type::long_type long_type;
enum base_scale_e
{
enum base_scale_e {
base_shift = color_type::base_shift,
base_mask = color_type::base_mask,
downscale_shift = image_filter_shift
@ -807,17 +725,14 @@ namespace agg
//--------------------------------------------------------------------
span_image_resample_rgba() {}
span_image_resample_rgba(source_type& src,
interpolator_type& inter,
const image_filter_lut& filter) :
base_type(src, inter, filter)
span_image_resample_rgba(source_type& src, interpolator_type& inter, const image_filter_lut& filter)
: base_type(src, inter, filter)
{}
//--------------------------------------------------------------------
void generate(color_type* span, int x, int y, unsigned len)
{
base_type::interpolator().begin(x + base_type::filter_dx_dbl(),
y + base_type::filter_dy_dbl(), len);
base_type::interpolator().begin(x + base_type::filter_dx_dbl(), y + base_type::filter_dy_dbl(), len);
long_type fg[4];
int diameter = base_type::filter().diameter();
@ -839,9 +754,7 @@ namespace agg
int radius_x = (diameter * rx) >> 1;
int radius_y = (diameter * ry) >> 1;
int len_x_lr =
(diameter * rx + image_subpixel_mask) >>
image_subpixel_shift;
int len_x_lr = (diameter * rx + image_subpixel_mask) >> image_subpixel_shift;
x += base_type::filter_dx_int() - radius_x;
y += base_type::filter_dy_int() - radius_y;
@ -849,17 +762,12 @@ namespace agg
fg[0] = fg[1] = fg[2] = fg[3] = image_filter_scale / 2;
int y_lr = y >> image_subpixel_shift;
int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) *
ry_inv) >>
image_subpixel_shift;
int y_hr = ((image_subpixel_mask - (y & image_subpixel_mask)) * ry_inv) >> image_subpixel_shift;
int total_weight = 0;
int x_lr = x >> image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) *
rx_inv) >>
image_subpixel_shift;
int x_hr = ((image_subpixel_mask - (x & image_subpixel_mask)) * rx_inv) >> image_subpixel_shift;
int x_hr2 = x_hr;
const value_type* fg_ptr =
(const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
const value_type* fg_ptr = (const value_type*)base_type::source().span(x_lr, y_lr, len_x_lr);
for (;;)
{
@ -867,20 +775,20 @@ namespace agg
x_hr = x_hr2;
for (;;)
{
int weight = (weight_y * weight_array[x_hr] +
image_filter_scale / 2) >>
downscale_shift;
int weight = (weight_y * weight_array[x_hr] + image_filter_scale / 2) >> downscale_shift;
fg[0] += *fg_ptr++ * weight;
fg[1] += *fg_ptr++ * weight;
fg[2] += *fg_ptr++ * weight;
fg[3] += *fg_ptr++ * weight;
total_weight += weight;
x_hr += rx_inv;
if(x_hr >= filter_scale) break;
if (x_hr >= filter_scale)
break;
fg_ptr = (const value_type*)base_type::source().next_x();
}
y_hr += ry_inv;
if(y_hr >= filter_scale) break;
if (y_hr >= filter_scale)
break;
fg_ptr = (const value_type*)base_type::source().next_y();
}
@ -889,15 +797,23 @@ namespace agg
fg[2] /= total_weight;
fg[3] /= total_weight;
if(fg[0] < 0) fg[0] = 0;
if(fg[1] < 0) fg[1] = 0;
if(fg[2] < 0) fg[2] = 0;
if(fg[3] < 0) fg[3] = 0;
if (fg[0] < 0)
fg[0] = 0;
if (fg[1] < 0)
fg[1] = 0;
if (fg[2] < 0)
fg[2] = 0;
if (fg[3] < 0)
fg[3] = 0;
if(fg[order_type::A] > base_mask) fg[order_type::A] = base_mask;
if(fg[order_type::R] > fg[order_type::A]) fg[order_type::R] = fg[order_type::A];
if(fg[order_type::G] > fg[order_type::A]) fg[order_type::G] = fg[order_type::A];
if(fg[order_type::B] > fg[order_type::A]) fg[order_type::B] = fg[order_type::A];
if (fg[order_type::A] > base_mask)
fg[order_type::A] = base_mask;
if (fg[order_type::R] > fg[order_type::A])
fg[order_type::R] = fg[order_type::A];
if (fg[order_type::G] > fg[order_type::A])
fg[order_type::G] = fg[order_type::A];
if (fg[order_type::B] > fg[order_type::A])
fg[order_type::B] = fg[order_type::A];
span->r = (value_type)fg[order_type::R];
span->g = (value_type)fg[order_type::G];
@ -910,11 +826,6 @@ namespace agg
}
};
}
} // namespace agg
#endif

37
deps/agg/include/agg_span_interpolator_adaptor.h vendored
View file

@ -18,8 +18,7 @@
#include "agg_basics.h"
namespace agg
{
namespace agg {
//===============================================span_interpolator_adaptor
template<class Interpolator, class Distortion>
@ -32,33 +31,22 @@ namespace agg
//--------------------------------------------------------------------
span_interpolator_adaptor() {}
span_interpolator_adaptor(const trans_type& trans,
const distortion_type& dist) :
base_type(trans),
m_distortion(&dist)
{
}
span_interpolator_adaptor(const trans_type& trans, const distortion_type& dist)
: base_type(trans)
, m_distortion(&dist)
{}
//--------------------------------------------------------------------
span_interpolator_adaptor(const trans_type& trans,
const distortion_type& dist,
double x, double y, unsigned len) :
base_type(trans, x, y, len),
m_distortion(&dist)
{
}
span_interpolator_adaptor(const trans_type& trans, const distortion_type& dist, double x, double y, unsigned len)
: base_type(trans, x, y, len)
, m_distortion(&dist)
{}
//--------------------------------------------------------------------
const distortion_type& distortion() const
{
return *m_distortion;
}
const distortion_type& distortion() const { return *m_distortion; }
//--------------------------------------------------------------------
void distortion(const distortion_type& dist)
{
m_distortion = dist;
}
void distortion(const distortion_type& dist) { m_distortion = dist; }
//--------------------------------------------------------------------
void coordinates(int* x, int* y) const
@ -71,7 +59,6 @@ namespace agg
//--------------------------------------------------------------------
const distortion_type* m_distortion;
};
}
} // namespace agg
#endif

80
deps/agg/include/agg_span_interpolator_linear.h vendored
View file

@ -20,8 +20,7 @@
#include "agg_dda_line.h"
#include "agg_trans_affine.h"
namespace agg
{
namespace agg {
//================================================span_interpolator_linear
template<class Transformer = trans_affine, unsigned SubpixelShift = 8>
@ -30,18 +29,15 @@ namespace agg
public:
typedef Transformer trans_type;
enum subpixel_scale_e
{
subpixel_shift = SubpixelShift,
subpixel_scale = 1 << subpixel_shift
};
enum subpixel_scale_e { subpixel_shift = SubpixelShift, subpixel_scale = 1 << subpixel_shift };
//--------------------------------------------------------------------
span_interpolator_linear() {}
span_interpolator_linear(const trans_type& trans) : m_trans(&trans) {}
span_interpolator_linear(const trans_type& trans,
double x, double y, unsigned len) :
m_trans(&trans)
span_interpolator_linear(const trans_type& trans)
: m_trans(&trans)
{}
span_interpolator_linear(const trans_type& trans, double x, double y, unsigned len)
: m_trans(&trans)
{
begin(x, y, len);
}
@ -100,11 +96,6 @@ namespace agg
dda2_line_interpolator m_li_y;
};
//=====================================span_interpolator_linear_subdiv
template<class Transformer = trans_affine, unsigned SubpixelShift = 8>
class span_interpolator_linear_subdiv
@ -112,33 +103,31 @@ namespace agg
public:
typedef Transformer trans_type;
enum subpixel_scale_e
{
subpixel_shift = SubpixelShift,
subpixel_scale = 1 << subpixel_shift
};
enum subpixel_scale_e { subpixel_shift = SubpixelShift, subpixel_scale = 1 << subpixel_shift };
//----------------------------------------------------------------
span_interpolator_linear_subdiv() :
m_subdiv_shift(4),
m_subdiv_size(1 << m_subdiv_shift),
m_subdiv_mask(m_subdiv_size - 1) {}
span_interpolator_linear_subdiv()
: m_subdiv_shift(4)
, m_subdiv_size(1 << m_subdiv_shift)
, m_subdiv_mask(m_subdiv_size - 1)
{}
span_interpolator_linear_subdiv(const trans_type& trans, unsigned subdiv_shift = 4)
: m_subdiv_shift(subdiv_shift)
, m_subdiv_size(1 << m_subdiv_shift)
, m_subdiv_mask(m_subdiv_size - 1)
, m_trans(&trans)
{}
span_interpolator_linear_subdiv(const trans_type& trans,
unsigned subdiv_shift = 4) :
m_subdiv_shift(subdiv_shift),
m_subdiv_size(1 << m_subdiv_shift),
m_subdiv_mask(m_subdiv_size - 1),
m_trans(&trans) {}
span_interpolator_linear_subdiv(const trans_type& trans,
double x, double y, unsigned len,
unsigned subdiv_shift = 4) :
m_subdiv_shift(subdiv_shift),
m_subdiv_size(1 << m_subdiv_shift),
m_subdiv_mask(m_subdiv_size - 1),
m_trans(&trans)
double x,
double y,
unsigned len,
unsigned subdiv_shift = 4)
: m_subdiv_shift(subdiv_shift)
, m_subdiv_size(1 << m_subdiv_shift)
, m_subdiv_mask(m_subdiv_size - 1)
, m_trans(&trans)
{
begin(x, y, len);
}
@ -166,7 +155,8 @@ namespace agg
m_src_y = y;
m_len = len;
if(len > m_subdiv_size) len = m_subdiv_size;
if (len > m_subdiv_size)
len = m_subdiv_size;
tx = x;
ty = y;
m_trans->transform(&tx, &ty);
@ -189,7 +179,8 @@ namespace agg
if (m_pos >= m_subdiv_size)
{
unsigned len = m_len;
if(len > m_subdiv_size) len = m_subdiv_size;
if (len > m_subdiv_size)
len = m_subdiv_size;
double tx = double(m_src_x) / double(subpixel_scale) + len;
double ty = m_src_y;
m_trans->transform(&tx, &ty);
@ -222,11 +213,6 @@ namespace agg
unsigned m_len;
};
}
} // namespace agg
#endif

84
deps/agg/include/agg_span_interpolator_persp.h vendored
View file

@ -18,10 +18,7 @@
#include "agg_trans_perspective.h"
#include "agg_dda_line.h"
namespace agg
{
namespace agg {
//===========================================span_interpolator_persp_exact
template<unsigned SubpixelShift = 8>
@ -30,36 +27,25 @@ namespace agg
public:
typedef trans_perspective trans_type;
typedef trans_perspective::iterator_x iterator_type;
enum subpixel_scale_e
{
subpixel_shift = SubpixelShift,
subpixel_scale = 1 << subpixel_shift
};
enum subpixel_scale_e { subpixel_shift = SubpixelShift, subpixel_scale = 1 << subpixel_shift };
//--------------------------------------------------------------------
span_interpolator_persp_exact() {}
//--------------------------------------------------------------------
// Arbitrary quadrangle transformations
span_interpolator_persp_exact(const double* src, const double* dst)
{
quad_to_quad(src, dst);
}
span_interpolator_persp_exact(const double* src, const double* dst) { quad_to_quad(src, dst); }
//--------------------------------------------------------------------
// Direct transformations
span_interpolator_persp_exact(double x1, double y1,
double x2, double y2,
const double* quad)
span_interpolator_persp_exact(double x1, double y1, double x2, double y2, const double* quad)
{
rect_to_quad(x1, y1, x2, y2, quad);
}
//--------------------------------------------------------------------
// Reverse transformations
span_interpolator_persp_exact(const double* quad,
double x1, double y1,
double x2, double y2)
span_interpolator_persp_exact(const double* quad, double x1, double y1, double x2, double y2)
{
quad_to_rect(quad, x1, y1, x2, y2);
}
@ -74,8 +60,7 @@ namespace agg
//--------------------------------------------------------------------
// Set the direct transformations, i.e., rectangle -> quadrangle
void rect_to_quad(double x1, double y1, double x2, double y2,
const double* quad)
void rect_to_quad(double x1, double y1, double x2, double y2, const double* quad)
{
double src[8];
src[0] = src[6] = x1;
@ -85,11 +70,9 @@ namespace agg
quad_to_quad(src, quad);
}
//--------------------------------------------------------------------
// Set the reverse transformations, i.e., quadrangle -> rectangle
void quad_to_rect(const double* quad,
double x1, double y1, double x2, double y2)
void quad_to_rect(const double* quad, double x1, double y1, double x2, double y2)
{
double dst[8];
dst[0] = dst[6] = x1;
@ -148,7 +131,6 @@ namespace agg
m_scale_y = dda2_line_interpolator(sy1, sy2, len);
}
//----------------------------------------------------------------
void resynchronize(double xe, double ye, unsigned len)
{
@ -186,8 +168,6 @@ namespace agg
m_scale_y = dda2_line_interpolator(sy1, sy2, len);
}
//----------------------------------------------------------------
void operator++()
{
@ -211,10 +191,7 @@ namespace agg
}
//----------------------------------------------------------------
void transform(double* x, double* y) const
{
m_trans_dir.transform(x, y);
}
void transform(double* x, double* y) const { m_trans_dir.transform(x, y); }
private:
trans_type m_trans_dir;
@ -224,52 +201,31 @@ namespace agg
dda2_line_interpolator m_scale_y;
};
//============================================span_interpolator_persp_lerp
template<unsigned SubpixelShift = 8>
class span_interpolator_persp_lerp
{
public:
typedef trans_perspective trans_type;
enum subpixel_scale_e
{
subpixel_shift = SubpixelShift,
subpixel_scale = 1 << subpixel_shift
};
enum subpixel_scale_e { subpixel_shift = SubpixelShift, subpixel_scale = 1 << subpixel_shift };
//--------------------------------------------------------------------
span_interpolator_persp_lerp() {}
//--------------------------------------------------------------------
// Arbitrary quadrangle transformations
span_interpolator_persp_lerp(const double* src, const double* dst)
{
quad_to_quad(src, dst);
}
span_interpolator_persp_lerp(const double* src, const double* dst) { quad_to_quad(src, dst); }
//--------------------------------------------------------------------
// Direct transformations
span_interpolator_persp_lerp(double x1, double y1,
double x2, double y2,
const double* quad)
span_interpolator_persp_lerp(double x1, double y1, double x2, double y2, const double* quad)
{
rect_to_quad(x1, y1, x2, y2, quad);
}
//--------------------------------------------------------------------
// Reverse transformations
span_interpolator_persp_lerp(const double* quad,
double x1, double y1,
double x2, double y2)
span_interpolator_persp_lerp(const double* quad, double x1, double y1, double x2, double y2)
{
quad_to_rect(quad, x1, y1, x2, y2);
}
@ -284,8 +240,7 @@ namespace agg
//--------------------------------------------------------------------
// Set the direct transformations, i.e., rectangle -> quadrangle
void rect_to_quad(double x1, double y1, double x2, double y2,
const double* quad)
void rect_to_quad(double x1, double y1, double x2, double y2, const double* quad)
{
double src[8];
src[0] = src[6] = x1;
@ -295,11 +250,9 @@ namespace agg
quad_to_quad(src, quad);
}
//--------------------------------------------------------------------
// Set the reverse transformations, i.e., quadrangle -> rectangle
void quad_to_rect(const double* quad,
double x1, double y1, double x2, double y2)
void quad_to_rect(const double* quad, double x1, double y1, double x2, double y2)
{
double dst[8];
dst[0] = dst[6] = x1;
@ -374,7 +327,6 @@ namespace agg
m_scale_y = dda2_line_interpolator(sy1, sy2, len);
}
//----------------------------------------------------------------
void resynchronize(double xe, double ye, unsigned len)
{
@ -418,7 +370,6 @@ namespace agg
m_scale_y = dda2_line_interpolator(sy1, sy2, len);
}
//----------------------------------------------------------------
void operator++()
{
@ -443,10 +394,7 @@ namespace agg
}
//----------------------------------------------------------------
void transform(double* x, double* y) const
{
m_trans_dir.transform(x, y);
}
void transform(double* x, double* y) const { m_trans_dir.transform(x, y); }
private:
trans_type m_trans_dir;
@ -457,6 +405,6 @@ namespace agg
dda2_line_interpolator m_scale_y;
};
}
} // namespace agg
#endif

Some files were not shown because too many files have changed in this diff Show more