void generate_alpha_mask(int cx, int cy)
{
delete [] m_alpha_buf;
m_alpha_buf = new unsigned char[cx * cy];
g_alpha_mask_rbuf.attach(m_alpha_buf, cx, cy, cx);
typedef agg::renderer_base<agg::pixfmt_gray8> ren_base;
typedef agg::renderer_scanline_aa_solid<ren_base> renderer;
agg::pixfmt_gray8 pixf(g_alpha_mask_rbuf);
ren_base rb(pixf);
renderer r(rb);
agg::scanline_p8 sl;
rb.clear(agg::gray8(0));
agg::ellipse ell;
int i;
for(i = 0; i < 10; i++)
{
ell.init(rand() % cx,
rand() % cy,
rand() % 100 + 20,
rand() % 100 + 20,
100);
g_rasterizer.add_path(ell);
r.color(agg::gray8(rand() & 0xFF, rand() & 0xFF));
agg::render_scanlines(g_rasterizer, sl, r);
}
}
impl(int width, int height)
: width(width), height(height)
, simperclock(0.01)
, m_fman(m_feng), m_curves(m_fman.path_adaptor()), m_contour(m_curves)
{
if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
throw std::runtime_error(SDL_GetError());
screen = SDL_SetVideoMode(width, height, 0, SDL_ANYFORMAT|SDL_HWSURFACE);
if(!screen) {
SDL_Quit();
throw runtime_error(string("Unable to set screen: ") + SDL_GetError());
}
window = intrusive_ptr<SDL_Surface>(
SDL_CreateRGBSurface(SDL_SWSURFACE, screen->w, screen->h,
screen->format->BitsPerPixel,
rmask, gmask, bmask, amask)
, false);
if (!window)
SDL_Quit();
runtime_error (string("Unable to set window: ") + SDL_GetError());
rbwindow.attach((unsigned char*)window->pixels, window->w
, window->h, window->pitch);
SDL_WM_SetCaption("EOSimulator", 0);
}
template<class VertexSource> void generate_alpha_mask(VertexSource& vs)
{
unsigned cx = (unsigned)width();
unsigned cy = (unsigned)height();
delete [] m_alpha_buf;
m_alpha_buf = new unsigned char[cx * cy];
m_alpha_mask_rbuf.attach(m_alpha_buf, cx, cy, cx);
typedef agg::renderer_base<agg::pixfmt_gray8> ren_base;
typedef agg::renderer_scanline_aa_solid<ren_base> renderer;
agg::pixfmt_gray8 pixf(m_alpha_mask_rbuf);
ren_base rb(pixf);
renderer ren(rb);
start_timer();
if(m_operation.cur_item() == 0)
{
rb.clear(agg::gray8(0));
ren.color(agg::gray8(255));
}
else
{
rb.clear(agg::gray8(255));
ren.color(agg::gray8(0));
}
m_ras.add_path(vs);
agg::render_scanlines(m_ras, m_sl, ren);
double t1 = elapsed_time();
char buf[100];
sprintf(buf, "Generate AlphaMask: %.3fms", t1);
draw_text(250, 20, buf);
}
// Draw a black frame around the rendering buffer, assuming it has
// RGB-structure, one byte per color component
//--------------------------------------------------
void draw_black_frame(agg::rendering_buffer& rbuf)
{
unsigned i;
for(i = 0; i < rbuf.height(); ++i)
{
unsigned char* p = rbuf.row_ptr(i);
*p++ = 0; *p++ = 0; *p++ = 0; *p++=0; // 3 black in header
p += (rbuf.width() - 2) * sizeof(pixfmt);
*p++ = 0; *p++ = 0; *p++ = 0; *p++=0; // 3 black in tail
}
memset(rbuf.row_ptr(0), 0, rbuf.width() * sizeof(pixfmt));
memset(rbuf.row_ptr(rbuf.height() - 1), 0, rbuf.width() * sizeof(pixfmt));
}
bool write_ppm(const agg::rendering_buffer& buffer,
const char* file_name)
{
FILE* fd=fopen(file_name, "wb");
if (fd) {
fprintf(fd,"P6 %d %d 255\n", buffer.width(),buffer.height());
for (size_t y=0; y<buffer.height();y++)
{
const unsigned char* row=buffer.row_ptr(y);
fwrite(row,1,buffer.width()*3,fd);
}
fclose(fd);
return true;
}
return false;
}
static void
attach_buffer_to_BBitmap(agg::rendering_buffer& buffer, BBitmap* bitmap, bool flipY)
{
uint8* bits = (uint8*)bitmap->Bits();
uint32 width = bitmap->Bounds().IntegerWidth() + 1;
uint32 height = bitmap->Bounds().IntegerHeight() + 1;
int32 bpr = bitmap->BytesPerRow();
if (flipY) {
// XXX: why don't I have to do this?!?
// bits += bpr * (height - 1);
bpr = -bpr;
}
buffer.attach(bits, width, height, bpr);
}
// _DrawBitmap
void
Painter::_DrawBitmap(const agg::rendering_buffer& srcBuffer, color_space format,
BRect actualBitmapRect, BRect bitmapRect, BRect viewRect) const
{
switch (format) {
case B_RGB32:
case B_RGBA32:
_DrawBitmap32(srcBuffer, actualBitmapRect, bitmapRect, viewRect);
break;
default:
fprintf(stderr, "Painter::_DrawBitmap() - non-native colorspace: %d\n", format);
#ifdef __ANTARES__
// TODO: this is only a temporary implementation,
// to really handle other colorspaces, one would
// rather do the conversion with much less overhead,
// for example in the nn filter (hm), or in the
// scanline generator
BBitmap temp(actualBitmapRect, 0, B_RGB32);
status_t err = temp.ImportBits(srcBuffer.buf(),
srcBuffer.height() * srcBuffer.stride(),
srcBuffer.stride(),
0, format);
if (err >= B_OK) {
agg::rendering_buffer convertedBuffer;
convertedBuffer.attach((uint8*)temp.Bits(),
(uint32)actualBitmapRect.IntegerWidth() + 1,
(uint32)actualBitmapRect.IntegerHeight() + 1,
temp.BytesPerRow());
_DrawBitmap32(convertedBuffer, actualBitmapRect, bitmapRect, viewRect);
} else {
fprintf(stderr, "Painter::_DrawBitmap() - colorspace conversion failed: %s\n", strerror(err));
}
#endif // __ANTARES__
break;
}
}
bool save_image_file (agg::rendering_buffer& rbuf, const char *fn)
{
FILE* fd = fopen(fn, "wb");
if(fd == 0) return false;
unsigned w = rbuf.width();
unsigned h = rbuf.height();
fprintf(fd, "P6\n%d %d\n255\n", w, h);
unsigned y;
agg::pod_array<unsigned char> row_buf(w * 3);
unsigned char *tmp_buf = row_buf.data();
for(y = 0; y < rbuf.height(); y++)
{
const unsigned char* src = rbuf.row_ptr(app_flip_y ? h - 1 - y : y);
agg::color_conv_row(tmp_buf, src, w, agg::color_conv_bgr24_to_rgb24());
fwrite(tmp_buf, 1, w * 3, fd);
}
fclose(fd);
return true;
}
void CAggMemoryDC::PrepareBufferMemory(CDC& dc)
{
CreateCompatibleDC(dc);
if(CreateAggBitmap(m_rcUpdate.Width(), m_rcUpdate.Height(), &m_buf))
{
m_oldhbmp=(HBITMAP)::SelectObject(m_hDC, m_hbmp);
#if defined(__16BIT_COLOR555__) || defined(__16BIT_COLOR565__)
int stride=((m_rcUpdate.Width()*2+3)/4)*4;
#else
int stride=((m_rcUpdate.Width()*4+3)/4)*4;
#endif
m_rbuf.attach(
(unsigned char*)m_buf,
m_rcUpdate.Width(),
m_rcUpdate.Height(),
-stride); // Use negative stride for Y-axis going down.
FillSolidRect(0,0,m_rcUpdate.Width(),m_rcUpdate.Height(),GetSysColor(COLOR_WINDOW));
}
}
//------------------------------------------------------------------------
void generate_pattern()
{
unsigned size = unsigned(m_pattern_size.value());
create_star(m_pattern_size.value() / 2.0,
m_pattern_size.value() / 2.0,
m_pattern_size.value() / 2.5,
m_pattern_size.value() / 6.0,
6,
m_pattern_angle.value());
agg::conv_smooth_poly1_curve<agg::path_storage> smooth(m_ps);
agg::conv_stroke<agg::conv_smooth_poly1_curve<agg::path_storage> > stroke(smooth);
smooth.smooth_value(1.0);
smooth.approximation_scale(4.0);
stroke.width(m_pattern_size.value() / 15.0);
delete [] m_pattern;
m_pattern = new agg::int8u[size * size * pixfmt::pix_width];
m_pattern_rbuf.attach(m_pattern, size, size, size * pixfmt::pix_width);
pixfmt pixf(m_pattern_rbuf);
agg::renderer_base<pixfmt> rb(pixf);
agg::renderer_scanline_aa_solid<agg::renderer_base<pixfmt> > rs(rb);
rb.clear(agg::rgba_pre(0.4, 0.0, 0.1, m_pattern_alpha.value())); // Pattern background color
m_ras.add_path(smooth);
rs.color(agg::srgba8(110,130,50));
agg::render_scanlines(m_ras, m_sl, rs);
m_ras.add_path(stroke);
rs.color(agg::srgba8(0,50,80));
agg::render_scanlines(m_ras, m_sl, rs);
}
void roadmap_canvas_agg_configure (unsigned char *buf, int width, int height, int stride) {
roadmap_log( ROADMAP_ERROR, "roadmap_canvas_agg_configure, height =%d width=%d",height, width);
agg_rbuf.attach(buf, width, height, stride);
agg_renb.attach(agg_pixf);
agg_renb.reset_clipping(true);
ras.clip_box(0, 0, agg_renb.width() - 1, agg_renb.height() - 1);
agg::glyph_rendering gren = agg::glyph_ren_outline;
agg::glyph_rendering image_gren = agg::glyph_ren_agg_gray8;
roadmap_config_declare
("preferences", &RoadMapConfigFont, "font.ttf", NULL);
roadmap_config_declare
("preferences", &RoadMapConfigFontNormal, "font_normal.ttf", NULL);
char *font_file = roadmap_path_join(roadmap_path_user(),
roadmap_config_get (&RoadMapConfigFont));
if ((width) && (height))
roadmap_screen_set_screen_type( width, height );
if (!RoadMapCanvasFontLoaded) {
if(m_feng.load_font(font_file, 0, gren) &&
m_image_feng.load_font(font_file, 0, image_gren)) {
m_feng.hinting(true);
if ( roadmap_screen_is_hd_screen() )
{
m_feng.height(22);
m_feng.width(22);
}
else
{
#ifdef _WIN32
m_feng.height(12);
m_feng.width(12);
#else
m_feng.height(15);
m_feng.width(15);
#endif
}
m_feng.flip_y(true);
m_image_feng.hinting(true);
m_image_feng.flip_y(true);
RoadMapCanvasFontLoaded = 1;
} else {
RoadMapCanvasFontLoaded = -1;
char message[300];
snprintf(message, sizeof(message), "Can't load font: %s\n", font_file);
roadmap_messagebox("Error", message);
}
}
RoadMapCanvasFontLoaded = 1;
roadmap_path_free(font_file);
font_file = roadmap_path_join(roadmap_path_user(),
roadmap_config_get (&RoadMapConfigFontNormal));
if(m_feng_nor.load_font(font_file, 0, gren) &&
m_image_feng_nor.load_font(font_file, 0, image_gren)) {
m_feng_nor.hinting(true);
if ( roadmap_screen_is_hd_screen() )
{
m_feng_nor.height(22);
m_feng_nor.width(22);
}
else
{
#ifdef _WIN32
m_feng_nor.height(12);
m_feng_nor.width(12);
#else
m_feng_nor.height(15);
m_feng_nor.width(15);
#endif
}
m_feng_nor.flip_y(true);
m_image_feng_nor.hinting(true);
m_image_feng_nor.flip_y(true);
RoadMapCanvasNormalFontLoaded = 1;
}
}
virtual void on_resize(int sx, int sy)
{
m_gray8_buf.resize(sx * sy);
m_gray8_rbuf.attach(m_gray8_buf.data(), sx, sy, sx);
}
