Newsgroup: it.comp.lang.c++
Titolo: SOS Algoritmo lettura sprite

Come posso implementare un algoritmo che mi legga degli sprite da files e
che li stampi a schermo (modalita chained 320x200x256 int10, serv 13h).
Sto usando il c++ misto all'asm (solo per le procedure base della gfx: per
disegnare un punto, per cancellare lo schermo ecc...).
Io avevo pensato ad un formato grafico che funzionasse a 256 colori (usando
degli unsigned char come contenitori per ogni pixel).
Ho gia scritto qualcosina, magari dateci una occhiata e ditemi...
NOTA: spero possiate capire l'utilizzo delle funzioni inserite nel file
graph.h, dato che il nome chiarisce tutto (  put_pixel(10,10,15), cosa
cavolo puo essere se non una funz. che stampa uno sprite???)
codice :
#include <alloc.h>
#include <stdio.h>
#include "graph.h"
typedef struct {
 int xheight, yheight;     //posizione iniziale sprite
 char *path;   //percorso del file
 char *color;     //colore dei punti
 FILE *stream;                   //stream del file del frame
} sprite;
int putsprite(sprite* MySprite, int posx, int posy);
int getsprite(sprite* MySprite);
int main()
{
 sprite spr;
 spr.xheight = 1;
 spr.yheight = 4;
 spr.path = "c:\\tc\\myfiles\\sprite.txt";
 initgraph();
 clear_screen(0);
 getsprite(&spr);
 putsprite(&spr, 50, 50);
 key();
 clear_screen(0);
 closegraph();
 return 0;
}
/////////////////////////
//putsprite -> funzione//
/////////////////////////
int putsprite(sprite* MySprite, int posx, int posy)
{
 int i,j;
 for(i = 0; i < MySprite->yheight; i++)
 {
  for(j = 0; j < MySprite->xheight; j++)
  {
   put_pixel(i+posx, j+posy,15);    //non so proprio che fare per il colore
da scegliere!!!
  }
 }
 return 0;
}
/////////////////////////
//getsprite -> funzione//
/////////////////////////
int getsprite(sprite* MySprite)
{
//funzione per caricare il frame da file
 int righe;  //lo uso come contatore
 if(!(MySprite->stream = fopen(MySprite->path, "r")))
   {
    closegraph();
    fprintf(stderr, "Errore nell'apertura del file %s\n", MySprite->path);
    return 1;
   }
  if ((MySprite->color = (char *)
malloc(MySprite->xheight*MySprite->yheight)) == NULL )
   {
    closegraph();
    fprintf(stderr, "Errore nella creazione del frame buffer.\n");
    return 2;
   }
 for(righe = 0; righe < MySprite->xheight; righe++)
 {
  if((fread(MySprite->color, sizeof(char), MySprite->yheight,
MySprite->stream))<(MySprite->xheight*MySprite->yheight))
  {
   closegraph();
   fprintf(stderr, "Errore nella lettura del file %s\n",MySprite->path);
   return 3;
  }
  fseek(MySprite->stream, (long) MySprite->yheight, SEEK_CUR);
 }
 fclose(MySprite->stream);
 return 0;
}

Visto che siamo in un NG che parla del C++, e soprattutto dato che un
oggetto come uno sprite si presta benissimo ad essere incapsulato in una
classe, ti posto il codice (lo sto buttando giù ora, mentre che scrivo,
quindi non sarà privo di errori) di una ipotetica classe CSprite.
class CSprite
{
public:
 Load(char *path);
 Save(char *path);
 Get(int x1, int y1, intx2, int y2);
 Put(int x1, int y1);
protected:
int height, width;
char *data;
};
// Per la gestione dei file uso la libreria standard del C: non me ne
vogliate....
CSprite::Load(char *path)
{
 FILE *File;
File = fopen(path, "r");
width = getw(File);
height = getw(File);
delete data;       // Nel caso fosse già stato caricato precedentemente
data = new char[width * height];
fread(data, width*height, 1, File);
fclose(File);
};
CSprite::Save(char *path)
{
 FILE *File;
File = fopen(path, "w");
putw(width, File);
putw(height, File);
fwrite(data, width*height, 1, File);
fclose(File);
};
CSprite::Get(int x1, int y1, intx2, int y2)
{
int x, y, count=0;
width = max(x1,x2) - min(x1,x2) + 1;
height = max(y1,y2) - min(y1,y2) + 1;
delete data;
data = new char [width*height];
for(y=min(y1,y2); y<=max(y1,y2); y++)
{
  for(x=min(x1,x2); x<=max(x1,x2); x++)
  {
     data[count] = getpixel(x,y);
     count++;
  };
};
};
CSprite::Put(int x1, int y1)
{
 int x, y, count=0;
for(y=y1; y<=y1+height; y++)
{
  for(x=x1; x<=x1+width; x++)
  {
     putpixel(x, y, data[count]);
     count++;
  };
};
};
Per un utilizzo serio il codice può (deve) essere fortemente ottimizzato nei
cicli e nei controlli (meglio se in asm). Inoltre è consigliabile aggiungere
dell'altro codice per un'eventuale mascheratura e per ulteriori controlli (è
già stato caricato lo sprite? esce dai limiti dello schermo?)
Ciao, Giuseppe