void parse_color(const std::wstring& text, COLORREF *color) { int r = 0; int g = 0; int b = 0; swscanf(text.c_str(), L"%d,%d,%d", &r, &g, &b); unsigned char rb = 0; unsigned char gb = 0; unsigned char bb = 0; if (check_color(r, &rb) && check_color(g, &gb) && check_color(b, &bb)) { *color = RGB(rb, gb, bb); } }
int add_color(char **format) { int len; if ((len = check_color("black", *format))) ft_putstr("\033[30m"); else if ((len = check_color("red", *format))) ft_putstr("\033[31m"); else if ((len = check_color("green", *format))) ft_putstr("\033[32m"); else if ((len = check_color("yellow", *format))) ft_putstr("\033[33m"); else if ((len = check_color("blue", *format))) ft_putstr("\033[34m"); else if ((len = check_color("magenta", *format))) ft_putstr("\033[35m"); else if ((len = check_color("cyan", *format))) ft_putstr("\033[36m"); else if ((len = check_color("eoc", *format))) ft_putstr("\033[0m"); else return (len = 0); (*format) += len; return (1); }
int main(int ac, char **av) { t_all all; if (ac >= 2) { all.mlx = mlx_init(); all.win_x = (ac >= 4 && check_arg(av[2])) ? ft_atoi(av[2]) : 500; all.win_y = (ac >= 4 && check_arg(av[3])) ? ft_atoi(av[3]) : 500; all.win = mlx_new_window(all.mlx, all.win_x, all.win_y, "FdF"); init_all(&all); if (ac == 5) check_color(av[4], &all); all.fd = open(av[1], O_RDONLY); if (all.fd == -1) exit(EXIT_FAILURE); parser(all.fd, &all); mlx_hook(all.win, 2, (1L << 0), key_hook_first, &all); draw_map_x(&all); mlx_loop(all.mlx); } else help_main(); return (0); }
void parsing_light(int fd, t_env *rt) { char *line; char **tab; int tmp; tmp = 0; while (get_next_line(fd, &line) > 0 && line[0] != '\0') { tab = split_tab(line); if (!ft_strcmp(tab[0], "pos")) rt->light[rt->i_light].center = new_vector(ft_atof(tab[2]), ft_atof(tab[3]), ft_atof(tab[4])); else if (!ft_strcmp(tab[0], "color")) { check_color(ft_atof(tab[2]), ft_atof(tab[3]), ft_atof(tab[4])); rt->light[rt->i_light].color.r = ft_atof(tab[2]); rt->light[rt->i_light].color.g = ft_atof(tab[3]); rt->light[rt->i_light].color.b = ft_atof(tab[4]); } else if (!ft_strcmp(tab[0], "parallel")) rt->light[rt->i_light].parallel = ft_atoi(tab[2]); tab_free(tab); ft_strdel(&line); } (tmp) ? (ft_strdel(&line)) : (0); rt->i_light++; }
t_color apply_refraction(t_ray *start, t_scene *scene, t_hit drawn_pixel, double noise) { double refract_indice; t_color tmp_color; int test; tmp_color = drawn_pixel.color; if (drawn_pixel.t_max == drawn_pixel.t) { refract_indice = drawn_pixel.ref_index; test = -1; } else { test = 1; refract_indice = 1.0 / drawn_pixel.ref_index; } *start = find_refract_vect(start, drawn_pixel, refract_indice, test); if (get_length(start->dir) != 0) { if (scene->is_real == CARTOON && is_black_edge(&drawn_pixel)) { tmp_color = init_color(0, 0, 0); return (tmp_color); } else tmp_color = add_color(tmp_color, color_render(scene, start, noise, NULL)); } check_color(&tmp_color); return (tmp_color); }
void parse_either( char *attrs, int dft_color, int *monop, int *colorp ) { int value; while ( attrs[0] ) { char *next = strchr( attrs, '+' ); char save = 0; if ( next == 0 ) { next = attrs + strlen( attrs ); } if ( save ) next[0] = 0; value = string_to_attr( attrs ); if ( value ) monop[0] |= value; else if ( colorp ) { value = check_color( attrs, dft_color ); if ( value != -3 ) colorp[0] = value; } attrs = next; if ( save ) { attrs[0] = save; attrs++; } } return; }
t_k *luminosite(t_spot *spot, t_k *k, t_objet *obj, t_utils *utils) { double a; double tmp; t_utils l; t_objet obj3; a = 0.0; init_new_color(k); trans_inv(utils, obj, 0); obj_rot(utils, obj, -1, 1); calc_coord(k, &obj3, utils); utils = init_norm(obj, obj3, utils); while (spot != NULL) { init_distance(spot, &l, obj3); tmp = calc_cos(utils, l); get_new_color(k, (tmp < 0.0 ? tmp = 0.0 : tmp), obj, spot); spot = spot->next; a++; } obj_rot(utils, obj, 1, 1); trans_nor(utils, obj, 0); check_color(k, a, utils); return (k); }
t_k *luminosite(t_spot *spot, t_k *k, t_objet *obj, t_utils *utils) { t_utils L; t_objet obj3; double tmp; double a; a = 0.0; init_new_color(k); trans_inv(utils, obj, 0); obj_rot(utils, obj, -1, 1); calc_coord(k, &obj3, utils); utils = my_init_norm(obj, obj3, utils); while (spot != NULL) { init_distance(spot, &L, obj3); tmp = calc_cos(utils, L); if (obj->texture == 1 || obj->texture == 2) k = texture(obj3, k, obj->texture); get_new_color(k, (tmp < 0.0 ? tmp = 0.0 : tmp), obj, spot); spot = spot->next; a++; } obj_rot(utils, obj, 1, 1); trans_nor(utils, obj, 0); check_color(k, a, utils); return (k); }
void Hero::move(){ if(enable_to_move){ check_color(); gravity_jump(); if(direction_x == LEFT){ if(stucked != S_LEFT){ stucked= NO; if(speed >= -6) {speed = speed - 3;} pos_x += speed; if(!tile_flipped){ tile_transformation = T_LEFT; tile_flipped = true; }else{ tile_transformation=T_NO; } } } if(direction_x == RIGHT){ if(stucked!= S_RIGHT){ stucked = NO; if(speed <= 6) {speed = speed + 3;} pos_x += speed; if(tile_flipped){ tile_transformation = T_RIGHT; tile_flipped = false; }else{ tile_transformation=T_NO; } } } } }
void EdgeDetector::stackfill(int x,int y) { points.push(Point(x,y)); while(points.empty()==false) { Point p=points.top(); points.pop(); setPixel(p); for(int i=-1;i<=1;i++) { for(int j=-1;j<=1;j++) { if(i==0 && j==0) continue; Point p1=Point(p.x+i,p.y+j); if(check_color(p1)==true) { points.push(p1); } } } } }
void cekGaris() { int a; motor[leftMotor] = 0; motor[rightMotor] = 0; while(1) { a=check_color(); } }
/** * \brief Implementation of surface:set_transparency_color(). * \param l the Lua context that is calling this function * \return number of values to return to Lua */ int LuaContext::surface_api_set_transparency_color(lua_State* l) { Surface& surface = check_surface(l, 1); Color color = check_color(l, 2); surface.set_transparency_color(color); return 0; }
// Make sure our blits always map src==0 to a noop, and src==FF to full opaque static void test_00_FF(skiatest::Reporter* reporter) { static const int W = 256; static const SkBitmap::Config gDstConfig[] = { SkBitmap::kARGB_8888_Config, SkBitmap::kRGB_565_Config, // SkBitmap::kARGB_4444_Config, // SkBitmap::kA8_Config, }; static const struct { SkColor fSrc; SkColor fDst; SkPMColor fResult32; uint16_t fResult16; uint8_t fResult8; } gSrcRec[] = { { 0, 0, 0, 0, 0 }, { 0, 0xFFFFFFFF, SkPackARGB32(0xFF, 0xFF, 0xFF, 0xFF), 0xFFFF, 0xFF }, { 0xFFFFFFFF, 0, SkPackARGB32(0xFF, 0xFF, 0xFF, 0xFF), 0xFFFF, 0xFF }, { 0xFFFFFFFF, 0xFFFFFFFF, SkPackARGB32(0xFF, 0xFF, 0xFF, 0xFF), 0xFFFF, 0xFF }, }; SkPaint paint; SkBitmap srcBM; srcBM.setConfig(SkBitmap::kARGB_8888_Config, W, 1); srcBM.allocPixels(); for (size_t i = 0; i < SK_ARRAY_COUNT(gDstConfig); i++) { SkBitmap dstBM; dstBM.setConfig(gDstConfig[i], W, 1); dstBM.allocPixels(); SkCanvas canvas(dstBM); for (size_t j = 0; j < SK_ARRAY_COUNT(gSrcRec); j++) { srcBM.eraseColor(gSrcRec[j].fSrc); dstBM.eraseColor(gSrcRec[j].fDst); for (int k = 0; k < 4; k++) { bool dither = (k & 1) != 0; bool blend = (k & 2) != 0; if (gSrcRec[j].fSrc != 0 && blend) { // can't make a numerical promise about blending anything // but 0 // continue; } paint.setDither(dither); paint.setAlpha(blend ? 0x80 : 0xFF); canvas.drawBitmap(srcBM, 0, 0, &paint); if (!check_color(dstBM, gSrcRec[j].fResult32, gSrcRec[j].fResult16, gSrcRec[j].fResult8, reporter)) { SkDebugf("--- src index %d dither %d blend %d\n", j, dither, blend); } } } } }
/** * \brief Implementation of text_surface:set_color(). * \param l the Lua context that is calling this function * \return number of values to return to Lua */ int LuaContext::text_surface_api_set_color(lua_State* l) { TextSurface& text_surface = check_text_surface(l, 1); const Color& color = check_color(l, 2); text_surface.set_text_color(color); return 0; }
void cekSimpang(Queue *Q) { if(checkLine(right)) { int heuristic = check_color(); node n = {right,heuristic}; addToQueue(Q,right); } if(checkLine(left)) { int heuristic = check_color(); node n = {right,heuristic}; addToQueue(Q,straight); } if(checkLine(left)) { int heuristic = check_color(); node n = {right,heuristic}; addToQueue(Q,left); } turn(right,90); }
int parse_color(const char *name) /* {{{ */ { /* parse a color from a string */ unsigned int i; int ret; struct color_map { const int color; const char *name; }; /* color map */ static const struct color_map colors_map[] = { {COLOR_BLACK, "black"}, {COLOR_RED, "red"}, {COLOR_GREEN, "green"}, {COLOR_YELLOW, "yellow"}, {COLOR_BLUE, "blue"}, {COLOR_MAGENTA, "magenta"}, {COLOR_CYAN, "cyan"}, {COLOR_WHITE, "white"}, }; /* try for int */ ret = sscanf(name, "%d", &i); if (ret == 1) return check_color(i); /* try for colorNNN */ ret = sscanf(name, "color%3d", &i); if (ret == 1) return check_color(i); /* look for mapped color */ for (i=0; i<sizeof(colors_map)/sizeof(struct color_map); i++) { if (str_eq(colors_map[i].name, name)) return check_color(colors_map[i].color); } return -2; } /* }}} */
void fill_circle(void) { _circle* c; c = POP(_circle); check_color(); fprintf(output_file, "\\pscircle*"); put_local(); fprintf(output_file, "(%.4f,%.4f){%.4f}\n", c->x, c->y, c->r); }
void fill_polygon(void) { _set* s; s = POP(_set); if (s == NULL) return; check_color(); fprintf(output_file, "\\pspolygon*"); put_local(); put_set(s); }
void draw_point(void) { _point *A; A = POP(_point); check_color(); check_shape(); check_dotsize(); fprintf(output_file, "\\psdots"); put_local(); fprintf(output_file, "(%.4f,%.4f)\n", A->x, A->y); }
/** * \brief Implementation of surface:fill_color(). * \param l the Lua context that is calling this function * \return number of values to return to Lua */ int LuaContext::surface_api_fill_color(lua_State* l) { Surface& surface = check_surface(l, 1); Color color = check_color(l, 2); if (lua_gettop(l) >= 3) { int x = luaL_checkint(l, 3); int y = luaL_checkint(l, 4); int width = luaL_checkint(l, 5); int height = luaL_checkint(l, 6); Rectangle where(x, y, width, height); surface.fill_with_color(color, where); } else { surface.fill_with_color(color); } return 0; }
static void parsing_options(char **tab, t_env *rt, int i) { if (!tab[0] || !tab[1]) ft_exit("\033[31mWrong format for an object\n"); missing_parameter_obj(tab); if (!ft_strcmp(tab[0], "radius")) { if (ATOF(2) <= 0 && rt->object[i].name != PLANE && rt->object[i].name != HYPERBOL) ft_exit("\033[31mRadius must be positive\n"); rt->object[i].radius = ATOF(2); } else if (!ft_strcmp(tab[0], "pos")) rt->object[i].center = new_vector(ATOF(2), ATOF(3), ATOF(4)); else if (!ft_strcmp(tab[0], "color")) { check_color(ATOF(2), ATOF(3), ATOF(4)); rt->object[i].color = new_color(ATOF(2), ATOF(3), ATOF(4)); } }
SM_CrossStitchEssentialMaterialInfo * SM_CrossStitchEssentialMaterialInfo_New(size_t size, char *color) { size_t color_len = strlen(color); if (color_len == 0) { color = "#ffffff"; color_len = strlen(color); } if (!check_color(color)) { return NULL; } if (size == 0) { return NULL; } SM_CrossStitchEssentialMaterialInfo *ret = malloc(sizeof(SM_CrossStitchEssentialMaterialInfo)); ret->canvas.size = size; ret->canvas.color = malloc(color_len + 1); memcpy(ret->canvas.color, color, color_len + 1); return ret; }
int checkLine(int dir) { int a,degmax=0; int incdegree=dir==right?10:-10; int rightpower=dir==right?-50:50; int rightdegree=dir==right?-10:10; while((degmax<2300&&dir==right) || (degmax>-2300&&dir==left)) { a=check_color(); switch(a) { case 0: moveMotorTarget(leftMotor,-rightdegree,-rightpower); moveMotorTarget(rightMotor,rightdegree,rightpower); while(getMotorMoving(leftMotor) && getMotorMoving(rightMotor)) sleep(1); degmax+=incdegree; break; case 1: motor[leftMotor]=0; motor[rightMotor]=0; sleep(100); return 1; } } }
int searchSpot() { //menelusuri garis hitam sampai menemukan "color" int a; while(1) { a=check_color(); switch(a){ case 0: //Putih_Arena -> Belok Kanan motor[leftMotor] = 15; motor[rightMotor] = 55; break; case 1: //Hitam_Garis -> Belok Kiri motor[leftMotor] = 55; motor[rightMotor] = 15; break; case 3: //Ijo_Simpang -> diem //moveMotorTarget(leftMotor,180,50); //moveMotorTarget(rightMotor,-180,-50); motor[leftMotor] =0; motor[rightMotor] =0; sleep(10); while(getMotorMoving(leftMotor) && getMotorMoving(rightMotor)) sleep(1); break; case 4: //Merah_ujung -> Balik kanan motor[leftMotor] = 100; motor[rightMotor] = -100; sleep(500); break; default: //motor[leftMotor] = 0; //motor[rightMotor] = 0; } } return a; }
task main() { while(true) { //cekGaris(); int a=check_color(); switch(a){ case 0: //Putih_Arena -> Belok Kanan motor[leftMotor] = -20; motor[rightMotor] = 40; break; case 1: //Hitam_Garis -> Belok Kiri motor[leftMotor] = 40; motor[rightMotor] = -20; break; case 3: //Ijo_Simpang -> diem //moveMotorTarget(leftMotor,40,50); //moveMotorTarget(rightMotor,40,50); motor[leftMotor] =0; motor[rightMotor] =0; sleep(1000); //while(getMotorMoving(leftMotor) && getMotorMoving(rightMotor)) //sleep(1); break; case 4: //Merah_ujung -> Balik kanan motor[leftMotor] =0; motor[rightMotor] =0; sleep(1000); break; default: //motor[leftMotor] = 0; //motor[rightMotor] = 0; } } }
void label_angle(void) { double a, b, r, s, t,x1, y1, x2, y2; _point *A, *B, *C; check_color(); C = POP(_point); B = POP(_point); A = POP(_point); a = argument(B, A); b = argument(B, C); r = SIZE(.5); s = .08/scale; fprintf(output_file, "\\pscustom"); put_local(); fprintf(output_file, "{\n"); switch (local_angle) { case SIMPLE: draw_mark("", B, r, a, b); if (local_dec == DOTTED) { set_xy(A, B, C, SIZE(M_SQRT2/8), &x1, &y1, &x2, &y2); fprintf(output_file, " \\Dot{%.4f}{%.4f}{%.4f}\n", B->x + x1 + x2, B->y + y1 + y2, SIZE(.05)); } if (local_dec == DASHED) { fprintf(output_file, " \\Dash{%.4f}{%.4f}{%.4f}{%.4f}{%.4f}\n", B->x, B->y, (a + b)/2, r - s, r + s); } break; case DOUBLE: if (local_dec == DASHED) { draw_mark("", B, r, a, b); t = 8/local_size; fprintf(output_file, " \\DoubleDash" "{%.4f}{%.4f}{%.4f}{%.4f}{%.4f}{%.4f}\n", B->x, B->y, r - s, r + s, (a + b)/2 - t/2, t); } else { fprintf(output_file, " \\DoubleArc" "{%.4f}{%.4f}{%.4f}{%.4f}{%.4f}{%.4f}\n", B->x, B->y, r - s/2, r + s/2, a, b); } break; case TRIPLE: if (local_dec == DASHED) { draw_mark("", B, r, a, b); t = 8/local_size; fprintf(output_file, " \\TripleDash" "{%.4f}{%.4f}{%.4f}{%.4f}{%.4f}{%.4f}\n", B->x, B->y, r - s, r + s, (a + b)/2 - t, t); } else { fprintf(output_file, " \\TripleArc" "{%.4f}{%.4f}{%.4f}{%.4f}{%.4f}{%.4f}{%.4f}\n", B->x, B->y, r - s, r, r + s, a, b); } break; case RIGHT: set_xy(A, B, C, SIZE(.35), &x1, &y1, &x2, &y2); fprintf(output_file, " \\Right{%.4f}{%.4f}{%.4f}{%.4f}{%.4f}{%.4f}\n", B->x + x1, B->y + y1, x2, y2, -x1, -y1); if (local_dec == DOTTED) { fprintf(output_file, " \\Dot{%.4f}{%.4f}{%.4f}\n", B->x + (x1 + x2)/2, B->y + (y1 + y2)/2, SIZE(.05)); } break; case FORTH: draw_mark("{->}", B, r, a, b); break; case BACK: draw_mark("{<-}", B, r, a, b); break; } fprintf(output_file, "}\n"); }
static GLboolean intelTryReadPixels( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, const struct gl_pixelstore_attrib *pack, GLvoid *pixels ) { intelContextPtr intel = INTEL_CONTEXT(ctx); GLint size = 0; /* not really used */ GLint pitch = pack->RowLength ? pack->RowLength : width; if (INTEL_DEBUG & DEBUG_PIXEL) fprintf(stderr, "%s\n", __FUNCTION__); /* Only accelerate reading to agp buffers. */ if ( !intelIsAgpMemory(intel, pixels, pitch * height * intel->intelScreen->cpp ) ) { if (INTEL_DEBUG & DEBUG_PIXEL) fprintf(stderr, "%s: dest not agp\n", __FUNCTION__); return GL_FALSE; } /* Need GL_PACK_INVERT_MESA to cope with upsidedown results from * blitter: */ if (!pack->Invert) { if (INTEL_DEBUG & DEBUG_PIXEL) fprintf(stderr, "%s: MESA_PACK_INVERT not set\n", __FUNCTION__); return GL_FALSE; } if (!check_color(ctx, type, format, pack, pixels, size, pitch)) return GL_FALSE; switch ( intel->intelScreen->cpp ) { case 4: break; default: return GL_FALSE; } /* Although the blits go on the command buffer, need to do this and * fire with lock held to guarentee cliprects and drawing offset are * correct. * * This is an unusual situation however, as the code which flushes * a full command buffer expects to be called unlocked. As a * workaround, immediately flush the buffer on aquiring the lock. */ intelFlush( &intel->ctx ); LOCK_HARDWARE( intel ); { __DRIdrawablePrivate *dPriv = intel->driDrawable; int nbox = dPriv->numClipRects; int src_offset = intel->readRegion->offset; int src_pitch = intel->intelScreen->front.pitch; int dst_offset = intelAgpOffsetFromVirtual( intel, pixels); drm_clip_rect_t *box = dPriv->pClipRects; int i; assert(dst_offset != ~0); /* should have been caught above */ if (!clip_pixelrect(ctx, ctx->ReadBuffer, &x, &y, &width, &height)) { UNLOCK_HARDWARE( intel ); if (INTEL_DEBUG & DEBUG_PIXEL) fprintf(stderr, "%s totally clipped -- nothing to do\n", __FUNCTION__); return GL_TRUE; } /* convert to screen coords (y=0=top) */ y = dPriv->h - y - height; x += dPriv->x; y += dPriv->y; if (INTEL_DEBUG & DEBUG_PIXEL) fprintf(stderr, "readpixel blit src_pitch %d dst_pitch %d\n", src_pitch, pitch); /* We don't really have to do window clipping for readpixels. * The OpenGL spec says that pixels read from outside the * visible window region (pixel ownership) have undefined value. */ for (i = 0 ; i < nbox ; i++) { GLint bx, by, bw, bh; if (intersect_region(box+i, x, y, width, height, &bx, &by, &bw, &bh)) { intelEmitCopyBlitLocked( intel, intel->intelScreen->cpp, src_pitch, src_offset, pitch, dst_offset, bx, by, bx - x, by - y, bw, bh ); } } } UNLOCK_HARDWARE( intel ); intelFinish( &intel->ctx ); return GL_TRUE; }
static GLboolean intelTryDrawPixels( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, const struct gl_pixelstore_attrib *unpack, const GLvoid *pixels ) { intelContextPtr intel = INTEL_CONTEXT(ctx); GLint pitch = unpack->RowLength ? unpack->RowLength : width; GLuint dest; GLuint cpp = intel->intelScreen->cpp; GLint size = width * pitch * cpp; if (INTEL_DEBUG & DEBUG_PIXEL) fprintf(stderr, "%s\n", __FUNCTION__); switch (format) { case GL_RGB: case GL_RGBA: case GL_BGRA: dest = intel->drawRegion->offset; /* Planemask doesn't have full support in blits. */ if (!ctx->Color.ColorMask[RCOMP] || !ctx->Color.ColorMask[GCOMP] || !ctx->Color.ColorMask[BCOMP] || !ctx->Color.ColorMask[ACOMP]) { if (INTEL_DEBUG & DEBUG_PIXEL) fprintf(stderr, "%s: planemask\n", __FUNCTION__); return GL_FALSE; } /* Can't do conversions on agp reads/draws. */ if ( !intelIsAgpMemory( intel, pixels, size ) ) { if (INTEL_DEBUG & DEBUG_PIXEL) fprintf(stderr, "%s: not agp memory\n", __FUNCTION__); return GL_FALSE; } if (!check_color(ctx, type, format, unpack, pixels, size, pitch)) { return GL_FALSE; } if (!check_color_per_fragment_ops(ctx)) { return GL_FALSE; } if (ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != -1.0F) return GL_FALSE; break; default: return GL_FALSE; } if ( intelIsAgpMemory(intel, pixels, size) ) { do_draw_pix( ctx, x, y, width, height, pitch, pixels, dest ); return GL_TRUE; } else if (0) { /* Pixels is in regular memory -- get dma buffers and perform * upload through them. No point doing this for regular uploads * but once we remove some of the restrictions above (colormask, * pixelformat conversion, zoom?, etc), this could be a win. */ } else return GL_FALSE; return GL_FALSE; }
static GLboolean r200TryReadPixels( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, const struct gl_pixelstore_attrib *pack, GLvoid *pixels ) { r200ContextPtr rmesa = R200_CONTEXT(ctx); GLint pitch = pack->RowLength ? pack->RowLength : width; GLint blit_format; GLuint cpp = rmesa->r200Screen->cpp; GLint size = width * height * cpp; if (R200_DEBUG & DEBUG_PIXEL) fprintf(stderr, "%s\n", __FUNCTION__); /* Only accelerate reading to GART buffers. */ if ( !r200IsGartMemory(rmesa, pixels, pitch * height * rmesa->r200Screen->cpp ) ) { if (R200_DEBUG & DEBUG_PIXEL) fprintf(stderr, "%s: dest not GART\n", __FUNCTION__); return GL_FALSE; } /* Need GL_PACK_INVERT_MESA to cope with upsidedown results from * blitter: */ if (!pack->Invert) { if (R200_DEBUG & DEBUG_PIXEL) fprintf(stderr, "%s: MESA_PACK_INVERT not set\n", __FUNCTION__); return GL_FALSE; } if (!check_color(ctx, type, format, pack, pixels, size, pitch)) return GL_FALSE; switch ( rmesa->r200Screen->cpp ) { case 4: blit_format = R200_CP_COLOR_FORMAT_ARGB8888; break; default: return GL_FALSE; } /* Although the blits go on the command buffer, need to do this and * fire with lock held to guarentee cliprects and drawOffset are * correct. * * This is an unusual situation however, as the code which flushes * a full command buffer expects to be called unlocked. As a * workaround, immediately flush the buffer on aquiring the lock. */ LOCK_HARDWARE( rmesa ); if (rmesa->store.cmd_used) r200FlushCmdBufLocked( rmesa, __FUNCTION__ ); if (!clip_pixelrect(ctx, ctx->ReadBuffer, &x, &y, &width, &height, &size)) { UNLOCK_HARDWARE( rmesa ); if (R200_DEBUG & DEBUG_PIXEL) fprintf(stderr, "%s totally clipped -- nothing to do\n", __FUNCTION__); return GL_TRUE; } { __DRIdrawablePrivate *dPriv = rmesa->dri.drawable; driRenderbuffer *drb = (driRenderbuffer *) ctx->ReadBuffer->_ColorReadBuffer; int nbox = dPriv->numClipRects; int src_offset = drb->offset + rmesa->r200Screen->fbLocation; int src_pitch = drb->pitch * drb->cpp; int dst_offset = r200GartOffsetFromVirtual( rmesa, pixels ); int dst_pitch = pitch * rmesa->r200Screen->cpp; drm_clip_rect_t *box = dPriv->pClipRects; int i; r200EmitWait( rmesa, RADEON_WAIT_3D ); y = dPriv->h - y - height; x += dPriv->x; y += dPriv->y; if (R200_DEBUG & DEBUG_PIXEL) fprintf(stderr, "readpixel blit src_pitch %d dst_pitch %d\n", src_pitch, dst_pitch); for (i = 0 ; i < nbox ; i++) { GLint bx = box[i].x1; GLint by = box[i].y1; GLint bw = box[i].x2 - bx; GLint bh = box[i].y2 - by; if (bx < x) bw -= x - bx, bx = x; if (by < y) bh -= y - by, by = y; if (bx + bw > x + width) bw = x + width - bx; if (by + bh > y + height) bh = y + height - by; if (bw <= 0) continue; if (bh <= 0) continue; r200EmitBlit( rmesa, blit_format, src_pitch, src_offset, dst_pitch, dst_offset, bx, by, bx - x, by - y, bw, bh ); } r200FlushCmdBufLocked( rmesa, __FUNCTION__ ); } UNLOCK_HARDWARE( rmesa ); r200Finish( ctx ); /* required by GL */ return GL_TRUE; }
static GLboolean r200TryDrawPixels( GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, const struct gl_pixelstore_attrib *unpack, const GLvoid *pixels ) { r200ContextPtr rmesa = R200_CONTEXT(ctx); GLint pitch = unpack->RowLength ? unpack->RowLength : width; GLuint planemask; GLuint cpp = rmesa->r200Screen->cpp; GLint size = width * pitch * cpp; if (R200_DEBUG & DEBUG_PIXEL) fprintf(stderr, "%s\n", __FUNCTION__); /* check that we're drawing to exactly one color buffer */ if (ctx->DrawBuffer->_NumColorDrawBuffers[0] != 1) return GL_FALSE; switch (format) { case GL_RGB: case GL_RGBA: case GL_BGRA: planemask = r200PackColor(cpp, ctx->Color.ColorMask[RCOMP], ctx->Color.ColorMask[GCOMP], ctx->Color.ColorMask[BCOMP], ctx->Color.ColorMask[ACOMP]); if (cpp == 2) planemask |= planemask << 16; if (planemask != ~0) return GL_FALSE; /* fix me -- should be possible */ /* Can't do conversions on GART reads/draws. */ if ( !r200IsGartMemory( rmesa, pixels, size ) ) { if (R200_DEBUG & DEBUG_PIXEL) fprintf(stderr, "%s: not GART memory\n", __FUNCTION__); return GL_FALSE; } if (!check_color(ctx, type, format, unpack, pixels, size, pitch)) { return GL_FALSE; } if (!check_color_per_fragment_ops(ctx)) { return GL_FALSE; } if (ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != -1.0F) return GL_FALSE; break; default: return GL_FALSE; } if ( r200IsGartMemory(rmesa, pixels, size) ) { do_draw_pix( ctx, x, y, width, height, pitch, pixels, planemask ); return GL_TRUE; } else if (0) { /* Pixels is in regular memory -- get dma buffers and perform * upload through them. */ } else return GL_FALSE; }