static void prepare_stars()
{
for(int i = 0; i < MAX_STARS; i++)
{
stars[i] = create_star();
}
}
//------------------------------------------------------------------------
virtual void on_mouse_button_down(int x, int y, unsigned flags) {
if (flags & agg::mouse_left) {
if (sqrt((x - m_image_cx) * (x - m_image_cx) +
(y - m_image_cy) * (y - m_image_cy)) < 5.0) {
m_dx = x - m_image_cx;
m_dy = y - m_image_cy;
m_flag = 1;
} else {
agg::rasterizer_scanline_aa<> ras;
agg::trans_affine polygon_mtx;
polygon_mtx *=
agg::trans_affine_translation(-m_polygon_cx, -m_polygon_cy);
polygon_mtx *= agg::trans_affine_rotation(m_polygon_angle.value() *
agg::pi / 180.0);
polygon_mtx *= agg::trans_affine_scaling(m_polygon_scale.value(),
m_polygon_scale.value());
polygon_mtx *=
agg::trans_affine_translation(m_polygon_cx, m_polygon_cy);
agg::path_storage ps;
create_star(ps);
agg::conv_transform<agg::path_storage> tr(ps, polygon_mtx);
ras.add_path(tr);
if (ras.hit_test(x, y)) {
m_dx = x - m_polygon_cx;
m_dy = y - m_polygon_cy;
m_flag = 2;
}
}
}
}
static void prepare_stars()
{
mVisibleStars = 0;
for (int i = 0; i < MAX_STARS; i++)
{
stars[i] = create_star();
}
}
void MainWindow::on_pushButton_3_clicked()
{
setButtonState(false,false);
int lvl = selected_lvl();
space * wp = (space*)getRoot();
if(lvl == 0)
{
star * p_star = create_star();
update_star(p_star,ui->lineEdit_star_name->text(),
ui->lineEdit_star_class->text(),
ui->lineEdit_star_mass->text().toFloat());
add_star_sort(wp,p_star);
}else if(lvl == 1){
int index_s = selected_index(0);
star * p_star = (star*)wp->sublvl[index_s];
planet * p_planet = create_planet();
update_planet(p_planet,ui->lineEdit_planet_name->text(),
ui->lineEdit_dist_to_star->text().toFloat(),
ui->lineEdit_planet_mass->text().toFloat());
add_planet_sort(p_star,p_planet);
}else if(lvl == 2){
int index_s = selected_index(1);
star * p_star = (star*)wp->sublvl[index_s];
int index_p = selected_index(0);
planet * p_planet = (planet*)p_star->sublvl[index_p];
satellite * p_sat = create_satellite();
update_satellite(p_sat,ui->lineEdit_sat_name->text(),
ui->lineEdit_sat_dist->text().toFloat(),
ui->checkBox->isChecked());
add_satellite_sort(p_planet,p_sat);
}else{
setButtonState(true,true);
}
show_tree();
}
//------------------------------------------------------------------------
virtual void on_mouse_button_down(int x, int y, unsigned flags)
{
if(flags & agg::mouse_left)
{
agg::trans_affine polygon_mtx;
polygon_mtx *= agg::trans_affine_translation(-m_polygon_cx, -m_polygon_cy);
polygon_mtx *= agg::trans_affine_rotation(m_polygon_angle.value() * agg::pi / 180.0);
polygon_mtx *= agg::trans_affine_scaling(m_polygon_scale.value(), m_polygon_scale.value());
polygon_mtx *= agg::trans_affine_translation(m_polygon_cx, m_polygon_cy);
double r = initial_width() / 3.0 - 8.0;
create_star(m_polygon_cx, m_polygon_cy, r, r / 1.45, 14);
agg::conv_transform<agg::path_storage> tr(m_ps, polygon_mtx);
m_ras.add_path(tr);
if(m_ras.hit_test(x, y))
{
m_dx = x - m_polygon_cx;
m_dy = y - m_polygon_cy;
m_flag = 1;
}
}
}
//------------------------------------------------------------------------
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);
}
int SDL_main(int argc, char** argv) {
#else
int main(int argc, char** argv) {
#endif
uint32_t windowFlags = 0;
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
SDL_GLContext glContext = nullptr;
#if defined(SK_BUILD_FOR_ANDROID) || defined(SK_BUILD_FOR_IOS)
// For Android/iOS we need to set up for OpenGL ES and we make the window hi res & full screen
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE |
SDL_WINDOW_BORDERLESS | SDL_WINDOW_FULLSCREEN_DESKTOP |
SDL_WINDOW_ALLOW_HIGHDPI;
#else
// For all other clients we use the core profile and operate in a window
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
windowFlags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
#endif
static const int kStencilBits = 8; // Skia needs 8 stencil bits
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, kStencilBits);
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
// If you want multisampling, uncomment the below lines and set a sample count
static const int kMsaaSampleCount = 0; //4;
// SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
// SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, kMsaaSampleCount);
/*
* In a real application you might want to initialize more subsystems
*/
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS) != 0) {
handle_error();
return 1;
}
// Setup window
// This code will create a window with the same resolution as the user's desktop.
SDL_DisplayMode dm;
if (SDL_GetDesktopDisplayMode(0, &dm) != 0) {
handle_error();
return 1;
}
SDL_Window* window = SDL_CreateWindow("SDL Window", SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, dm.w, dm.h, windowFlags);
if (!window) {
handle_error();
return 1;
}
// To go fullscreen
// SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN);
// try and setup a GL context
glContext = SDL_GL_CreateContext(window);
if (!glContext) {
handle_error();
return 1;
}
int success = SDL_GL_MakeCurrent(window, glContext);
if (success != 0) {
handle_error();
return success;
}
uint32_t windowFormat = SDL_GetWindowPixelFormat(window);
int contextType;
SDL_GL_GetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, &contextType);
int dw, dh;
SDL_GL_GetDrawableSize(window, &dw, &dh);
glViewport(0, 0, dw, dh);
glClearColor(1, 1, 1, 1);
glClearStencil(0);
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
// setup GrContext
auto interface = GrGLMakeNativeInterface();
// setup contexts
sk_sp<GrContext> grContext(GrContext::MakeGL(interface));
SkASSERT(grContext);
// Wrap the frame buffer object attached to the screen in a Skia render target so Skia can
// render to it
GrGLint buffer;
GR_GL_GetIntegerv(interface.get(), GR_GL_FRAMEBUFFER_BINDING, &buffer);
GrGLFramebufferInfo info;
info.fFBOID = (GrGLuint) buffer;
SkColorType colorType;
//SkDebugf("%s", SDL_GetPixelFormatName(windowFormat));
// TODO: the windowFormat is never any of these?
if (SDL_PIXELFORMAT_RGBA8888 == windowFormat) {
info.fFormat = GR_GL_RGBA8;
colorType = kRGBA_8888_SkColorType;
} else {
colorType = kBGRA_8888_SkColorType;
if (SDL_GL_CONTEXT_PROFILE_ES == contextType) {
info.fFormat = GR_GL_BGRA8;
} else {
// We assume the internal format is RGBA8 on desktop GL
info.fFormat = GR_GL_RGBA8;
}
}
GrBackendRenderTarget target(dw, dh, kMsaaSampleCount, kStencilBits, info);
// setup SkSurface
// To use distance field text, use commented out SkSurfaceProps instead
// SkSurfaceProps props(SkSurfaceProps::kUseDeviceIndependentFonts_Flag,
// SkSurfaceProps::kLegacyFontHost_InitType);
SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
sk_sp<SkSurface> surface(SkSurface::MakeFromBackendRenderTarget(grContext.get(), target,
kBottomLeft_GrSurfaceOrigin,
colorType, nullptr, &props));
SkCanvas* canvas = surface->getCanvas();
canvas->scale((float)dw/dm.w, (float)dh/dm.h);
ApplicationState state;
const char* helpMessage = "Click and drag to create rects. Press esc to quit.";
SkPaint paint;
// create a surface for CPU rasterization
sk_sp<SkSurface> cpuSurface(SkSurface::MakeRaster(canvas->imageInfo()));
SkCanvas* offscreen = cpuSurface->getCanvas();
offscreen->save();
offscreen->translate(50.0f, 50.0f);
offscreen->drawPath(create_star(), paint);
offscreen->restore();
sk_sp<SkImage> image = cpuSurface->makeImageSnapshot();
int rotation = 0;
SkFont font;
while (!state.fQuit) { // Our application loop
SkRandom rand;
canvas->clear(SK_ColorWHITE);
handle_events(&state, canvas);
paint.setColor(SK_ColorBLACK);
canvas->drawString(helpMessage, 100.0f, 100.0f, font, paint);
for (int i = 0; i < state.fRects.count(); i++) {
paint.setColor(rand.nextU() | 0x44808080);
canvas->drawRect(state.fRects[i], paint);
}
// draw offscreen canvas
canvas->save();
canvas->translate(dm.w / 2.0, dm.h / 2.0);
canvas->rotate(rotation++);
canvas->drawImage(image, -50.0f, -50.0f);
canvas->restore();
canvas->flush();
SDL_GL_SwapWindow(window);
}
if (glContext) {
SDL_GL_DeleteContext(glContext);
}
//Destroy window
SDL_DestroyWindow(window);
//Quit SDL subsystems
SDL_Quit();
return 0;
}
//------------------------------------------------------------------------
virtual void on_draw()
{
double width = rbuf_window().width();
double height = rbuf_window().height();
typedef agg::renderer_base<pixfmt> renderer_base;
typedef agg::renderer_base<pixfmt_pre> renderer_base_pre;
pixfmt pixf(rbuf_window());
pixfmt_pre pixf_pre(rbuf_window());
renderer_base rb(pixf);
renderer_base_pre rb_pre(pixf_pre);
rb.clear(agg::rgba(1.0, 1.0, 1.0));
agg::trans_affine polygon_mtx;
polygon_mtx *= agg::trans_affine_translation(-m_polygon_cx, -m_polygon_cy);
polygon_mtx *= agg::trans_affine_rotation(m_polygon_angle.value() * agg::pi / 180.0);
polygon_mtx *= agg::trans_affine_scaling(m_polygon_scale.value());
polygon_mtx *= agg::trans_affine_translation(m_polygon_cx, m_polygon_cy);
double r = initial_width() / 3.0 - 8.0;
create_star(m_polygon_cx, m_polygon_cy, r, r / 1.45, 14);
agg::conv_transform<agg::path_storage> tr(m_ps, polygon_mtx);
typedef agg::wrap_mode_reflect_auto_pow2 wrap_x_type;
typedef agg::wrap_mode_reflect_auto_pow2 wrap_y_type;
typedef agg::image_accessor_wrap<pixfmt,
wrap_x_type,
wrap_y_type> img_source_type;
typedef agg::span_pattern_rgba<img_source_type> span_gen_type;
unsigned offset_x = 0;
unsigned offset_y = 0;
if(m_tie_pattern.status())
{
offset_x = unsigned(width-m_polygon_cx);
offset_y = unsigned(height-m_polygon_cy);
}
agg::span_allocator<color_type> sa;
pixfmt img_pixf(m_pattern_rbuf);
img_source_type img_src(img_pixf);
span_gen_type sg(img_src, offset_x, offset_y);
// Alpha is meaningful for RGB only because RGBA has its own
sg.alpha(span_gen_type::value_type(m_pattern_alpha.value() * 255.0));
m_ras.add_path(tr);
agg::render_scanlines_aa(m_ras, m_sl, rb_pre, sa, sg);
agg::render_ctrl(m_ras, m_sl, rb, m_polygon_angle);
agg::render_ctrl(m_ras, m_sl, rb, m_polygon_scale);
agg::render_ctrl(m_ras, m_sl, rb, m_pattern_angle);
agg::render_ctrl(m_ras, m_sl, rb, m_pattern_size);
agg::render_ctrl(m_ras, m_sl, rb, m_pattern_alpha);
agg::render_ctrl(m_ras, m_sl, rb, m_rotate_polygon);
agg::render_ctrl(m_ras, m_sl, rb, m_rotate_pattern);
agg::render_ctrl(m_ras, m_sl, rb, m_tie_pattern);
}
//------------------------------------------------------------------------
virtual void on_draw() {
typedef agg::renderer_base<pixfmt> renderer_base;
typedef agg::renderer_scanline_aa_solid<renderer_base> renderer_solid;
pixfmt pixf(rbuf_window());
pixfmt pixf_img(rbuf_img(0));
renderer_base rb(pixf);
renderer_solid rs(rb);
rb.clear(agg::rgba(1.0, 1.0, 1.0));
agg::trans_affine image_mtx;
agg::trans_affine polygon_mtx;
polygon_mtx *= agg::trans_affine_translation(-m_polygon_cx, -m_polygon_cy);
polygon_mtx *=
agg::trans_affine_rotation(m_polygon_angle.value() * agg::pi / 180.0);
polygon_mtx *= agg::trans_affine_scaling(m_polygon_scale.value());
polygon_mtx *= agg::trans_affine_translation(m_polygon_cx, m_polygon_cy);
switch (m_example.cur_item()) {
default:
case 0:
// --------------(Example 0, Identity matrix)
break;
case 1:
// --------------(Example 1)
image_mtx *=
agg::trans_affine_translation(-m_image_center_x, -m_image_center_y);
image_mtx *= agg::trans_affine_rotation(m_polygon_angle.value() *
agg::pi / 180.0);
image_mtx *= agg::trans_affine_scaling(m_polygon_scale.value());
image_mtx *= agg::trans_affine_translation(m_polygon_cx, m_polygon_cy);
image_mtx.invert();
break;
case 2:
// --------------(Example 2)
image_mtx *=
agg::trans_affine_translation(-m_image_center_x, -m_image_center_y);
image_mtx *=
agg::trans_affine_rotation(m_image_angle.value() * agg::pi / 180.0);
image_mtx *= agg::trans_affine_scaling(m_image_scale.value());
image_mtx *= agg::trans_affine_translation(m_image_cx, m_image_cy);
image_mtx.invert();
break;
case 3:
// --------------(Example 3)
image_mtx *=
agg::trans_affine_translation(-m_image_center_x, -m_image_center_y);
image_mtx *=
agg::trans_affine_rotation(m_image_angle.value() * agg::pi / 180.0);
image_mtx *= agg::trans_affine_scaling(m_image_scale.value());
image_mtx *= agg::trans_affine_translation(m_polygon_cx, m_polygon_cy);
image_mtx.invert();
break;
case 4:
// --------------(Example 4)
image_mtx *= agg::trans_affine_translation(-m_image_cx, -m_image_cy);
image_mtx *= agg::trans_affine_rotation(m_polygon_angle.value() *
agg::pi / 180.0);
image_mtx *= agg::trans_affine_scaling(m_polygon_scale.value());
image_mtx *= agg::trans_affine_translation(m_polygon_cx, m_polygon_cy);
image_mtx.invert();
break;
case 5:
// --------------(Example 5)
image_mtx *=
agg::trans_affine_translation(-m_image_center_x, -m_image_center_y);
image_mtx *=
agg::trans_affine_rotation(m_image_angle.value() * agg::pi / 180.0);
image_mtx *= agg::trans_affine_rotation(m_polygon_angle.value() *
agg::pi / 180.0);
image_mtx *= agg::trans_affine_scaling(m_image_scale.value());
image_mtx *= agg::trans_affine_scaling(m_polygon_scale.value());
image_mtx *= agg::trans_affine_translation(m_image_cx, m_image_cy);
image_mtx.invert();
break;
case 6:
// --------------(Example 6)
image_mtx *= agg::trans_affine_translation(-m_image_cx, -m_image_cy);
image_mtx *=
agg::trans_affine_rotation(m_image_angle.value() * agg::pi / 180.0);
image_mtx *= agg::trans_affine_scaling(m_image_scale.value());
image_mtx *= agg::trans_affine_translation(m_image_cx, m_image_cy);
image_mtx.invert();
break;
}
typedef agg::span_interpolator_linear<> interpolator_type;
interpolator_type interpolator(image_mtx);
agg::span_allocator<color_type> sa;
// "hardcoded" bilinear filter
//------------------------------------------
typedef agg::span_image_filter_rgba_bilinear_clip<pixfmt, interpolator_type>
span_gen_type;
span_gen_type sg(pixf_img, agg::rgba(1, 1, 1), interpolator);
//------------------------------------------
agg::rasterizer_scanline_aa<> ras;
agg::scanline_u8 sl;
agg::path_storage ps;
create_star(ps);
agg::conv_transform<agg::path_storage> tr(ps, polygon_mtx);
ras.add_path(tr);
agg::render_scanlines_aa(ras, sl, rb, sa, sg);
agg::ellipse e1(m_image_cx, m_image_cy, 5, 5, 20);
agg::ellipse e2(m_image_cx, m_image_cy, 2, 2, 20);
agg::conv_stroke<agg::ellipse> c1(e1);
rs.color(agg::rgba(0.7, 0.8, 0));
ras.add_path(e1);
agg::render_scanlines(ras, sl, rs);
rs.color(agg::rgba(0, 0, 0));
ras.add_path(c1);
agg::render_scanlines(ras, sl, rs);
ras.add_path(e2);
agg::render_scanlines(ras, sl, rs);
agg::render_ctrl(ras, sl, rb, m_polygon_angle);
agg::render_ctrl(ras, sl, rb, m_polygon_scale);
agg::render_ctrl(ras, sl, rb, m_image_angle);
agg::render_ctrl(ras, sl, rb, m_image_scale);
agg::render_ctrl(ras, sl, rb, m_rotate_polygon);
agg::render_ctrl(ras, sl, rb, m_rotate_image);
agg::render_ctrl(ras, sl, rb, m_example);
}
