[RegIon]

int LoadImage(loadimg img)
{ 
if(img.data==0) return 0;
int i,n;
uint16_t c,r1,b1,g1;
uint16_t out_w=img.width;
img.mask=0;
for(i=0;i<img.height;i++){
 for(n=0;n<img.width;n++){
    r1=img.data[((i*out_w)*3+n*3)];
    g1=img.data[((i*out_w)*3+n*3)+1];
    b1=img.data[((i*out_w)*3+n*3)+2];
    c=MAKE_RGB565(r1,g1,b1);
    img.data[i*img.width+n]=c;
}    
}
return 1;
}

int LoadAnimImage(loadimg img,uint16_t f_w,uint16_t f_h,uint16_t f_c)
{ 
  if(f_c==0)return 0; 
  LoadImage(img);
  if(f_c>1){
  if(img.width>f_w-1){
  img.framecount=f_c;
  img.f_width=f_w;
  img.f_height=f_h;
   }
   }
   return 1;
}

void DrawImage(uint16_t *screen,int x,int y,loadimg img,uint16_t fram)
{ 
int i,n;
uint16_t c;
uint16_t img_w=img.width;
uint16_t img_h=img.height;
if(img.f_width>0 && img.f_height>0){
img_w=img.f_width;
img_h=img.f_height;
}
if(fram>img.framecount)fram=img.framecount;
for(i=0;i<img_h;i++){
 for(n=0;n<img_w;n++){
  c=img.data[fram*(img_w*img_h)+i*img_w+n];
   if(c!=img.mask)SetPixel(screen,x+i,y+n,c);
}    
}
}

void TileImage(uint16_t *buff,loadimg img,int x,int y,uint16_t width,uint16_t height)
{
uint16_t i,n,w_c,h_c;
w_c=img.width/width;
h_c=img.height/height;

  for(i=0;i<w_c;i++){
      for(n=0;n<h_c;n++){
        
          DrawImage(buff,img,x+img.width*i,y+img.width*n);  
    
       }
  }
}

void SetMask(loadimg img,uint16_t c)
{
img.mask=c;
}

void Graphics(uint16_t* screens,int SCREENWIDTH,int SCREENHEIGHT){ //гапи приставки
   //апи функции,прикольно,все через 4 идут(32бита на каждую получается почти)
   _dprintf              = FUNC(0x04);
    gfx_init              = FUNC(0x38);
    gfx_set_framebuffer   = FUNC(0x90);
    gfx_set_display_screen= FUNC(0x54);
    gfx_set_cammmode      = FUNC(0x8c);
    gfx_set_colorrop      = FUNC(0x3c);
    gfx_set_fgcolor       = FUNC(0x44);
    gfx_get_fgcolor       = FUNC(0x48);
    gfx_set_alpha         = FUNC(0x74);
    gfx_get_alpha         = FUNC(0x78);
    gfx_fillrect          = FUNC(0xc4);
    gfx_enable_feature    = FUNC(0x7c);
    gfx_flush             = FUNC(0xc);
    gfx_paint             = FUNC(0x10);
    gfx_load_image        = FUNC(0x14);
    gfx_free_image        = FUNC(0x18);
    gfx_bitblt            = FUNC(0xB4);
    gfx_sprite            = FUNC(0xB8);

    res_init              = FUNC(0xD4);
    res_get               = FUNC(0xD8);
    res_play              = FUNC(0xDC);
    res_stop              = FUNC(0xE8);

    fs_open               = FUNC(0x13C);
    fs_read               = FUNC(0x140);
    fs_write              = FUNC(0x144);
    fs_close              = FUNC(0x148);
    fs_seek               = FUNC(0x14C);

    get_time              = FUNC(0x124);
    get_keys              = FUNC(0x100);
    //get_keys2             = gpio_reg(0x60);//не хотит работать так,виснит....
    //
    static int    firsttime=1;
    gfx_rect_t rect;

    gfx_init(NULL, 0);

    rect.x = 0;
    rect.y = 0;
    rect.width = SCREENWIDTH;
    rect.height = SCREENHEIGHT;
    gfx_set_framebuffer(SCREENWIDTH,SCREENHEIGHT);
    gfx_set_display_screen(&rect);
 
    firsttime = 0;

    cls(screens,0x0000);//так лучше
    
    video_img.data     = screens;
    video_img.width    = SCREENWIDTH;
    video_img.height   = SCREENHEIGHT;
    video_img.img_type = IMG_TYPE_16BPP;
    video_img.unk2     = 0;
    video_img.pal_data = 0;//а палитры тю-тю
    video_img.pal_size = 0;//нет палитры-нет размера
    video_img.flags[0]   = 0x80;
    video_img.flags[1]   = 0;
    video_img.flags[2]   = 0;
    video_img.flags[3]   = 0;
    gfx_load_image(&video_img, &video_handle);
    gfx_set_colorrop(0xcc);
   
}

void Render(void){
gfx_rect_t rect;
gfx_point2d_t pos;

    rect.x = 0;
    rect.y = 0;
    rect.width =video_img.width  ;
    rect.height = video_img.height ;

pos.x=0;
pos.y=0;
gfx_bitblt(video_handle,&rect,&pos);
}

void ShutdownGraphics(void){
gfx_free_image(video_handle);
}

void cls(uint16_t* screens,uint16_t c){
int i;
for(i=0;i<video_img.width * video_img.height;i++) screens[i]=c;
//тут лучше так,меньше проходов нужно.
//screens=c;
}


void SetPixel(uint16_t* buff,uint16_t x,uint16_t y,uint16_t c)
{
if(y < video_img.height && y > 0) {
   if(x < video_img.width && x > 0)buff[video_img.width*y+x]=c;
   }
//так как буфер ограничен,не разрешим запись выходящих за грани пикселов
}

uint16_t GetPixel(uint16_t* buff,uint16_t x,uint16_t y)
{
uint16_t c=0x0000;
if(x < video_img.width && x > 0 ){
if(y < video_img.height && y > 0) c=buff[video_img.width*y+x];
}
return c;//пригодится,не разрешает просканить пкселы которые за гранью буффера..
}
void rect(uint16_t* buff,int x,int y,int h,int w,uint16_t c){
int i,n;
if(h==0 || w==0)return;
for(i=0;i<h;i++){
  for(n=0;n<w;n++){
  
  SetPixel(buff,i+x,n+y,c);  
    }
  } 
}

вот что есть,все кроме Graphics переписать придётся..?