282 lines
6.9 KiB
C++
282 lines
6.9 KiB
C++
#include <stdlib.h>
|
|
#include <ctype.h>
|
|
#include <stdio.h>
|
|
#include "agg_basics.h"
|
|
#include "agg_array.h"
|
|
#include "agg_rendering_buffer.h"
|
|
#include "agg_rasterizer_scanline_aa.h"
|
|
#include "agg_scanline_p.h"
|
|
#include "agg_scanline_u.h"
|
|
#include "agg_scanline_bin.h"
|
|
#include "agg_scanline_boolean_algebra.h"
|
|
#include "agg_scanline_storage_aa.h"
|
|
#include "agg_scanline_storage_bin.h"
|
|
#include "agg_renderer_scanline.h"
|
|
#include "agg_path_storage.h"
|
|
#include "agg_conv_transform.h"
|
|
#include "agg_ellipse.h"
|
|
#include "ctrl/agg_rbox_ctrl.h"
|
|
#include "ctrl/agg_cbox_ctrl.h"
|
|
#include "ctrl/agg_slider_ctrl.h"
|
|
#include "platform/agg_platform_support.h"
|
|
#include "interactive_polygon.h"
|
|
|
|
#define AGG_BGR24
|
|
//#define AGG_RGB24
|
|
//#define AGG_BGRA32
|
|
//#define AGG_RGBA32
|
|
//#define AGG_ARGB32
|
|
//#define AGG_ABGR32
|
|
//#define AGG_BGR96
|
|
//#define AGG_BGRA128
|
|
//#define AGG_RGB565
|
|
//#define AGG_RGB555
|
|
#include "pixel_formats.h"
|
|
|
|
enum flip_y_e { flip_y = true };
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void generate_circles(agg::path_storage& ps,
|
|
const double* quad,
|
|
unsigned num_circles,
|
|
double radius)
|
|
{
|
|
ps.remove_all();
|
|
unsigned i;
|
|
for(i = 0; i < 4; ++i)
|
|
{
|
|
unsigned n1 = i * 2;
|
|
unsigned n2 = (i < 3) ? i * 2 + 2 : 0;
|
|
unsigned j;
|
|
for(j = 0; j < num_circles; j++)
|
|
{
|
|
agg::ellipse ell(quad[n1] + (quad[n2] - quad[n1]) * j / num_circles,
|
|
quad[n1 + 1] + (quad[n2 + 1] - quad[n1 + 1]) * j / num_circles,
|
|
radius, radius, 100);
|
|
ps.concat_path(ell);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
class the_application : public agg::platform_support
|
|
{
|
|
public:
|
|
typedef agg::renderer_base<pixfmt> renderer_base;
|
|
typedef agg::renderer_scanline_aa_solid<renderer_base> renderer_solid;
|
|
typedef agg::scanline_p8 scanline_type;
|
|
|
|
agg::interactive_polygon m_quad1;
|
|
agg::interactive_polygon m_quad2;
|
|
agg::rbox_ctrl<color_type> m_trans_type;
|
|
agg::cbox_ctrl<color_type> m_reset;
|
|
agg::slider_ctrl<color_type> m_mul1;
|
|
agg::slider_ctrl<color_type> m_mul2;
|
|
|
|
the_application(agg::pix_format_e format, bool flip_y) :
|
|
agg::platform_support(format, flip_y),
|
|
m_quad1(4, 5.0),
|
|
m_quad2(4, 5.0),
|
|
m_trans_type(420, 5.0, 420+130.0, 145.0, !flip_y),
|
|
m_reset (350, 5.0, "Reset", !flip_y),
|
|
m_mul1 (5.0, 5.0, 340.0, 12.0, !flip_y),
|
|
m_mul2 (5.0, 20.0, 340.0, 27.0, !flip_y)
|
|
{
|
|
m_trans_type.add_item("Union");
|
|
m_trans_type.add_item("Intersection");
|
|
m_trans_type.add_item("Linear XOR");
|
|
m_trans_type.add_item("Saddle XOR");
|
|
m_trans_type.add_item("Abs Diff XOR");
|
|
m_trans_type.add_item("A-B");
|
|
m_trans_type.add_item("B-A");
|
|
m_trans_type.cur_item(0);
|
|
add_ctrl(m_trans_type);
|
|
add_ctrl(m_reset);
|
|
add_ctrl(m_mul1);
|
|
add_ctrl(m_mul2);
|
|
m_mul1.value(1.0);
|
|
m_mul2.value(1.0);
|
|
m_mul1.label("Opacity1=%.3f");
|
|
m_mul2.label("Opacity2=%.3f");
|
|
}
|
|
|
|
|
|
virtual void on_init()
|
|
{
|
|
m_quad1.xn(0) = 50;
|
|
m_quad1.yn(0) = 200 - 20;
|
|
m_quad1.xn(1) = width() / 2 - 25;
|
|
m_quad1.yn(1) = 200;
|
|
m_quad1.xn(2) = width() / 2 - 25;
|
|
m_quad1.yn(2) = height() - 50 - 20;
|
|
m_quad1.xn(3) = 50;
|
|
m_quad1.yn(3) = height() - 50;
|
|
|
|
m_quad2.xn(0) = width() / 2 + 25;
|
|
m_quad2.yn(0) = 200 - 20;
|
|
m_quad2.xn(1) = width() - 50;
|
|
m_quad2.yn(1) = 200;
|
|
m_quad2.xn(2) = width() - 50;
|
|
m_quad2.yn(2) = height() - 50 - 20;
|
|
m_quad2.xn(3) = width() / 2 + 25;
|
|
m_quad2.yn(3) = height() - 50;
|
|
}
|
|
|
|
|
|
|
|
|
|
virtual void on_draw()
|
|
{
|
|
pixfmt pixf(rbuf_window());
|
|
renderer_base rb(pixf);
|
|
renderer_solid r(rb);
|
|
rb.clear(agg::rgba(1, 1, 1));
|
|
|
|
scanline_type sl;
|
|
agg::rasterizer_scanline_aa<> ras;
|
|
agg::rasterizer_scanline_aa<> ras1;
|
|
agg::rasterizer_scanline_aa<> ras2;
|
|
|
|
agg::sbool_op_e op = (agg::sbool_op_e)m_trans_type.cur_item();
|
|
|
|
ras1.gamma(agg::gamma_multiply(m_mul1.value()));
|
|
ras2.gamma(agg::gamma_multiply(m_mul2.value()));
|
|
|
|
ras.clip_box(0, 0, width(), height());
|
|
|
|
agg::path_storage ps1;
|
|
generate_circles(ps1, m_quad1.polygon(), 5, 20);
|
|
|
|
agg::path_storage ps2;
|
|
generate_circles(ps2, m_quad2.polygon(), 5, 20);
|
|
|
|
ras1.filling_rule(agg::fill_even_odd);
|
|
|
|
|
|
r.color(agg::srgba8(240, 255, 200, 100));
|
|
ras1.add_path(ps1);
|
|
agg::render_scanlines(ras1, sl, r);
|
|
|
|
r.color(agg::srgba8(255, 240, 240, 100));
|
|
ras2.add_path(ps2);
|
|
agg::render_scanlines(ras2, sl, r);
|
|
|
|
|
|
|
|
typedef agg::scanline_p8 sbool_scanline_type;
|
|
typedef agg::renderer_scanline_aa_solid<renderer_base> sbool_renderer_type;
|
|
|
|
sbool_scanline_type sl_result;
|
|
sbool_scanline_type sl1;
|
|
sbool_scanline_type sl2;
|
|
sbool_renderer_type sren(rb);
|
|
|
|
sren.color(agg::srgba8(0, 0, 0));
|
|
|
|
agg::sbool_combine_shapes_aa(op, ras1, ras2, sl1, sl2, sl_result, sren);
|
|
|
|
//--------------------------
|
|
// Render the "quad" tools and controls
|
|
r.color(agg::rgba(0, 0.3, 0.5, 0.6));
|
|
ras.add_path(m_quad1);
|
|
agg::render_scanlines(ras, sl, r);
|
|
ras.add_path(m_quad2);
|
|
agg::render_scanlines(ras, sl, r);
|
|
agg::render_ctrl(ras, sl, rb, m_trans_type);
|
|
agg::render_ctrl(ras, sl, rb, m_reset);
|
|
agg::render_ctrl(ras, sl, rb, m_mul1);
|
|
agg::render_ctrl(ras, sl, rb, m_mul2);
|
|
//--------------------------
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void on_mouse_button_down(int x, int y, unsigned flags)
|
|
{
|
|
if(flags & agg::mouse_left)
|
|
{
|
|
if(m_quad1.on_mouse_button_down(x, y) ||
|
|
m_quad2.on_mouse_button_down(x, y) )
|
|
{
|
|
force_redraw();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
virtual void on_mouse_move(int x, int y, unsigned flags)
|
|
{
|
|
if(flags & agg::mouse_left)
|
|
{
|
|
if(m_quad1.on_mouse_move(x, y) ||
|
|
m_quad2.on_mouse_move(x, y) )
|
|
{
|
|
force_redraw();
|
|
}
|
|
}
|
|
if((flags & agg::mouse_left) == 0)
|
|
{
|
|
on_mouse_button_up(x, y, flags);
|
|
}
|
|
}
|
|
|
|
|
|
virtual void on_mouse_button_up(int x, int y, unsigned flags)
|
|
{
|
|
if(m_quad1.on_mouse_button_up(x, y) ||
|
|
m_quad2.on_mouse_button_up(x, y) )
|
|
{
|
|
force_redraw();
|
|
}
|
|
}
|
|
|
|
|
|
virtual void on_ctrl_change()
|
|
{
|
|
if(m_reset.status())
|
|
{
|
|
on_init();
|
|
m_reset.status(false);
|
|
force_redraw();
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
int agg_main(int argc, char* argv[])
|
|
{
|
|
the_application app(pix_format, flip_y);
|
|
app.caption("AGG Example. Scanline Boolean");
|
|
|
|
if(app.init(800, 600, agg::window_resize))
|
|
{
|
|
return app.run();
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|