C++ draw_line函数代码示例

int BEE::draw_line(int x1, int y1, int x2, int y2, rgba_t color, bool is_hud) {
	return draw_line(x1, y1, x2, y2, get_enum_color(color), is_hud);
}

int main() {

  screen s;
  color c;
 
  
  c.red = 0;
  c.green = 0;
  c.blue = 0;
  
  clear_screen(s);

  int i, j;

  for (i=0; i < YRES; i++)
    for (j=0; j < XRES; j++ )
      plot(s, c, i, j);
  
  c.green = MAX_COLOR;
  c.blue = MAX_COLOR;
  c.red = MAX_COLOR;

  //too lazy to finish the 2 of hearts

  draw_line(90, 1, 410, 1, s, c);
  draw_line(90, 499, 410, 499, s, c);
  draw_line(90, 1, 90, 499, s, c);
  draw_line(410, 1, 410, 499, s, c);
  draw_line(110, 480, 140, 480, s, c);
  draw_line(140, 480, 140, 460, s, c);
  draw_line(140, 460, 110, 445, s, c);
  draw_line(110, 445, 110, 425, s, c);
  draw_line(110, 425, 140, 425, s, c);

  draw_line(360, 20, 390, 20, s, c);
  draw_line(360, 20, 360, 40, s, c);
  draw_line(360, 40, 390, 55, s, c);
  draw_line(390, 55, 390, 75, s, c);
  draw_line(360, 75, 390, 75, s, c);

  //Note: Display may not work on your system
  //save_ppm and save_extension should be fine
  display(s);
  save_ppm(s, "pic.ppm");
  save_extension(s, "whatevs.png");
}  

void draw_default_fixed_cockpit_clock_hands (cockpit_panels panel)
{
	float
		hour_hand_value,
		minute_hand_value,
		second_hand_value,
		x_centre,
		y_centre;

	scale_data
		*hour_hand_scale,
		*minute_hand_scale,
		*second_hand_scale,
		*p;

	if (draw_virtual_cockpit_needles_on_fixed_cockpits)
	{
		return;
	}

	get_clock_hand_values (&hour_hand_value, &minute_hand_value, &second_hand_value);

	switch (panel)
	{
		////////////////////////////////////////
		case COCKPIT_PANEL_DOWN20_AHEAD:
		////////////////////////////////////////
		{
			x_centre = 45.0;

			y_centre = 388.0;

			hour_hand_scale = clock_small_hand_scale_down_20_ahead;

			minute_hand_scale = clock_large_hand_scale_down_20_ahead;

			second_hand_scale = clock_large_hand_scale_down_20_ahead;

			break;
		}
		////////////////////////////////////////
		case COCKPIT_PANEL_DOWN20_LEFT30:
		////////////////////////////////////////
		{
			x_centre = 317.0;

			y_centre = 349.0;

			hour_hand_scale = clock_small_hand_scale_down_20_left_30;

			minute_hand_scale = clock_large_hand_scale_down_20_left_30;

			second_hand_scale = clock_large_hand_scale_down_20_left_30;

			break;
		}
		////////////////////////////////////////
		case COCKPIT_PANEL_DOWN20_LEFT60:
		////////////////////////////////////////
		{
			x_centre = 589.0;

			y_centre = 386.0;

			hour_hand_scale = clock_small_hand_scale_down_20_left_60;

			minute_hand_scale = clock_large_hand_scale_down_20_left_60;

			second_hand_scale = clock_large_hand_scale_down_20_left_60;

			break;
		}
		////////////////////////////////////////
		default:
		////////////////////////////////////////
		{
			debug_fatal (instrument_error);

			break;
		}
	}

	//
	// draw second hand over minute hand over hour hand
	//

	p = find_scale_value (hour_hand_scale, hour_hand_value);

	draw_line (fx_640_480 + x_centre, fy_640_480 + y_centre, fx_640_480 + p->x, fy_640_480 + p->y, white_needle_colour);

	p = find_scale_value (minute_hand_scale, minute_hand_value);

	draw_line (fx_640_480 + x_centre, fy_640_480 + y_centre, fx_640_480 + p->x, fy_640_480 + p->y, white_needle_colour);

	p = find_scale_value (second_hand_scale, second_hand_value);

	draw_line (fx_640_480 + x_centre, fy_640_480 + y_centre, fx_640_480 + p->x, fy_640_480 + p->y, red_needle_colour);

	if (test_cockpit_instruments && DEBUG_MODULE)
	{
//.........这里部分代码省略.........

/*Hough space

180x120 x-y space to -->

angle
180
| OOOOOOOOOOOOOOOOOOOOOO
| OOOOOOOOOOOOOOOOOOOOOO
| OOOOOOOOOOOOOOOOOOOOOO
| OOOOOOOOOOOOOOOOOOOOOO
--------(diag)--------(diag*2)----->

*/
void hough_lines(U16* buf, U16 threshold_value,
                double resolution, U16 num_line, S16* p_radius, U16* p_theta,d_YUV* d_pixel_value){
	int width = 180, height = 120, r, c, i, j, k;
	U16 diagH = (U16)(sqrt((double)(180*180 + 120*120)));
	U16 diag = diagH*2;
	U16 res_step = (U16)(180/resolution); // In resolution 1, each step has 1 degree.
	U16 num_trans = diag*res_step;
	U16 hough_space[num_trans];
	U16 theta;
	memset(hough_space, 0, num_trans*sizeof(U16));

	for(r = 5; r < height - 5; r++){
	for(c = 5; c < width - 5; c++){

		int distance;
		// At each edge pixels
		if(BLUE_VALUE_IN565(buf[180*r + c]) > threshold_value){
			//printf("selected pixel : y=%d, x=%d\n", r, c);
			for(theta = 0; theta < 180; theta += (U16)resolution){
				distance = (int)(c*mysin(theta) + r*mycos(theta) + diagH + 0.5);
				hough_space[distance*res_step + (U16)(theta/resolution)]++;
			}
		}

	}
	}

	int highest_voted_pixel[6] = {0, 0, 0, 0, 0, 0};
	int highest_voted_pixel_index[6] = {0, 0, 0, 0, 0, 0};

	for(i = 0; i < num_trans; i++){
		if(hough_space[i] >= highest_voted_pixel[0]){
			// push highest_voted_pixel, index array
			for(j = 5; (j >= 0) && (hough_space[i] >= highest_voted_pixel[j]); j--){
				for(k = 1; k < j + 1; k++){
					highest_voted_pixel[k-1] = highest_voted_pixel[k];
					highest_voted_pixel_index[k-1] = highest_voted_pixel_index[k];
				}
				highest_voted_pixel[j] = hough_space[i];
				highest_voted_pixel_index[j] = i;
				break;
			}
		}
	}

	for(i = 0; i < 6; i++){
		p_radius[i] = (S16)(highest_voted_pixel_index[i]/res_step);
		p_theta[i] = (highest_voted_pixel_index[i] - p_radius[i]*res_step)*resolution;
		p_radius[i] -= diagH;
		//printf("line detected. voted : %d, index : %d,  r : %d / theta : %d\n", highest_voted_pixel[i], highest_voted_pixel_index[i], p_radius[i], p_theta[i]);
		//printf("\n");
	}
	float d_Usum=0,d_Vsum=0;
	for(i = 0; i < 6; i++){
		draw_line(buf, p_radius[i], p_theta[i],d_pixel_value);
		printf("each direct%d U_value : %0.3f, V_value : %0.3f\n",i+1,d_pixel_value->u_value,d_pixel_value->v_value);
	}

	/*for(line_count = 0; line_count < num_line; line_count++){
		printf("line no. %d  p_r : %d / p_t : %d\n", line_count, p_radius[line_count], p_theta[line_count]);
	}*/



}

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;
}

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 (under.is_valid())
				draw_texture(under,Point2());
			if (progress.is_valid()) {
				Size2 s = progress->get_size();
				switch (mode) {
				case FILL_LEFT_TO_RIGHT: {
					Rect2 region=Rect2(Point2(),Size2(s.x*get_unit_value(),s.y));
					draw_texture_rect_region(progress,region,region);
				} break;
				case FILL_RIGHT_TO_LEFT: {
					Rect2 region=Rect2(Point2(s.x-s.x*get_unit_value(),0),Size2(s.x*get_unit_value(),s.y));
					draw_texture_rect_region(progress,region,region);
				} break;
				case FILL_TOP_TO_BOTTOM: {
					Rect2 region=Rect2(Point2(),Size2(s.x,s.y*get_unit_value()));
					draw_texture_rect_region(progress,region,region);
				} break;
				case FILL_BOTTOM_TO_TOP: {
					Rect2 region=Rect2(Point2(0,s.y-s.y*get_unit_value()),Size2(s.x,s.y*get_unit_value()));
					draw_texture_rect_region(progress,region,region);
				} break;
				case FILL_CLOCKWISE:
				case FILL_COUNTER_CLOCKWISE: {
					float val=get_unit_value()*rad_max_degrees/360;
					if (val==1) {
						Rect2 region=Rect2(Point2(),s);
						draw_texture_rect_region(progress,region,region);
					} else if (val!=0) {
						Array pts;
						float direction=mode==FILL_CLOCKWISE?1:-1;
						float 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));
						}
						draw_polygon(points,Vector<Color>(),uvs,progress);
					}
					if (get_tree()->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;
				default:
					draw_texture_rect_region(progress,Rect2(Point2(),Size2(s.x*get_unit_value(),s.y)),Rect2(Point2(),Size2(s.x*get_unit_value(),s.y)));
				}

				
			}
			if (over.is_valid())
				draw_texture(over,Point2());

		} break;
	}
}

 void draw_line (const Vector2d& pos1, const Vector2d& pos2, Color color, int wide = 0)
 {
   draw_line (pos1.x, pos1.y, pos2.x, pos2.y, color, wide);
 }

    void rasterizer::draw_triangle(int x0, int y0, int x1, int y1, int x2, int y2,
                                   const color_rgba8& c0, const color_rgba8& c1, const color_rgba8& c2)
    {
        
        int w = surface_->get_width();
        int h = surface_->get_height();
        if ((x0 < 0 || x0 > w) &&
            (y0 < 0 || y0 > h) &&
            (x1 < 0 || x1 > w) &&
            (y1 < 0 || y1 > h) &&
            (x2 < 0 || x2 > w) &&
            (y2 < 0 || y2 > h)) {
            // out of screen space...
            return;
        }
		// 退化为直线的情况
		if (((x0 == x1) && (x1 == x2)) || ((y0 == y1) && (y1 == y2))) {
			draw_line(x0, y0, x1, y1, c0, c1);
			draw_line(x0, y0, x2, y2, c0, c2);
			draw_line(x2, y2, x1, y1, c2, c1);
			return;
		}

		// ensure y0 < y1 < y2
		color_rgba8 tc0 = c0, tc1 = c1, tc2 = c2;
		if (y1 < y0) {// ensure y0 < y1
			std::swap(x0, x1);
			std::swap(y0, y1);
			std::swap(tc0, tc1);
		}
		if (y2 < y0) {// ensure y0 < y2
			std::swap(x0, x2);
			std::swap(y0, y2);
			std::swap(tc0, tc2);
		}
		if (y2 < y1) {// ensure y1 < y2
			std::swap(x1, x2);
			std::swap(y1, y2);
			std::swap(tc1, tc2);
		}

		enum trinagle_type
		{
			general = 0,
			flat_top = 1,
			flat_botton = 2
		};
		trinagle_type tt = general;
		if (y0 == y1) {
			tt = flat_top;
			if (x1 < x0) {
				std::swap(x0, x1);
				std::swap(y0, y1);
				std::swap(tc0, tc1);
			}
		}
		else if (y1 == y2) {
			tt = flat_botton;
			if (x2 < x1) {
				std::swap(x1, x2);
				std::swap(y1, y2);
				std::swap(tc1, tc2);
			}
		} else {
			tt = general;
		}

		float dxdy_left = 0.f;
		float dxdy_right = 0.f;
		float x_left = 0.f, x_right = 0.f;
		int y_start = 0, y_end = 0;
		int x_start = 0, x_end = 0;
		color_rgba8 c_start, c_end;
		color_rgba8 dc_left, dc_right;
		if (tt == general) {
			y_end = y2;
			if (y_end > h) y_end = h;
			int side = 0;
			int ys = y1; //转折点
			float dy_left = 0.f, dy_right = 0.f;
			if (y1 < 0) { //退化为平顶三角形
				//左右边斜率倒数
				dy_left = 1.f / (y2 - y1);
				dxdy_left = (x2 - x1) * dy_left;
				dy_right = 1.f / (y2 - y0);
				dxdy_right = (x2 - x0) * dy_right;
				//左右斜边初始值
				dy_right = -y0;
				dy_left = -y1;
				x_left = dxdy_left * dy_left + x1;
				x_right = dxdy_right * dy_right + x0;
				y_start = 0;
				if (dxdy_right > dxdy_left) {//交换
					std::swap(dxdy_left, dxdy_right);
					std::swap(x_left, x_right);
					std::swap(x1, x2);
					std::swap(y1, y2);
					std::swap(tc1, tc2);
					side = 1;
				}
//.........这里部分代码省略.........

int main() {

  screen s;
  color c;
 
  
  c.red = 50;
  c.green = 200;
  c.blue = 54;
  
  clear_screen(s);

  int i, j;

  for (i=0; i < YRES; i++)
    for (j=0; j < XRES; j++ )
      plot(s, c, i, j);
  
  c.green = 0;
  c.red = 0;
  c.blue=0;
  //  draw_line(20, 350, 300, 350, s, c); //oct 6
 i = 0;
 for(i;i<100;i++){
    draw_line(i,0,i,500,s,c);
    c.red = c.red +1;
 }
 c.red=0;
 i = 100;
 for(i;i<200;i++){
    draw_line(i,0,i,500,s,c);
    c.red = c.red +1;
 }
c.red=0;
 i = 200;
 for(i;i<300;i++){
    draw_line(i,0,i,500,s,c);
    c.red = c.red +1;
 }
c.red=0;
 i = 300;
 for(i;i<400;i++){
    draw_line(i,0,i,500,s,c);
    c.red = c.red +1;
 }
c.red=0;
 i = 400;
 for(i;i<500;i++){
    draw_line(i,0,i,500,s,c);
    c.red = c.red +1;
 }

 c.red = 255;
 c.green = 255;
 c.blue = 0;

 i = 0;

 for(i;i<100;i++){
    draw_line(i,0,500,500,s,c);
    draw_line(0,i,500,500,s,c);
    draw_line(500-i,0,0,500,s,c);
    draw_line(500,i,0,500,s,c);
 }
 c.red = 0;
 c.green = 0;
    draw_line(0,100,500,500,s,c);
    draw_line(100,0,500,500,s,c);

//Note: Display may not work on your system
  //save_ppm and save_extension should be fine
  //display(s);
  save_ppm(s, "pic.ppm");
  save_extension(s, "whatevs.png");
}  

void
setup_screen(const C_SCREEN *scp)
{
	static char	buffer[BUFSIZ];
	int	i, j;
	char	str[3];
	const char *airstr;

	initscr();
	/* size of screen depends on chosen game, but we need at least 80
	 * columns for "Information area" to work. */
	if (LINES < (INPUT_LINES + scp->height) ||
	    COLS < (PLANE_COLS + 2 * scp->width) ||
	    COLS < 80) {
		endwin();
		errx(1, "screen too small.");
	}
	setvbuf(stdout, buffer, _IOFBF, sizeof buffer);
	input = newwin(INPUT_LINES, COLS - PLANE_COLS, LINES - INPUT_LINES, 0);
	credit = newwin(INPUT_LINES, PLANE_COLS, LINES - INPUT_LINES, 
		COLS - PLANE_COLS);
	planes = newwin(LINES - INPUT_LINES, PLANE_COLS, 0, COLS - PLANE_COLS);

	str[2] = '\0';

	if (radar != NULL)
		delwin(radar);
	radar = newwin(scp->height, scp->width * 2, 0, 0);

	if (cleanradar != NULL)
		delwin(cleanradar);
	cleanradar = newwin(scp->height, scp->width * 2, 0, 0);

	/* minus one here to prevent a scroll */
	for (i = 0; i < PLANE_COLS - 1; i++) {
		wmove(credit, 0, i);
		waddch(credit, C_CREDIT);
		wmove(credit, INPUT_LINES - 1, i);
		waddch(credit, C_CREDIT);
	}
	wmove(credit, INPUT_LINES / 2, 1);
	waddstr(credit, AUTHOR_STR);

	for (i = 1; i < scp->height - 1; i++) {
		for (j = 1; j < scp->width - 1; j++) {
			wmove(radar, i, j * 2);
			waddch(radar, C_BACKROUND);
		}
	}

	/*
	 * Draw the lines first, since people like to draw lines
	 * through beacons and exit points.
	 */
	str[0] = C_LINE;
	for (i = 0; i < scp->num_lines; i++) {
		str[1] = ' ';
		draw_line(radar, scp->line[i].p1.x, scp->line[i].p1.y,
			scp->line[i].p2.x, scp->line[i].p2.y, str);
	}

	str[0] = C_TOPBOTTOM;
	str[1] = C_TOPBOTTOM;
	wmove(radar, 0, 0);
	for (i = 0; i < scp->width - 1; i++)
		waddstr(radar, str);
	waddch(radar, C_TOPBOTTOM);

	str[0] = C_TOPBOTTOM;
	str[1] = C_TOPBOTTOM;
	wmove(radar, scp->height - 1, 0);
	for (i = 0; i < scp->width - 1; i++)
		waddstr(radar, str);
	waddch(radar, C_TOPBOTTOM);

	for (i = 1; i < scp->height - 1; i++) {
		wmove(radar, i, 0);
		waddch(radar, C_LEFTRIGHT);
		wmove(radar, i, (scp->width - 1) * 2);
		waddch(radar, C_LEFTRIGHT);
	}

	str[0] = C_BEACON;
	for (i = 0; i < scp->num_beacons; i++) {
		str[1] = '0' + i;
		wmove(radar, scp->beacon[i].y, scp->beacon[i].x * 2);
		waddstr(radar, str);
	}

	for (i = 0; i < scp->num_exits; i++) {
		wmove(radar, scp->exit[i].y, scp->exit[i].x * 2);
		waddch(radar, '0' + i);
	}

	airstr = "^?>?v?<?";
	for (i = 0; i < scp->num_airports; i++) {
		str[0] = airstr[scp->airport[i].dir];
		str[1] = '0' + i;
		wmove(radar, scp->airport[i].y, scp->airport[i].x * 2);
		waddstr(radar, str);
//.........这里部分代码省略.........

int wiki_trans_line( section_def *section, int alloc_size )
/*********************************************************/
{
    char                *ptr;
    char                *end;
    int                 ch;
    char                *ctx_name;
    char                *ctx_text;
    char                buf[500];
    int                 font_idx;
    int                 line_len;
    bool                term_fix;
    int                 ch_len;
    int                 len;
    char                *file_name;

    /* check for special column 0 stuff first */
    ptr = Line_buf;
    ch = *(unsigned char *)ptr;
    ch_len = 0;
    line_len = 0;

    switch( ch ) {

    case CH_TABXMP:
        if( *skip_blank( ptr + 1 ) == '\0' ) {
            Tab_xmp = FALSE;
            trans_add_str( "</pre>\n", section, &alloc_size );
            Blank_line_sfx = FALSE;     // remove following blanks
        } else {
            read_tabs( ptr + 1 );
            trans_add_str( "<pre>\n", section, &alloc_size );
            Tab_xmp = TRUE;
            Blank_line_pfx = FALSE;     // remove preceding blanks
        }
        return( alloc_size );

    case CH_BOX_ON:
        /* Table support is the closest thing to boxing in IPF, but it
           doesn't work well with changing fonts on items in the tables
           (the edges don't line up). So we draw long lines at the
           top and bottom instead */
        draw_line( section, &alloc_size );
        Blank_line_pfx = FALSE;
        return( alloc_size );

    case CH_BOX_OFF:
        draw_line( section, &alloc_size );
        Blank_line_sfx = FALSE;
        return( alloc_size );

    case CH_OLIST_START:
        trans_add_list( "# ", section, &alloc_size, ptr );
        Blank_line_pfx = FALSE;
        return( alloc_size );

    case CH_LIST_START:
        trans_add_list( "* ", section, &alloc_size, ptr );
        Blank_line_pfx = FALSE;
        return( alloc_size );

    case CH_DLIST_START:
        trans_add_str( "; ", section, &alloc_size );
        Blank_line_pfx = FALSE;
        return( alloc_size );

    case CH_SLIST_START:
        trans_add_list( "* ", section, &alloc_size, ptr );
        Blank_line_pfx = FALSE;
        return( alloc_size );

    case CH_SLIST_END:
        trans_add_str( "\n", section, &alloc_size );
        Blank_line_sfx = FALSE;
        return( alloc_size );

    case CH_OLIST_END:
        trans_add_str( "\n", section, &alloc_size );
        Blank_line_sfx = FALSE;
        return( alloc_size );

    case CH_LIST_END:
        trans_add_str( "\n", section, &alloc_size );
        Blank_line_sfx = FALSE;
        return( alloc_size );

    case CH_DLIST_END:
        trans_add_str( "\n", section, &alloc_size );
        Blank_line_sfx = FALSE;
        return( alloc_size );

    case CH_LIST_ITEM:
    case CH_DLIST_TERM:
        /* eat blank lines before list items and terms */
        Blank_line_pfx = FALSE;
        break;

    case CH_CTX_KW:
        ptr = whole_keyword_line( ptr );
        if( ptr == NULL ) {
//.........这里部分代码省略.........

void update_timer(int cycles_gone)
{
    static int collected = 0, vsync_collect = 0, div_collect = 0, redrawed = 0;
    #ifdef ENABLE_LINK
    static int serial_poll_collect = 0;
    #endif
    int hblank_start = 0;

    div_collect += cycles_gone;
    while (div_collect >= 64)
    {
        io_regs->div++;
        div_collect -= cycles_gone;
    }

    if (lcd_on)
    {
        vsync_collect += cycles_gone;

        io_regs->stat &= ~3;
        if (io_regs->ly >= 144)
            io_regs->stat |= 1;
        else
        {
            if (vsync_collect < 51)
                redrawed = 0;
            else if (vsync_collect < 71)
                io_regs->stat |= 2;
            else
            {
                io_regs->stat |= 3;
                if (!redrawed)
                {
                    draw_line(io_regs->ly);
                    redrawed = 1;
                }
            }
        }

        while (vsync_collect >= 114) // Eine Zeile wäre jetzt fertig
        {
            vsync_collect -= 114;

            #ifdef ENABLE_LINK
            if (!link_countdown && (++serial_poll_collect >= 10))
            {
                serial_poll_collect = 0;
                if (server != INVALID_CONN_VALUE)
                    tcp_server_poll(server);
                if (current_connection != INVALID_CONN_VALUE)
                    tcp_conn_poll(current_connection);
            }
            #endif

            hblank_start = 1;
            if (hdma_on)
                hdma_copy_16b();

            if (++io_regs->ly > 153)
                io_regs->ly = 0;
            if (io_regs->ly == 144)
            {
                io_regs->stat &= ~3;
                io_regs->stat |= 1;
                io_regs->int_flag |= INT_VBLANK;
            }

            if (io_regs->lyc == io_regs->ly)
            {
                io_regs->stat |= (1 << 2);
                if (io_regs->stat & (1 << 6))
                    io_regs->int_flag |= INT_LCDC_STAT;
            }
            else
                io_regs->stat &= ~(1 << 2);
        }

        if ((io_regs->stat & (1 << 5)) && ((io_regs->stat & 3) == 2))
            io_regs->int_flag |= INT_LCDC_STAT;
        else if ((io_regs->stat & (1 << 4)) && ((io_regs->stat & 3) == 1))
            io_regs->int_flag |= INT_LCDC_STAT;
        else if ((io_regs->stat & (1 << 3)) && hblank_start)
            io_regs->int_flag |= INT_LCDC_STAT;
    }

    #ifdef ENABLE_LINK
    if (link_countdown)
    {
        link_countdown -= cycles_gone;
        if (link_countdown <= 0)
            link_clock();
    }
    #endif

    if (!(io_regs->tac & (1 << 2)))
        return;

    collected += cycles_gone;
    while (collected >= collect_overflow[io_regs->tac & 3])
    {
//.........这里部分代码省略.........

void RayCast2D::_notification(int p_what) {

	switch(p_what) {

		case NOTIFICATION_ENTER_TREE: {

			if (enabled && !get_tree()->is_editor_hint())
				set_fixed_process(true);
			else
				set_fixed_process(false);

			if (get_parent()->cast_to<PhysicsBody2D>()) {
				if (exclude_parent_body)
					exclude.insert( get_parent()->cast_to<PhysicsBody2D>()->get_rid() );
				else
					exclude.erase( get_parent()->cast_to<PhysicsBody2D>()->get_rid() );
			}
		} break;
		case NOTIFICATION_EXIT_TREE: {

			if (enabled)
				set_fixed_process(false);

		} break;

		case NOTIFICATION_DRAW: {

			if (!get_tree()->is_editor_hint()  && !get_tree()->is_debugging_collisions_hint())
				break;
			Matrix32 xf;
			xf.rotate(cast_to.angle());
			xf.translate(Vector2(0,cast_to.length()));

			//Vector2 tip = Vector2(0,s->get_length());
			Color dcol=get_tree()->get_debug_collisions_color();//0.9,0.2,0.2,0.4);
			draw_line(Vector2(),cast_to,dcol,3);
			Vector<Vector2> pts;
			float tsize=4;
			pts.push_back(xf.xform(Vector2(0,tsize)));
			pts.push_back(xf.xform(Vector2(0.707*tsize,0)));
			pts.push_back(xf.xform(Vector2(-0.707*tsize,0)));
			Vector<Color> cols;
			for(int i=0;i<3;i++)
				cols.push_back(dcol);

			draw_primitive(pts,cols,Vector<Vector2>()); //small arrow

		} break;


		case NOTIFICATION_FIXED_PROCESS: {

			if (!enabled)
				break;



			Ref<World2D> w2d = get_world_2d();
			ERR_BREAK( w2d.is_null() );

			Physics2DDirectSpaceState *dss = Physics2DServer::get_singleton()->space_get_direct_state(w2d->get_space());
			ERR_BREAK( !dss );

			Matrix32 gt = get_global_transform();

			Vector2 to = cast_to;
			if (to==Vector2())
				to=Vector2(0,0.01);

			Physics2DDirectSpaceState::RayResult rr;

			if (dss->intersect_ray(gt.get_origin(),gt.xform(to),rr,exclude,layer_mask,type_mask)) {

				collided=true;
				against=rr.collider_id;
				collision_point=rr.position;
				collision_normal=rr.normal;
				against_shape=rr.shape;
			} else {
				collided=false;
			}



		} break;
	}
}

/*======== void draw_lines() ==========
Inputs:   struct matrix * points
         screen s
         color c 
Returns: 
Go through points 2 at a time and call draw_line to add that line
to the screen
====================*/
void draw_lines( struct matrix * points, screen s, color c) {
  int i;
  for (i = 0; i < points->lastcol - 1; i += 2) {
    draw_line(points->m[0][i], points->m[1][i], points->m[0][i+1], points->m[1][i+1], s, c);
  }
}

void draw_tri(FBDev *dev, int x1, int y1, int x2, int y2, int x3, int y3, uint32_t pixel) {
	draw_line(dev, x1, y1, x2, y2, pixel);
	draw_line(dev, x2, y2, x3, y3, pixel);
	draw_line(dev, x3, y3, x1, y1, pixel);
}