Programa de rasterização

[FelipeCarioca]

#define MAX(a,B)    (((a) > (B)) ? (a) : (B))
#define MIN(a,B)    (((a) < (B)) ? (a) : (B))

struct edge
{
  int     y_max;       /* maior y da aresta */
  int     y_min;      /* menor y da aresta */
  float   xs;      /* x correspondente a ys */
                      /* (no início é o correspondente a y_max) */
  float delta; /* incremento de xs entre duas linhas de scan */
};

void fill (int np, int *x, int *y)
{
  static struct edge *aresta=NULL;    /* vetor de arestas */
  static int *vxs=NULL;        /* vetor de interseções */
  static int old_np=0;    /* número de pontos da última chamada */

  int ymax, ymin;    /* limites do polígono */
  int num_inters;    /* num. de interseções */
  int num_arestas;    /* num. de arestas */
  int ys;        /* ordenada da reta de scan */
  int i;

/* realoca os vetores de arestas e de interseções */
  if (np > old_np)
  {
    old_np=np;
    if (vxs) free (vxs);
    if (aresta) free (aresta);
    vxs=(int *) malloc ((np-1)*sizeof(int)); /* max num. De inters.*/
    aresta=(struct edge *) malloc (np*sizeof(struct edge)); 
  }
  /* calcula y max e min e monta o vetor de arestas */
  ymax = y[0];
  ymin = y[0];
  num_arestas = 0;
  for(i=0;i<np;i++)
  {
    int i1=(i+1)%np;
    if (y[i] != y[i1])
    {
      aresta[num_arestas].y_max = MAX(y[i],y[i1]);
      aresta[num_arestas].y_min = MIN(y[i],y[i1]);
      aresta[num_arestas].delta = ((float)(x[i1]-x[i])/(float)(y[i1]-y[i]));

      if (aresta[num_arestas].y_min == y[i])
        aresta[num_arestas].xs = x[i];
      else
        aresta[num_arestas].xs = x[i1];

      ymax = MAX( ymax, aresta[num_arestas].y_max );
      ymin = MIN( ymin, aresta[num_arestas].y_min );

      num_arestas++;
    }
  }
  for(ys=ymin; ys<ymax; ys++) /* para cada linha de scan */
  {
    num_inters = 0;
    for(i=0; i<num_arestas; i++)
    {
      if (aresta[i].y_max < ys)     /* retira da lista de arestas */
      {
        aresta[i] = aresta[num_arestas-1];
        num_arestas--;
      }
     
      if((ys>=aresta[i].y_min)&&(ys<aresta[i].y_max)) /* intersepta */
      {
        vxs[num_inters] = aresta[i].xs;
        aresta[i].xs += aresta[i].delta; /* atualiza o xs */
        num_inters++;
      }
    } /* for */

    ordena(vxs,0,num_inters-1);    /* ordena as interseções */

    for(i=0;i<num_inters;i+=2)
      if (vxs[i]+1 <= vxs[i+1]);
        hline(vxs[i],vxs[i+1],ys,0xff);
  }
} /* fill */

Segue o código acima que estou usando para um probleminha de rasterização, a minha dúvida é a seguinte:

Ao compilar esse código aparece os seguintes erros: [Linker error] undefined reference to `ordena'

[Linker error] undefined reference to `hline'

[Linker error] undefined reference to `WinMain@16'

ld returned 1 exit status

o que eu entendo sobre esses erros é que faltou definir alguma variável, mas o ordena e o hline não são comando de utilização em C?

Editado Junho 2, 2011 por Durub
Adicionar tags code [Durub]

[FelipeCarioca]

ninguém com alguma dica?

[William Rodrigues]

Saudações,

As palavras ordena e hline não fazem parte das palavras reservadas da linguagem C.

Você está utilizando alguma biblioteca?

Abraços,

William Rodrigues.

[FelipeCarioca]

Olá William, obrigado por responder...

Então eu estou usando uma biblioteca do opengl:

../../lib/libgdi32.a

../../lib/libglu32.a

../../lib/libglut32.a

../../lib/libopengl32.a

Bom conversando hoje com uns amigos eles me falaram que teria que criar um objeto ordena (struct talvez) e um hline, o hline no caso seria a minha própria rasterização em si, essa eu já tenho e a coloquei para funcionar, rodou normalmente, meu único problema agora se encontra no ordena.... Não estou conseguindo criar uma estrutura correta para faze-lo funcionar!!

Abraços

[FelipeCarioca]

William,

Consegui fazer a estrutura do Ordena, depois de muito quebrar a cabeça consegui criar como eu precisava, segue o código ordena abaixo:

static void ordena(int *vxs, int left, int right)
{
     int i,j;
     int a;
     i = left;
     j = right;
     a = vxs[(left + right)/2];
       do
       {
        while (vxs[i] < a && i < right) i++;
          while (a < vxs[j] && j > left)  j--;
               if (i<=j)
               {
                 int b = vxs[i];
                 vxs[i] = vxs[j];
                 vxs[j] = b;
                 i++;j--;
               }
       } while (i<=j);
              if (left < j)  ordena(vxs,left,j);
               if (i < right) ordena(vxs,i,right);
}

Agora o que acontece é que meu código "hline" não está de acordo com o código, não consegui criar uma estrutura de rasterização exata para faze-lo rodar.