svg (partial support) via AGG

[_maxim_]

Code: Select all

#include "agg_scanline_p.h"
#include "agg_basics.h"
#include "agg_rendering_buffer.h"
#include "agg_rasterizer_scanline_aa.h"
#include "agg_renderer_scanline.h"
#include "agg_pixfmt_rgba.h"
#include "agg_svg_parser.h"

using namespace agg;
using namespace svg;

typedef row_accessor<irr::u32> rendering_buffer_u32;
typedef pixfmt_alpha_blend_rgba<blender_bgra32, rendering_buffer_u32, pixel32_type> agg_pixel_type;

IRRLICHT_C_API agg::svg::path_renderer* agg_svg_path(char* file_name = "tiger.svg")
{
	agg::svg::path_renderer* m_path = new path_renderer();
	agg::svg::parser p(*m_path);
	p.parse(file_name);
	return m_path;
}

IRRLICHT_C_API ITexture* agg_svg_ITexture(agg::svg::path_renderer* m_path, IVideoDriver* driver, fschar_t* texture_name = "", double scale_value = 1.0, double rotate_value = 0.0, double expand_value = 0.0, video::ECOLOR_FORMAT color_format = ECF_A8R8G8B8, u32 alpha_value = 0, int stride_value = 1)
{
	double m_min_x = 0.0;
	double m_min_y = 0.0;
	double m_max_x = 0.0;
	double m_max_y = 0.0;
	//m_path->arrange_orientations();
	m_path->bounding_rect(&m_min_x, &m_min_y, &m_max_x, &m_max_y);
	m_max_x *= scale_value;
	m_max_y *= scale_value;
	const dimension2d<u32>& image_size = dimension2d<u32>((irr::u32)m_max_x, (irr::u32)m_max_y);
	IImage* image = driver->createImage(color_format, image_size);
	rendering_buffer_u32 rbuf((irr::u32*)image->lock(), image_size.Width, image_size.Height, image_size.Width*stride_value);
	//row_accessor<agg::int8u> rbuf((irr::u32*)image->lock(), image_size.Width, image_size.Height, image_size.Width*stride_value);
	agg_pixel_type pixf(rbuf);
	agg::renderer_base<agg_pixel_type> renb(pixf);
	agg::renderer_scanline_aa_solid<agg::renderer_base<agg_pixel_type>> ren(renb);
	renb.clear(agg::rgba8(255, 255, 255, alpha_value));
	agg::rasterizer_scanline_aa<> ras;
	agg::scanline_p8 sl;
	agg::trans_affine mtx;
	mtx *= agg::trans_affine_scaling(scale_value);
	mtx *= agg::trans_affine_rotation(agg::deg2rad(rotate_value));
	agg::render_scanlines(ras, sl, ren);
	m_path->expand(expand_value);
	m_path->render(ras, sl, ren, mtx, renb.clip_box(), 1.0);
	image->unlock();
	ITexture* texture = driver->addTexture(texture_name, image);
	image->drop();
	if (image)
		delete image;
	return texture;
}

for usage one call agg_svg_path(file_name), after this can many calls agg_svg_ITexture(...) for scale, rotate and etc. See "svg_viewer.py" for example from http://pir.sourceforge.net

[hybrid]

To reduce google load, here's the link to agg http://antigrain.com/
Sounds nice, after all. And integration seems pretty easy.

[_maxim_]

Thanks and sorry for my "memory leak".

I must add few instructions:

AGG svg parser depends from http://libexpat.org
and AGG image optional depends from zlib and libpng respectively.

For compile project or makefile require add next cpp files: agg_curves.cpp, agg_trans_affine.cpp, agg_vcgen_contour.cpp, agg_vcgen_stroke.cpp

If project with svg parser also include: agg_svg_parser.cpp, agg_svg_path_renderer.cpp, agg_svg_path_tokenizer.cpp

Next function do direct access to vector drawing functional and not require svg parser

Code: Select all

ITexture* test_vectors(IVideoDriver* driver, video::ECOLOR_FORMAT image_format = ECF_R8G8B8, const dimension2d<u32>& image_size = dimension2d<u32>(640, 480), char* texture_name = "texture_01", u32 alpha_value = 0)
{
	IImage* image = driver->createImage(image_format, image_size);

	agg::rendering_buffer rbuf;
	rbuf.attach((unsigned char*)image->lock(), image_size.Width, image_size.Height, image_size.Width*4);

	// Pixel format and basic primitives renderer
	agg::pixfmt_bgra32 pixf(rbuf);
	agg::renderer_base<agg::pixfmt_bgra32> renb(pixf);

	renb.clear(agg::rgba8(255, 255, 255, alpha_value));

	// Scanline renderer for solid filling.
	agg::renderer_scanline_aa_solid<agg::renderer_base<agg::pixfmt_bgra32> > ren(renb);

	// Rasterizer & scanline
	agg::rasterizer_scanline_aa<> ras;
	agg::scanline_p8 sl;

	// Polygon (triangle)
	ras.move_to_d(20.7, 34.15);
	ras.line_to_d(398.23, 123.43);
	ras.line_to_d(165.45, 401.87);

	// Setting the attrribute (color) & Rendering
	ren.color(agg::rgba8(80, 90, 60));
	agg::render_scanlines(ras, sl, ren);

	image->unlock();
	return driver->addTexture(texture_name, image);
}

[_maxim_]

Code: Select all

class agg_svg_loader : public irr::video::IImageLoader
{
public:
	agg_svg_loader(IVideoDriver* driver)
	{
		video_driver = driver;
	}
	~agg_svg_loader()
	{
		video_driver = 0;
	}
	virtual bool isALoadableFileExtension(const io::path& filename) const
	{
		return core::hasFileExtension ( filename, "svg" );
	}
	virtual bool isALoadableFileFormat(irr::io::IReadFile* file) const
	{
		return (false);
	}
	virtual irr::video::IImage* loadImage(irr::io::IReadFile* file) const
	{
		agg::svg::path_renderer m_path;
		agg::svg::parser p(m_path);
		p.parse(file->getFileName().c_str());
		double m_min_x = 0.0;
		double m_min_y = 0.0;
		double m_max_x = 0.0;
		double m_max_y = 0.0;
		m_path.bounding_rect(&m_min_x, &m_min_y, &m_max_x, &m_max_y);
		const dimension2d<u32>& image_size = dimension2d<u32>((irr::u32)m_max_x, (irr::u32)m_max_y);
		IImage* image = video_driver->createImage(ECF_A8R8G8B8, image_size);
		typedef row_accessor<irr::u32> rendering_buffer_u32;
		rendering_buffer_u32 rbuf((irr::u32*)image->lock(), image_size.Width, image_size.Height, image_size.Width);
		agg_pixel_type pixf(rbuf);
		agg::renderer_base<agg_pixel_type> renb(pixf);
		agg::renderer_scanline_aa_solid<agg::renderer_base<agg_pixel_type>> ren(renb);
		renb.clear(agg::rgba8(255, 255, 255, 0));
		agg::rasterizer_scanline_aa<> ras;
		agg::scanline_p8 sl;
		agg::trans_affine mtx;
		agg::render_scanlines(ras, sl, ren);
		m_path.render(ras, sl, ren, mtx, renb.clip_box(), 1.0);
		image->unlock();
		return image;
	}
	protected:
		IVideoDriver* video_driver;
};

video_driver->addExternalImageLoader(new agg_svg_loader(video_driver));
ITexture* tex = video_driver->getTexture("test.svg");

[_maxim_]

experimental SVG parser based on Irrlicht XML

AGG backend
http://code.google.com/p/pyirrlicht/sou ... svn10&r=10

Cairo backend
http://code.google.com/p/pyirrlicht/sou ... svn10&r=10

[REDDemon]

What about loading SWG directly as vertices/lines? textures use much more memory.

[_maxim_]

interesting, but required more skils than I have.
if I understand you, this topic was about http://irrlicht.sourceforge.net/forum/v ... hp?t=40234
if you have any ideas, I can trying