static void draw_tile(drawing *dr, game_drawstate *ds, game_state *state, int x, int y, int tile, int flash_colour) { if (tile == 0) { draw_rect(dr, x, y, TILE_SIZE, TILE_SIZE, flash_colour); } else { int coords[6]; char str[40]; coords[0] = x + TILE_SIZE - 1; coords[1] = y + TILE_SIZE - 1; coords[2] = x + TILE_SIZE - 1; coords[3] = y; coords[4] = x; coords[5] = y + TILE_SIZE - 1; draw_polygon(dr, coords, 3, COL_LOWLIGHT, COL_LOWLIGHT); coords[0] = x; coords[1] = y; draw_polygon(dr, coords, 3, COL_HIGHLIGHT, COL_HIGHLIGHT); draw_rect(dr, x + HIGHLIGHT_WIDTH, y + HIGHLIGHT_WIDTH, TILE_SIZE - 2*HIGHLIGHT_WIDTH, TILE_SIZE - 2*HIGHLIGHT_WIDTH, flash_colour); sprintf(str, "%d", tile); draw_text(dr, x + TILE_SIZE/2, y + TILE_SIZE/2, FONT_VARIABLE, TILE_SIZE/3, ALIGN_VCENTRE | ALIGN_HCENTRE, COL_TEXT, str); } draw_update(dr, x, y, TILE_SIZE, TILE_SIZE); }
void display() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if(display_state == clipping) { glColor3f(1, 0, 0); draw_polygon(pol); if(rect_visible) { glColor4f(0, 1, 0, 0.5); glRecti(rect_corner_from_x, rect_corner_from_y, rect_corner_to_x, rect_corner_to_y); } glutSwapBuffers(); } else if(display_state == clipped) { glColor3f(1, 0, 0); draw_polygon(clipped_pol_bottom); } else if(display_state == drawing_polygon) { glColor3f(1, 0, 0); draw_polygon(pol); } else { } }
static void render(struct widget *w) { struct widget_priv *priv = w->priv; struct canvas *ca = &w->ca; char buf[10]; struct point uav_points[4] = { {0, 0}, {6, 8}, {0, -8}, {-6, 8} }; struct polygon uav = { .len = 4, .points = uav_points, }; struct point arrow_points[7] = { {1, -10}, {1, -3}, {4, -4}, {0, 0}, {-4, -4}, {-1, -3}, {-1, -10} }; struct polygon arrow = { .len = 7, .points = arrow_points, }; move_polygon(&uav, ca->width >> 1, ca->height >> 1); draw_polygon(&uav, 3, ca); move_polygon(&uav, -1, -1); draw_polygon(&uav, 1, ca); move_polygon(&arrow, 0, -11); transform_polygon(&arrow, ca->width >> 1, ca->height >> 1, priv->direction - priv->heading); draw_polygon(&arrow, 3, ca); move_polygon(&arrow, -1, -1); draw_polygon(&arrow, 1, ca); switch (get_units(w->cfg)) { case UNITS_METRIC: default: sprintf(buf, "%dkm/h", (int) ((priv->speed * 3600) / 1000)); break; case UNITS_IMPERIAL: sprintf(buf, "%dmph", (int) ((priv->speed * 3600) * M2MILE)); break; case UNITS_CUSTOM_1: sprintf(buf, "%dm/s", (int) (priv->speed)); break; case UNITS_CUSTOM_2: sprintf(buf, "%df/s", (int) (priv->speed * M2FEET)); break; case UNITS_CUSTOM_3: sprintf(buf, "%dkn", (int) ((priv->speed * 3600 * 1.852) / 1000)); break; } draw_str(buf, 0, 0, ca, 0); } const struct widget_ops wind_widget_ops = { .name = "Wind information", .mavname = "WINDINF", .id = WIDGET_WIND_ID, .init = NULL, .open = open, .render = render, .close = NULL, };
static void render(struct widget *w) { struct home_data *priv = w->priv; struct canvas *ca = &w->ca; char buf[50]; float d, a; struct point arrow_points[7] = { {-3, 0}, {-3, -6}, {3, -6}, {3, 0}, {6, 0}, {0, 6}, {-6, 0} }; struct polygon arrow = { .len = 7, .points = arrow_points, }; if (priv->lock != HOME_LOCKED) { sprintf(buf, "No Home"); draw_str(buf, 0, 0, ca, 2); } else { switch (get_units(w->cfg)) { case UNITS_METRIC: default: sprintf(buf, "Alt %dm\nDis %dm\n%d", priv->altitude, (unsigned int) priv->distance, priv->direction); break; case UNITS_IMPERIAL: a = (float) priv->altitude * M2FEET; d = (float) priv->distance * M2FEET; sprintf(buf, "Alt %df\nDis %df\n%d", (unsigned int) a, (unsigned int) d, priv->direction); break; } draw_str(buf, 0, 0, ca, 1); transform_polygon(&arrow, 50, 34, priv->direction + 180); draw_polygon(&arrow, 3, ca); move_polygon(&arrow, -1, -1); draw_polygon(&arrow, 1, ca); } } const struct widget_ops home_info_widget_ops = { .name = "Home info", .mavname = "HOMEINF", .id = WIDGET_HOME_INFO_ID, .init = NULL, .open = open, .render = render, .close = NULL, };
void SoftwareRendererImp::draw_element(SVGElement* element) { // Task 4 (part 1): // Modify this to implement the transformation stack switch (element->type) { case POINT: draw_point(static_cast<Point&>(*element)); break; case LINE: draw_line(static_cast<Line&>(*element)); break; case POLYLINE: draw_polyline(static_cast<Polyline&>(*element)); break; case RECT: draw_rect(static_cast<Rect&>(*element)); break; case POLYGON: draw_polygon(static_cast<Polygon&>(*element)); break; case ELLIPSE: draw_ellipse(static_cast<Ellipse&>(*element)); break; case IMAGE: draw_image(static_cast<Image&>(*element)); break; case GROUP: draw_group(static_cast<Group&>(*element)); break; default: break; } }
int main (void) { display scr; polygon p; display_create(&scr, 80, 35); obj_pol_create(&p, 5); srand(time(NULL)); for (;;) { obj_pol_add_vertex(&p, 1 + abs(rand() % scr.width-2), 1 + abs(rand() % scr.height-2)); obj_pol_add_vertex(&p, 1 + abs(rand() % scr.width-2), 1 + abs(rand() % scr.height-2)); obj_pol_add_vertex(&p, 1 + abs(rand() % scr.width-2), 1 + abs(rand() % scr.height-2)); obj_pol_add_vertex(&p, 1 + abs(rand() % scr.width-2), 1 + abs(rand() % scr.height-2)); obj_pol_add_vertex(&p, 1 + abs(rand() % scr.width-2), 1 + abs(rand() % scr.height-2)); draw_polygon(&scr, &p); display_show(&scr); display_clear(&scr); #ifdef _WIN32 Sleep(150); #else usleep(150000); #endif } }
int main(void){ //tests(); POLYGON temp; assert(get_size(&temp.size_points)==TRUE); alloc_points(&temp.max_of_x,&temp.points,temp.size_points); temp.segments=create_segments(temp.size_points); add_segments(temp.points,temp.segments,temp.size_points); draw_polygon(temp); triangulal_polygol(temp); printf("Potrzeba %d straznikow\n",coloring_sl(temp.points,temp.segments,temp.size_points)); print_colors(temp.points,temp.size_points); draw_polygon(temp); free_segments(temp.segments,temp.size_points); free_points(temp.points); return EXIT_SUCCESS; }
static void set_foreground(GdkColor *color, int status) { int num_app_shells = get_num_shells(); int i, num; GdkPoint *p; num = numpoints[status]; p = polyptr[status]; for (i = 0; i < num_app_shells; i++) { tape_status_widget *ts = &app_shells[i].tape_status; if (ts) { cairo_t *cr = gdk_cairo_create(gtk_widget_get_window(ts->control)); if (cr) { gdk_cairo_set_source_color(cr, color); cairo_translate(cr, 0, (gtk_widget_get_allocated_height(ts->control) - CTRL_HEIGHT) / 2); if (num) { draw_polygon(cr, p, num); } else { cairo_arc(cr, CTRL_WIDTH / 2, CTRL_HEIGHT / 2, (CTRL_HEIGHT / 2) - 1, 0, 360.0f * (M_PI / 180.0f)); } cairo_fill (cr); cairo_destroy(cr); } } } }
void draw_triangle(PFBDEV pFbdev, POINT p1, POINT p2, POINT p3, uint8_t r, uint8_t g, uint8_t b) { POINT p[3]; p[0] = p1; p[1] = p2; p[2] = p3; draw_polygon(pFbdev, 3, p, r, g, b); }
void ShZshapeManager::draw_shape(const char* content) { if (content == "cube") { draw_cube(); } if (content == "cylinder") { draw_cylinder(); } if (content == "pipe") { draw_pipe(); } if (content == "cone") { draw_cone(); } if (content == "circle") { draw_circle(); } if (content == "ring") { draw_ring(); } if (content == "pyramid") { draw_pyramid(); } if (content == "triangle") { draw_triangle(); } if (content == "rectangle") { draw_rectangle(); } if (content == "polygon") { draw_polygon(); } if (content == "multigonalStar") { draw_multigonalStar(); } }
void display(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); draw_polygon(); /* execute the drawing commands */ glFlush(); }
void ClockDraw::draw_simple_hand(double angle, double len) { Vertex v[] = { Vertex(-2, 4), Vertex(-2, -len - 1), Vertex( 2, -len - 1), Vertex( 2, 4), Vertex(-1, 3), Vertex(-1, -len), Vertex( 1, -len), Vertex( 1, 3) }; std::for_each(v, v+8, Vector_add_rotator(Vertex(30.5, 30.5), angle*M_PI/180)); draw_polygon(ras, v, v+4, Color(255, 255, 255)); draw_polygon(ras, v+4, v+8, Color(255, 128, 128)); }
void LightOccluder2D::_notification(int p_what) { if (p_what==NOTIFICATION_ENTER_CANVAS) { VS::get_singleton()->canvas_light_occluder_attach_to_canvas(occluder,get_canvas()); VS::get_singleton()->canvas_light_occluder_set_transform(occluder,get_global_transform()); VS::get_singleton()->canvas_light_occluder_set_enabled(occluder,is_visible()); } if (p_what==NOTIFICATION_TRANSFORM_CHANGED) { VS::get_singleton()->canvas_light_occluder_set_transform(occluder,get_global_transform()); } if (p_what==NOTIFICATION_VISIBILITY_CHANGED) { VS::get_singleton()->canvas_light_occluder_set_enabled(occluder,is_visible()); } if (p_what==NOTIFICATION_DRAW) { if (get_tree()->is_editor_hint()) { if (occluder_polygon.is_valid()) { DVector<Vector2> poly = occluder_polygon->get_polygon(); if (poly.size()) { if (occluder_polygon->is_closed()) { Vector<Color> color; color.push_back(Color(0,0,0,0.6)); draw_polygon(Variant(poly),color); } else { int ps=poly.size(); DVector<Vector2>::Read r = poly.read(); for(int i=0;i<ps-1;i++) { draw_line(r[i],r[i+1],Color(0,0,0,0.6),3); } } } } } } if (p_what==NOTIFICATION_EXIT_CANVAS) { VS::get_singleton()->canvas_light_occluder_attach_to_canvas(occluder,RID()); } }
int draw_rectangle(Vec pos, double width, double height) { GLdouble cw = width / 2.0; GLdouble ch = height / 2.0; Vec square[4] = { { pos.x + cw, pos.y + ch }, { pos.x + cw, pos.y - ch }, { pos.x - cw, pos.y - ch }, { pos.x - cw, pos.y + ch } }; return draw_polygon(square, 4); }
gint button_release_event(GtkWidget *widget,GdkEventButton *event ) { if (event->state & GDK_BUTTON1_MASK && pixmap != NULL) switch(tool) { case RECT_SEL: select_rectangular_region(widget,event->x,event->y,0); selected++; break; case ERASER: eraser(widget,event->x,event->y); break; case LINE:draw_line(widget,event->x,event->y,0); break; case BRUSH: paintbrush(widget,event->x,event->y); break; case SPRAYCAN: spraycan(widget,event->x,event->y); break; case PENCIL:draw_using_pencil(widget,event->x,event->y); break; case BUCKET: break; case POLYLINE: draw_line(widget,event->x,event->y,0); pre_x=last_x=event->x; pre_y=last_y=event->y; break; case ELLIPSE: draw_arc(widget,event->x,event->y,0); break; case POLYGON: draw_polygon(widget,event->x,event->y,0); last_x=event->x; last_y=event->y; lineflag++; break; case RECTANGLE:draw_rectangle(widget,event->x,event->y,0); break; } return TRUE; }
int draw_square(Vec pos, double side) { GLdouble r = side / 2.0; GLdouble x = pos.x; GLdouble y = pos.y; Vec square[4] = { { x + r, y + r }, { x + r, y - r }, { x - r, y - r }, { x - r, y + r } }; return draw_polygon(square, 4); }
void GeomDrawBox::draw_geometry(cairo_t *cr, OGRGeometry *geom, double scale, double x, double y, double height) { switch (geom->getGeometryType()) { case wkbPolygon: draw_polygon(cr, dynamic_cast<OGRPolygon*>(geom), scale, x, y, height); break; case wkbMultiPolygon: { OGRGeometryCollection *geoCollection = dynamic_cast<OGRGeometryCollection*>(geom); for (int i = 0; i < geoCollection->getNumGeometries(); ++i) draw_geometry(cr, geoCollection->getGeometryRef(i), scale, x, y, height); } break; default: log_warning("Can't paint geometry type %s\n", geom->getGeometryName()); break; } }
void ColorRampEdit::_draw_checker(int x, int y, int w, int h) { //Draw it with polygon to insert UVs for scale Vector<Vector2> backPoints; backPoints.push_back(Vector2(x, y)); backPoints.push_back(Vector2(x, y+h)); backPoints.push_back(Vector2(x+w, y+h)); backPoints.push_back(Vector2(x+w, y)); Vector<Color> colorPoints; colorPoints.push_back(Color(1, 1, 1, 1)); colorPoints.push_back(Color(1, 1, 1, 1)); colorPoints.push_back(Color(1, 1, 1, 1)); colorPoints.push_back(Color(1, 1, 1, 1)); Vector<Vector2> uvPoints; //Draw checker pattern pixel-perfect and scale it by 2. uvPoints.push_back(Vector2(x, y)); uvPoints.push_back(Vector2(x, y+h*.5f/checker->get_height())); uvPoints.push_back(Vector2(x+w*.5f/checker->get_width(), y+h*.5f/checker->get_height())); uvPoints.push_back(Vector2(x+w*.5f/checker->get_width(), y)); draw_polygon(backPoints, colorPoints, uvPoints, checker); }
// ディスプレイに変化があった時に呼び出されるコールバック関数。 // 「ディスプレイに変化があった時」は、glutPostRedisplay() で指示する。 void glut_display(){ glClear(GL_COLOR_BUFFER_BIT); // 今まで画面に描かれていたものを消す switch(g_display_mode){ case 1: draw_square1(); break; case 2: draw_square2(); break; case 3: draw_square3(); break; case 4: draw_polygon(); break; } glFlush(); // ここで画面に描画をする }
void ClockDraw::draw_floating_tick(double angle) { Vertex tri[3]; Vertex* v = tri; const double xc = 28.5; const double yc = 28.5; v->x = xc + sin((angle)*M_PI/180) * 25; v->y = yc - cos((angle)*M_PI/180) * 25; v++; v->x = xc + sin((angle+10)*M_PI/180) * 20; v->y = yc - cos((angle+10)*M_PI/180) * 20; v++; v->x = xc + sin((angle-10)*M_PI/180) * 20; v->y = yc - cos((angle-10)*M_PI/180) * 20; draw_polygon(ras, tri, tri+3, Color(255, 255, 255)); }
int draw_circle(Vec pos, double radius) { // drawing algorithm from here: http://slabode.exofire.net/circle_draw.shtml static Vec verts[360]; static const size_t vertc = sizeof verts / sizeof (Vec); double theta = 2 * M_PI / vertc; double costh = cos(theta); double sinth = sin(theta); double t; double x = radius; double y = 0; for(int i = 0; i < vertc; i++) { verts[i].x = x + pos.x; verts[i].y = y + pos.y; t = x; x = costh * x - sinth * y; y = sinth * t + costh * y; } return draw_polygon(verts, vertc); }
static void fill_polygon(DiaRenderer *self, Point *points, int num_points, Color *colour) { WmfRenderer *renderer = WMF_RENDERER (self); W32::HBRUSH hBrush, hBrOld; W32::COLORREF rgb = W32COLOR(colour); DIAG_NOTE(renderer, "fill_polygon n:%d %f,%f ...\n", num_points, points->x, points->y); hBrush = W32::CreateSolidBrush(rgb); hBrOld = (W32::HBRUSH)W32::SelectObject(renderer->hFileDC, hBrush); draw_polygon(self, points, num_points, NULL); W32::SelectObject(renderer->hFileDC, W32::GetStockObject(HOLLOW_BRUSH) ); W32::DeleteObject(hBrush); }
static void QuadTree_print_internal(FILE *fp, QuadTree q, int level){ /* dump a quad tree in Mathematica format. */ SingleLinkedList l, l0; real *coord; int i, dim; if (!q) return; draw_polygon(fp, q->dim, q->center, q->width); dim = q->dim; l0 = l = q->l; if (l){ printf(",(*a*) {Red,"); while (l){ if (l != l0) printf(","); coord = node_data_get_coord(SingleLinkedList_get_data(l)); fprintf(fp, "(*node %d*) Point[{", node_data_get_id(SingleLinkedList_get_data(l))); for (i = 0; i < dim; i++){ if (i != 0) printf(","); fprintf(fp, "%f",coord[i]); } fprintf(fp, "}]"); l = SingleLinkedList_get_next(l); } fprintf(fp, "}"); } if (q->qts){ for (i = 0; i < 1<<dim; i++){ fprintf(fp, ",(*b*){"); QuadTree_print_internal(fp, q->qts[i], level + 1); fprintf(fp, "}"); } } }
static void render(struct widget *w) { struct widget_priv *priv = w->priv; struct canvas *ca = &w->ca; char buf[10]; unsigned long d = (unsigned long) priv->home->distance; unsigned int r = (w->ca.width/2)-2; int x, y; int min_increment; long i, scale; struct point ils_points[5] = { {-4, -6}, {-4, 6}, {0, 10}, {4, 6}, {4, -6} }; struct polygon ils = { .len = 5, .points = ils_points, }; struct point uav_points[4] = { {0, 0}, {6, 8}, {0, -8}, {-6, 8} }; struct polygon uav = { .len = 4, .points = uav_points, }; struct polygon *p; x = (w->ca.width/2)-1; y = (w->ca.height/2)-1; draw_vline(x, 0, r*2, 2, ca); draw_hline(0, r*2, y, 2, ca); //draw_circle(x, y, r+1, 3, ca); draw_circle(x, y, r , 2, ca); /* auto scale */ switch (get_units(w->cfg)) { default: case UNITS_METRIC: min_increment = 500; scale = ((d / min_increment) + 1) * min_increment; sprintf(buf, "%um", (unsigned int) scale); break; case UNITS_IMPERIAL: d *= M2FEET; min_increment = 1000; scale = ((d / min_increment) + 1) * min_increment; if (d > 5000) { d = (d * 1000) / MILE2FEET; scale /= 1000; sprintf(buf, "%umi", (unsigned int) scale); } else { sprintf(buf, "%uf", (unsigned int) scale); } break; } draw_str(buf, 0, 0, ca, 0); i = (long) d * r; i /= scale; switch (w->cfg->props.mode >> 1) { case 0: default: /* radar fixed at uav heading, home moves */ x += sin(DEG2RAD(priv->home->direction)) * i; y -= cos(DEG2RAD(priv->home->direction)) * i; transform_polygon(&ils, x, y, priv->stats->launch_heading - priv->heading - 180); p = &ils; break; case 1: /* radar always facing north, uav moves */ x += sin(DEG2RAD(priv->home->uav_bearing)) * i; y -= cos(DEG2RAD(priv->home->uav_bearing)) * i; transform_polygon(&uav, x, y, priv->heading); p = &uav; break; case 2: /* radar always facing launch direction, uav moves */ x += sin(DEG2RAD(priv->home->uav_bearing - priv->stats->launch_heading)) * i; y -= cos(DEG2RAD(priv->home->uav_bearing - priv->stats->launch_heading)) * i; transform_polygon(&uav, x, y, priv->heading - priv->stats->launch_heading); p = &uav; break; case 3: /* testing waypoints */ /* radar always facing north, uav moves with waypoints */ if (priv->wp_seq > 0) { long i_wp = (long) priv->wp_distance * r; i_wp /= scale; int x_wp = x, y_wp = y; x_wp += sin(DEG2RAD(priv->wp_target_bearing - priv->heading)) * i_wp; y_wp -= cos(DEG2RAD(priv->wp_target_bearing - priv->heading)) * i_wp; sprintf(buf, "%d", priv->wp_seq); draw_str(buf, x_wp, y_wp, ca, 0); } x += sin(DEG2RAD(priv->home->uav_bearing)) * i; y -= cos(DEG2RAD(priv->home->uav_bearing)) * i; transform_polygon(&uav, x, y, priv->heading); p = &uav; break; } draw_polygon(p, 3, ca); move_polygon(p, -1, -1); draw_polygon(p, 1, ca); } const struct widget_ops radar_widget_ops = { .name = "Radar", .mavname = "RADAR", .id = WIDGET_RADAR_ID, .init = NULL, .open = open, .render = render, .close = NULL, };
static void game_redraw(drawing *dr, game_drawstate *ds, const game_state *oldstate, const game_state *state, int dir, const game_ui *ui, float animtime, float flashtime) { int i, j; struct bbox bb = find_bbox(&state->params); struct solid *poly; const int *pkey, *gkey; float t[3]; float angle; int square; draw_rect(dr, 0, 0, XSIZE(GRID_SCALE, bb, state->solid), YSIZE(GRID_SCALE, bb, state->solid), COL_BACKGROUND); if (dir < 0) { const game_state *t; /* * This is an Undo. So reverse the order of the states, and * run the roll timer backwards. */ assert(oldstate); t = oldstate; oldstate = state; state = t; animtime = ROLLTIME - animtime; } if (!oldstate) { oldstate = state; angle = 0.0; square = state->current; pkey = state->dpkey; gkey = state->dgkey; } else { angle = state->angle * animtime / ROLLTIME; square = state->previous; pkey = state->spkey; gkey = state->sgkey; } state = oldstate; for (i = 0; i < state->grid->nsquares; i++) { int coords[8]; for (j = 0; j < state->grid->squares[i].npoints; j++) { coords[2*j] = ((int)(state->grid->squares[i].points[2*j] * GRID_SCALE) + ds->ox); coords[2*j+1] = ((int)(state->grid->squares[i].points[2*j+1]*GRID_SCALE) + ds->oy); } draw_polygon(dr, coords, state->grid->squares[i].npoints, GET_SQUARE(state, i) ? COL_BLUE : COL_BACKGROUND, COL_BORDER); } /* * Now compute and draw the polyhedron. */ poly = transform_poly(state->solid, state->grid->squares[square].flip, pkey[0], pkey[1], angle); /* * Compute the translation required to align the two key points * on the polyhedron with the same key points on the current * face. */ for (i = 0; i < 3; i++) { float tc = 0.0; for (j = 0; j < 2; j++) { float grid_coord; if (i < 2) { grid_coord = state->grid->squares[square].points[gkey[j]*2+i]; } else { grid_coord = 0.0; } tc += (grid_coord - poly->vertices[pkey[j]*3+i]); } t[i] = tc / 2; } for (i = 0; i < poly->nvertices; i++) for (j = 0; j < 3; j++) poly->vertices[i*3+j] += t[j]; /* * Now actually draw each face. */ for (i = 0; i < poly->nfaces; i++) { float points[8]; int coords[8]; for (j = 0; j < poly->order; j++) { int f = poly->faces[i*poly->order + j]; points[j*2] = (poly->vertices[f*3+0] - poly->vertices[f*3+2] * poly->shear); points[j*2+1] = (poly->vertices[f*3+1] - poly->vertices[f*3+2] * poly->shear); } for (j = 0; j < poly->order; j++) { coords[j*2] = (int)floor(points[j*2] * GRID_SCALE) + ds->ox; coords[j*2+1] = (int)floor(points[j*2+1] * GRID_SCALE) + ds->oy; } /* * Find out whether these points are in a clockwise or * anticlockwise arrangement. If the latter, discard the * face because it's facing away from the viewer. * * This would involve fiddly winding-number stuff for a * general polygon, but for the simple parallelograms we'll * be seeing here, all we have to do is check whether the * corners turn right or left. So we'll take the vector * from point 0 to point 1, turn it right 90 degrees, * and check the sign of the dot product with that and the * next vector (point 1 to point 2). */ { float v1x = points[2]-points[0]; float v1y = points[3]-points[1]; float v2x = points[4]-points[2]; float v2y = points[5]-points[3]; float dp = v1x * v2y - v1y * v2x; if (dp <= 0) continue; } draw_polygon(dr, coords, poly->order, state->facecolours[i] ? COL_BLUE : COL_BACKGROUND, COL_BORDER); } sfree(poly); draw_update(dr, 0, 0, XSIZE(GRID_SCALE, bb, state->solid), YSIZE(GRID_SCALE, bb, state->solid)); /* * Update the status bar. */ { char statusbuf[256]; if (state->completed) { strcpy(statusbuf, _("COMPLETED!")); strcpy(statusbuf+strlen(statusbuf), " "); } else statusbuf[0] = '\0'; sprintf(statusbuf+strlen(statusbuf), _("Moves: %d"), (state->completed ? state->completed : state->movecount)); status_bar(dr, statusbuf); } }
void SoftwareRendererImp::draw_element( SVGElement* element ) { // Task 4 (part 1): // Modify this to implement the transformation stack //std::cout << element->transform << endl; //transform svg elements switch(element->type) { case POINT: { transformation = transformation * (element->transform); draw_point(static_cast<Point&>(*element)); transformation = transformation * (element->transform.inv()); break; } case LINE: { transformation = transformation * (element->transform); draw_line(static_cast<Line&>(*element)); transformation = transformation * (element->transform.inv()); break; } case POLYLINE: { transformation = transformation * (element->transform); draw_polyline(static_cast<Polyline&>(*element)); transformation = transformation * (element->transform.inv()); break; } case RECT: { transformation = transformation * (element->transform); draw_rect(static_cast<Rect&>(*element)); transformation = transformation * (element->transform.inv()); break; } case POLYGON: { transformation = transformation * (element->transform); draw_polygon(static_cast<Polygon&>(*element)); transformation = transformation * (element->transform.inv()); break; } case ELLIPSE: { transformation = transformation * (element->transform); draw_ellipse(static_cast<Ellipse&>(*element)); transformation = transformation * (element->transform.inv()); break; } case IMAGE: { transformation = transformation * (element->transform); draw_image(static_cast<Image&>(*element)); transformation = transformation * (element->transform.inv()); break; } case GROUP: { transformation = transformation * (element->transform); draw_group(static_cast<Group&>(*element)); transformation = transformation * (element->transform.inv()); break; } default: break; } }
// Parse the next command. BOOL WMFUpdateState::parse_next_command(BOOL *primitive) { BOOL fPrimitive = FALSE; // Remember the start of the record. ST_DEV_POSITION lRecordOffset; file.tell(&lRecordOffset); // Read the next record. METARECORD Record; if ((error = file.read(&Record, sizeof(Record)-sizeof(Record.rdParm))) != ERRORCODE_None) { return FALSE; } // TRACE("Record %d function: %04x, size: %08lx\n", m_nRecord, Record.rdFunction, Record.rdSize); // Process the record. switch (Record.rdFunction) { case 0: { // End of records. All done. return FALSE; } case META_ESCAPE: { // short n; // file.read(&n, sizeof(n)); // TRACE("Escape: %x\n", n); break; } case META_SETROP2: case META_SETRELABS: case META_SETMAPMODE: { // TRACE("IGNORED Record %d function: %04x, size: %08lx\n", m_nRecord, Record.rdFunction, Record.rdSize); break; } case META_SETTEXTALIGN: { short nAlign; file.read(&nAlign, sizeof(nAlign)); SetTextAlign(nAlign); break; } case META_SETBKCOLOR: { COLORREF Color; file.read(&Color, sizeof(Color)); SetBkColor(Color); break; } case META_SETBKMODE: { short nMode; file.read(&nMode, sizeof(nMode)); SetBkMode(nMode); break; } case META_SETTEXTCOLOR: { COLORREF Color; file.read(&Color, sizeof(Color)); SetTextColor(Color); break; } case META_SETWINDOWORG: { // Read the parameter. short Parms[2]; ASSERT(Record.rdSize == 5); file.read(Parms, sizeof(Parms)); m_DCState.m_cpWindowOrg.y = Parms[0]; m_DCState.m_cpWindowOrg.x = Parms[1]; NewSourceVars(); break; } case META_SETWINDOWEXT: { // Read the parameter. short Parms[2]; ASSERT(Record.rdSize == 5); file.read(Parms, sizeof(Parms)); m_DCState.m_cpWindowExt.y = Parms[0]; m_DCState.m_cpWindowExt.x = Parms[1]; NewSourceVars(); break; } case META_CREATEBRUSHINDIRECT: { CWMFBrushObject* pNewBrush = new CWMFBrushObject; file.read(&pNewBrush->m_LogBrush, sizeof(LOGBRUSH16)); NewObject(pNewBrush); break; } case META_DIBCREATEPATTERNBRUSH: { CWMFBrushObject* pNewBrush = new CWMFBrushObject; pNewBrush->m_LogBrush.lbStyle = BS_SOLID; pNewBrush->m_LogBrush.lbColor = RGB(128, 0, 0); NewObject(pNewBrush); break; } case META_CREATEPENINDIRECT: { CWMFPenObject* pNewPen = new CWMFPenObject; file.read(&pNewPen->m_LogPen, sizeof(LOGPEN16)); NewObject(pNewPen); // TRACE("New pen - s: %d; w: %d, %d; c: %08lx\n", // pNewPen->m_LogPen.lopnStyle, // pNewPen->m_LogPen.lopnWidth.x, // pNewPen->m_LogPen.lopnWidth.y, // pNewPen->m_LogPen.lopnColor); break; } case META_CREATEFONTINDIRECT: { CWMFFontObject* pNewFont = new CWMFFontObject; // Read the data. LOGFONT16 lf; file.read(&lf, sizeof(LOGFONT16)); // Translate it over. pNewFont->m_LogFont.lfHeight = lf.lfHeight; pNewFont->m_LogFont.lfWidth = lf.lfWidth; pNewFont->m_LogFont.lfEscapement = lf.lfEscapement; pNewFont->m_LogFont.lfOrientation = lf.lfOrientation; pNewFont->m_LogFont.lfWeight = lf.lfWeight; // Warning: hard-coded size ahead. memcpy(&pNewFont->m_LogFont.lfItalic, &lf.lfItalic, 8 + LF_FACESIZE); NewObject(pNewFont); break; } case META_CREATEPALETTE: { // This is mostly here to make sure the object array stays in sync. CWMFPaletteObject* pNewPalette = new CWMFPaletteObject; struct { WORD palVersion; WORD palNumEntries; } Header; file.read(&Header, sizeof(Header)); // Now we have the header. See how many entries we want. if (Header.palVersion == 0x0300) { int nPaletteSize = sizeof(PALETTEENTRY)*Header.palNumEntries; pNewPalette->m_pPalette = (LOGPALETTE*)new BYTE[sizeof(LOGPALETTE) + nPaletteSize - sizeof(PALETTEENTRY)]; pNewPalette->m_pPalette->palVersion = Header.palVersion; pNewPalette->m_pPalette->palNumEntries = Header.palNumEntries; file.read(pNewPalette->m_pPalette->palPalEntry, nPaletteSize); } NewObject(pNewPalette); break; } case META_CREATEREGION: { // This is mostly here to make sure the object array stays in sync. // I don't think there's hope of determining the parms format for // this record. CWMFRegionObject* pNewRegion = new CWMFRegionObject; NewObject(pNewRegion); break; } case META_SELECTPALETTE: case META_SELECTOBJECT: { short nIndex; file.read(&nIndex, sizeof(nIndex)); SelectObject(nIndex); // TRACE("SelectObject: %d\n", nIndex); break; } case META_DELETEOBJECT: { short nIndex; file.read(&nIndex, sizeof(nIndex)); DeleteObject(nIndex); // TRACE("DeleteObject: %d\n", nIndex); break; } case META_SETPOLYFILLMODE: { short nFillMode; file.read(&nFillMode, sizeof(nFillMode)); m_nFillMode = nFillMode; break; } case META_SETSTRETCHBLTMODE: { short nMode; file.read(&nMode, sizeof(nMode)); SetBltMode(nMode); break; } case META_POLYPOLYGON: { // Read the number of polygons. short nPolygons; file.read(&nPolygons, sizeof(nPolygons)); // Proceed to read counts and points (and draw). int* pCounts = NULL; POINT* pPoints = NULL; TRY { // Allocate the polygon counts. pCounts = new int[nPolygons]; // Read the polygon counts. int nPoints = 0; for (int nPolygon = 0; nPolygon < nPolygons; nPolygon++) { short p; file.read(&p, sizeof(p)); pCounts[nPolygon] = p; nPoints += p; } // Allocate the polygon points. pPoints = new POINT[nPoints]; // Read the polygon points. for (int nPoint = 0; nPoint < nPoints; nPoint++) { short p[2]; file.read(p, sizeof(p)); pPoints[nPoint].x = p[0]; pPoints[nPoint].y = p[1]; } // Draw the polypolygon. DrawPolyPolygon(pPoints, pCounts, nPolygons); } END_TRY delete [] pPoints; delete [] pCounts; fPrimitive = TRUE; break; } case META_POLYGON: { WORD wCount; file.read(&wCount, sizeof(wCount)); draw_polygon(wCount); fPrimitive = TRUE; break; } case META_POLYLINE: { WORD wCount; file.read(&wCount, sizeof(wCount)); draw_polyline(wCount, TRUE); fPrimitive = TRUE; break; } case META_ELLIPSE: { short Parms[4]; file.read(Parms, sizeof(Parms)); // Compute parameters to pass. // Parms[3] = left // Parms[2] = top // Parms[1] = right // Parms[0] = bottom OUTLINE_POINT center; center.x = (short)((int)Parms[3] + (int)Parms[1])/2; center.y = (short)((int)Parms[2] + (int)Parms[0])/2; short rx = Parms[3] - center.x; if (rx < 0) rx = -rx; short ry = Parms[2] - center.y; if (ry < 0) ry = -ry; draw_ellipse(center, rx, ry); fPrimitive = TRUE; break; } case META_ROUNDRECT: { // Cheat for now. Just draw it as a rectangle. // Skip the corner radii. file.seek(2*sizeof(short), ST_DEV_SEEK_CUR); // Fall through to... } case META_RECTANGLE: { short Parms[4]; file.read(Parms, sizeof(Parms)); // Parms[3] = left // Parms[2] = top // Parms[1] = right // Parms[0] = bottom OUTLINE_POINT p0, p1; p0.x = Parms[3]; p0.y = Parms[2]; p1.x = Parms[1]; p1.y = Parms[0]; draw_rectangle(p0, p1); fPrimitive = TRUE; break; } case META_DIBSTRETCHBLT: { // Read the numeric parameters. short Parms[10]; file.read(Parms, sizeof(Parms)); // Parms[0] = low-order word of raster op // Parms[1] = high-order word of raster op // Parms[2] = source y extent // Parms[3] = source x extent // Parms[4] = source y coordinate // Parms[5] = source x coordinate // Parms[6] = destination y extent // Parms[7] = destination x extent // Parms[8] = destination y coordinate // Parms[9] = destination x coordinate CRect crSource(CPoint(Parms[5], Parms[4]), CSize(Parms[3], Parms[2])); CRect crDest(CPoint(Parms[9], Parms[8]), CSize(Parms[7], Parms[6])); DWORD dwROP = MAKELONG(Parms[0], Parms[1]); // Process the rest of the dib blt. DoDibBlt(crSource, crDest, dwROP); fPrimitive = TRUE; break; } case META_DIBBITBLT: { // Read the numeric parameters. short Parms[7]; file.read(Parms, sizeof(Parms)); // Parms[0] = high-order word of raster op // Parms[1] = source y coordinate // Parms[2] = source x coordinate // Parms[3] = destination y extent // Parms[4] = destination x extent // Parms[5] = destination y coordinate // Parms[6] = destination x coordinate CRect crSource(CPoint(Parms[5], Parms[4]), CSize(Parms[7], Parms[6])); CRect crDest(CPoint(Parms[9], Parms[8]), CSize(Parms[7], Parms[6])); DWORD dwROP = MAKELONG(0, Parms[1]); // Process the rest of the dib blt. DoDibBlt(crSource, crDest, dwROP); fPrimitive = TRUE; break; } case META_STRETCHDIB: { // Read the numeric parameters. short Parms[11]; file.read(Parms, sizeof(Parms)); // Parms[0] = low-order word of raster op // Parms[1] = high-order word of raster op // Parms[2] = usage flag // Parms[3] = source y extent // Parms[4] = source x extent // Parms[5] = source y coordinate // Parms[6] = source x coordinate // Parms[7] = destination y extent // Parms[8] = destination x extent // Parms[9] = destination y coordinate // Parms[10] = destination x coordinate CRect crSource(CPoint(Parms[6], Parms[5]), CSize(Parms[4], Parms[3])); CRect crDest(CPoint(Parms[10], Parms[9]), CSize(Parms[8], Parms[7])); DWORD dwROP = MAKELONG(Parms[0], Parms[1]); WORD wUsage = (WORD)Parms[2]; // Process the rest of the dib blt. DoDibBlt(crSource, crDest, dwROP, wUsage); fPrimitive = TRUE; break; } case META_EXTTEXTOUT: { // Handle ExtTextOut call. // Read the numeric parameters. short Parms[4]; file.read(Parms, sizeof(Parms)); // Parms[0] = y // Parms[1] = x // Parms[2] = string length // Parms[3] = option flags RECTS rClip; if (Parms[3] != 0) { file.read(&rClip, sizeof(rClip)); } // String data follows int nStrLength = Parms[2]; int nStrSize = (nStrLength + 1) & ~1; LPBYTE pString = NULL; TRY { // Read the text. pString = new BYTE[nStrSize]; file.huge_read(pString, nStrSize); // See if there are any widths. ST_DEV_POSITION Here; file.tell(&Here); ST_DEV_POSITION lRecordEnd = lRecordOffset + Record.rdSize*sizeof(WORD); // TRACE("Count:%d; Here: %ld; lRecordEnd: %ld\n", // nStrLength, Here, lRecordEnd); int nDXSize = nStrLength*sizeof(short); short* pDX = NULL; if (lRecordEnd >= Here + nDXSize) { pDX = new short[nStrLength]; file.read(pDX, nDXSize); } OUTLINE_POINT p; p.x = (short)Parms[1]; p.y = (short)Parms[0]; RECT r; r.left = rClip.left; r.top = rClip.top; r.right = rClip.right; r.bottom = rClip.bottom; // Draw the text. DrawText(p, Parms[3], (LPCSTR)pString, nStrLength, &r, pDX); // Free the dx array. delete [] pDX; // Free the text. delete pString; } END_TRY fPrimitive = TRUE; break; } case META_TEXTOUT: { // Handle TextOut call. // Read the string size. short nStrLength; file.read(&nStrLength, sizeof(nStrLength)); int nStrSize = (nStrLength + 1) & ~1; LPBYTE pString = NULL; TRY { // Read the text. pString = new BYTE[nStrSize]; file.huge_read(pString, nStrSize); // Read the x and y. short Parms[2]; file.read(Parms, sizeof(Parms)); OUTLINE_POINT p; p.x = (short)Parms[1]; p.y = (short)Parms[0]; // Draw the text. DrawText(p, 0, (LPCSTR)pString, nStrLength, NULL); // Free the text. delete pString; } END_TRY fPrimitive = TRUE; break; } case META_MOVETO: case META_LINETO: { short Parms[2]; file.read(&Parms, sizeof(Parms)); // TRACE("%s: %d, %d\n", Record.rdFunction == META_MOVETO ? "MoveTo" : "LineTo", Parms[1], Parms[0]); OUTLINE_POINT p; p.x = Parms[1]; p.y = Parms[0]; if (Record.rdFunction == META_MOVETO) { // Move to. MoveTo(p); } else { // Must be Line to. LineTo(p); fPrimitive = TRUE; } break; } case META_PATBLT: { WORD Parms[6]; // Parms[0] - op low word // Parms[1] - op high word // Parms[2] - height // Parms[3] - width // Parms[4] - top // Parms[5] - left file.read(Parms, sizeof(Parms)); OUTLINE_POINT p0, p1; p0.x = Parms[5]; p0.y = Parms[4]; p1.x = p0.x + Parms[3]; p1.y = p0.y + Parms[2]; DoPatBlt(p0, p1, MAKELONG(Parms[0], Parms[1])); fPrimitive = TRUE; break; } case META_PIE: case META_ARC: { short Parms[8]; // Parms[0] = y4 end pt y // Parms[1] = x4 end pt x // Parms[2] = y3 start pt y // Parms[3] = x3 start pt x // Parms[4] = y2 Bound bottom // Parms[5] = x2 Bound right // Parms[6] = y1 Bound top // Parms[7] = x1 Bound left file.read(Parms, sizeof(Parms)); OUTLINE_POINT Center; Center.x = (short)midpoint(Parms[7], Parms[5]); Center.y = (short)midpoint(Parms[6], Parms[4]); double rx = Parms[5] - Center.x; if (rx < 0) rx = -rx; double ry = Parms[4] - Center.y; if (ry < 0) ry = -ry; double dStart = angle_from_vector(Parms[2] - Center.y, Parms[3] - Center.x); double dEnd = angle_from_vector(Parms[0] - Center.y, Parms[1] - Center.x); draw_elliptical_arc(Center, rx, ry, dStart-PI/2, dEnd-PI/2, (Record.rdFunction == META_PIE) ? 1 : -1); break; } case META_SAVEDC: { PushState(); break; } case META_RESTOREDC: { PopState(); break; } case META_SCALEVIEWPORTEXT: { // Read the parameter. short Parms[4]; // Parms[0] = ydenom // Parms[1] = ynum // Parms[2] = xdenom // Parms[3] = xnum file.read(Parms, sizeof(Parms)); m_DCState.m_cpViewportScaleNum.x = Parms[3]; m_DCState.m_cpViewportScaleDenom.x = Parms[2]; m_DCState.m_cpViewportScaleNum.y = Parms[1]; m_DCState.m_cpViewportScaleDenom.y = Parms[0]; NewSourceVars(); break; } default: { TRACE("UNKNOWN Record %d function: %04x, size: %08lx\n", m_nRecord, Record.rdFunction, Record.rdSize); break; } } m_nRecord++; // Seek past the record file.seek(lRecordOffset + Record.rdSize*sizeof(WORD), ST_DEV_SEEK_SET); *primitive = fPrimitive; return TRUE; }
static void draw_lines(struct graphics_priv *gr, struct graphics_gc_priv *gc, struct point *p, int count) { if ((gr->overlay_parent && !gr->overlay_parent->overlay_enable) || (gr->overlay_parent && gr->overlay_parent->overlay_enable && !gr->overlay_enable) ) { return; } /* you might expect lines to be simpler than the other shapes. but, that would be wrong. 1 line can generate 1 polygon + 2 circles and even worse, we have to calculate their parameters! go dust off your trigonometry hat. */ /* sort of based on graphics_opengl.c::draw_lines */ /* FIXME: should honor ./configure flag for no fp. this could be 100% integer code pretty easily, except that i am lazy */ struct point vert[4]; int lw = gc->linewidth; //int lw = 1; int i; for(i = 0; i < count-1; i++) { float dx=p[i+1].x-p[i].x; float dy=p[i+1].y-p[i].y; float angle; int x_lw_adj, y_lw_adj; if(lw == 1) { if(gr->aa) { raster_aaline(gr->screen, p[i].x, p[i].y, p[i+1].x, p[i+1].y, SDL_MapRGBA(gr->screen->format, gc->fore_r, gc->fore_g, gc->fore_b, gc->fore_a)); } else { raster_line(gr->screen, p[i].x, p[i].y, p[i+1].x, p[i+1].y, SDL_MapRGBA(gr->screen->format, gc->fore_r, gc->fore_g, gc->fore_b, gc->fore_a)); } } else { /* there is probably a much simpler way but this works ok */ /* FIXME: float + double mixture */ /* FIXME: lrint(round())? */ if(dy == 0.0) { angle = 0.0; x_lw_adj = 0; y_lw_adj = round((float)lw/2.0); } else if(dx == 0.0) { angle = 0.0; x_lw_adj = round((float)lw/2.0); y_lw_adj = 0; } else { angle = (M_PI/2.0) - atan(abs(dx)/abs(dy)); x_lw_adj = round(sin(angle)*(float)lw/2.0); y_lw_adj = round(cos(angle)*(float)lw/2.0); if((x_lw_adj < 0) || (y_lw_adj < 0)) { dbg(lvl_debug, "i=%d\n", i); dbg(lvl_debug, " %d,%d->%d,%d\n", p[i].x, p[i].y, p[i+1].x, p[i+1].y); dbg(lvl_debug, " lw=%d angle=%f\n", lw, 180.0 * angle / M_PI); dbg(lvl_debug, " x_lw_adj=%d y_lw_adj=%d\n", x_lw_adj, y_lw_adj); } } if(p[i+1].x > p[i].x) { x_lw_adj = -x_lw_adj; } if(p[i+1].y > p[i].y) { y_lw_adj = -y_lw_adj; } /* FIXME: draw a circle/square if p[i]==p[i+1]? */ /* FIXME: clipping, check for neg values. hoping sdl-gfx does this */ vert[0].x = p[i].x + x_lw_adj; vert[0].y = p[i].y - y_lw_adj; vert[1].x = p[i].x - x_lw_adj; vert[1].y = p[i].y + y_lw_adj; vert[2].x = p[i+1].x - x_lw_adj; vert[2].y = p[i+1].y + y_lw_adj; vert[3].x = p[i+1].x + x_lw_adj; vert[3].y = p[i+1].y - y_lw_adj; draw_polygon(gr, gc, vert, 4); /* draw small circles at the ends. this looks better than nothing, and slightly * better than the triangle used by graphics_opengl, but is more expensive. * should have an ifdef/xml attr? */ /* FIXME: should just draw a half circle */ /* now some circular endcaps, if the width is over 2 */ if(lw > 2) { if(i == 0) { draw_circle(gr, gc, &p[i], lw/2); } /* we truncate on the divide on purpose, so we don't go outside the line */ draw_circle(gr, gc, &p[i+1], lw/2); } } } }
void TextureProgress::_notification(int p_what) { const float corners[12] = { -0.125, -0.375, -0.625, -0.875, 0.125, 0.375, 0.625, 0.875, 1.125, 1.375, 1.625, 1.875 }; switch (p_what) { case NOTIFICATION_DRAW: { if (nine_patch_stretch && (mode == FILL_LEFT_TO_RIGHT || mode == FILL_RIGHT_TO_LEFT || mode == FILL_TOP_TO_BOTTOM || mode == FILL_BOTTOM_TO_TOP)) { if (under.is_valid()) { draw_nine_patch_stretched(under, FILL_LEFT_TO_RIGHT, 1.0, tint_under); } if (progress.is_valid()) { draw_nine_patch_stretched(progress, mode, get_as_ratio(), tint_progress); } if (over.is_valid()) { draw_nine_patch_stretched(over, FILL_LEFT_TO_RIGHT, 1.0, tint_over); } } else { if (under.is_valid()) draw_texture(under, Point2(), tint_under); if (progress.is_valid()) { Size2 s = progress->get_size(); switch (mode) { case FILL_LEFT_TO_RIGHT: { Rect2 region = Rect2(Point2(), Size2(s.x * get_as_ratio(), s.y)); draw_texture_rect_region(progress, region, region, tint_progress); } break; case FILL_RIGHT_TO_LEFT: { Rect2 region = Rect2(Point2(s.x - s.x * get_as_ratio(), 0), Size2(s.x * get_as_ratio(), s.y)); draw_texture_rect_region(progress, region, region, tint_progress); } break; case FILL_TOP_TO_BOTTOM: { Rect2 region = Rect2(Point2(), Size2(s.x, s.y * get_as_ratio())); draw_texture_rect_region(progress, region, region, tint_progress); } break; case FILL_BOTTOM_TO_TOP: { Rect2 region = Rect2(Point2(0, s.y - s.y * get_as_ratio()), Size2(s.x, s.y * get_as_ratio())); draw_texture_rect_region(progress, region, region, tint_progress); } break; case FILL_CLOCKWISE: case FILL_COUNTER_CLOCKWISE: case FILL_CLOCKWISE_AND_COUNTER_CLOCKWISE: { float val = get_as_ratio() * rad_max_degrees / 360; if (val == 1) { Rect2 region = Rect2(Point2(), s); draw_texture_rect_region(progress, region, region, tint_progress); } else if (val != 0) { Array pts; float direction = mode == FILL_COUNTER_CLOCKWISE ? -1 : 1; float start; if (mode == FILL_CLOCKWISE_AND_COUNTER_CLOCKWISE) { start = rad_init_angle / 360 - val / 2; } else { start = rad_init_angle / 360; } float end = start + direction * val; pts.append(start); pts.append(end); float from = MIN(start, end); float to = MAX(start, end); for (int i = 0; i < 12; i++) if (corners[i] > from && corners[i] < to) pts.append(corners[i]); pts.sort(); Vector<Point2> uvs; Vector<Point2> points; uvs.push_back(get_relative_center()); points.push_back(Point2(s.x * get_relative_center().x, s.y * get_relative_center().y)); for (int i = 0; i < pts.size(); i++) { Point2 uv = unit_val_to_uv(pts[i]); if (uvs.find(uv) >= 0) continue; uvs.push_back(uv); points.push_back(Point2(uv.x * s.x, uv.y * s.y)); } Vector<Color> colors; colors.push_back(tint_progress); draw_polygon(points, colors, uvs, progress); } if (Engine::get_singleton()->is_editor_hint()) { Point2 p = progress->get_size(); p.x *= get_relative_center().x; p.y *= get_relative_center().y; p = p.floor(); draw_line(p - Point2(8, 0), p + Point2(8, 0), Color(0.9, 0.5, 0.5), 2); draw_line(p - Point2(0, 8), p + Point2(0, 8), Color(0.9, 0.5, 0.5), 2); } } break; case FILL_BILINEAR_LEFT_AND_RIGHT: { Rect2 region = Rect2(Point2(s.x / 2 - s.x * get_as_ratio() / 2, 0), Size2(s.x * get_as_ratio(), s.y)); draw_texture_rect_region(progress, region, region, tint_progress); } break; case FILL_BILINEAR_TOP_AND_BOTTOM: { Rect2 region = Rect2(Point2(0, s.y / 2 - s.y * get_as_ratio() / 2), Size2(s.x, s.y * get_as_ratio())); draw_texture_rect_region(progress, region, region, tint_progress); } break; default: draw_texture_rect_region(progress, Rect2(Point2(), Size2(s.x * get_as_ratio(), s.y)), Rect2(Point2(), Size2(s.x * get_as_ratio(), s.y)), tint_progress); } } if (over.is_valid()) draw_texture(over, Point2(), tint_over); } } break; } }
int main() { // 8位3通道图像 image = cvCreateImage( cvSize( IMG_WIDTH, IMG_HEIGHT ), IPL_DEPTH_8U, 3 ); // 置零 cvZero(image); temp = cvCloneImage( image ); // 创建窗口并设置鼠标事件回调函数 cvNamedWindow("Drawing"); cvSetMouseCallback("Drawing", my_mouse_callback, (void*) image ); while(1) { cvCopyImage( image, temp ); switch(g_draw_mode) { // 画线模式 case MODE_LINE: if(drawing_line) draw_line( temp ); break; // 画圆模式 case MODE_CIRCLE: if(drawing_circle) draw_circle( temp ); break; // 画椭圆模式 case MODE_ELLIPSE: if(drawing_ellipse) draw_ellipse( temp ); break; // 画多边形模式 case MODE_POLYGON: if(drawing_polygon) draw_polygon( temp ); break; } cvShowImage("Drawing", temp); // Esc键退出 // 对于不同的按键,画不同的图形(线、圆、椭圆、多边形) int choose = cvWaitKey(15); switch(choose) { // l-108 L-76 case 76: case 108: printf("当前处于画线模式.\n"); g_draw_mode = MODE_LINE; break; // c-99 C-67 case 67: case 99: printf("当前处于画圆模式.\n"); g_draw_mode = MODE_CIRCLE; break; // e-101 E-69 case 69: case 101: printf("当前处于画椭圆模式.\n"); g_draw_mode = MODE_ELLIPSE; break; // p-112 P-80 case 80: case 112: printf("当前处于画多边形模式.\n"); g_draw_mode = MODE_POLYGON; break; // Esc 退出 case 27: goto end; } } end: // 释放资源 cvReleaseImage( &image ); cvReleaseImage( &temp ); cvDestroyAllWindows(); return 0; }