Codigo Cubo 3D

sayroz · 1 de outubro de 2009

Olá estou fazendo um trabalho pra Comp. Grafica, encontrei um codigo semelhante para incrementar no trabalha pela web, porém esse codigo esta dando erro no meu compilador, vocês podem dar uma analisada e verificar!?!?!. creio eu que seja problema de configuração de compilador, o meu é DEVc++ 4.9.9.2. o erro esta em vermelho.

/*** CUBO.C ***/

#include <graphics.h>
#include <time.h>
#include <stdlib.h>
#include <dos.h>
#include <conio.h>
#include <math.h>

#define  ESC            27
#define  SetaPCima      72
#define  SetaPBaixo     80
#define  SetaPEsquerda  75
#define  SetaPDireita   77
#define  TeclaF1        59
#define  TeclaF2        60
#define  TeclaF3        61
#define  TeclaF4        62
#define  TeclaF5        63

/* ----------------------------------------------------------------------- */

float A, B,                  /* Coordenadas do centro da tela                */
     TAM = 70,               /* Coeficiente de ampliacao                     */
     nu = 40,                /* Quant. subdivisoes no dominio da variavel u  */
     nv = 40,                /* Quant. subdivisoes no dominio da variavel v  */
     teta = M_PI/7,
     fi = M_PI/7,
     proj_X, proj_Y;         /* Coordenadas da projecao do ponto (x, y, z)   */

typedef struct { float x, y, z; } ponto;

typedef struct { float x, y; } ponto_plano;

/* ------------------------------------------------------------------------- */

void Reta(int x0, int y0, int x1, int y1, int cor) {

/* Desenha a reta (x0, y0) - (x1, y1) usando o algoritmo de Bresenham */

  int aux, primeiro_octante, dx, dy, incrE, incrNE,
      X0, X1, Y0, Y1, d, x, y, inclinacao_negativa;

  if (x0 > x1) {
    aux = x0; x0 = x1; x1 = aux;
    aux = y0; y0 = y1; y1 = aux;
  }

  X0 = x0; X1= x1; Y0 = y0; Y1 = y1;

  inclinacao_negativa = (y0 > y1);
  if (inclinacao_negativa) {
    aux = y0; y0 = y1; y1 = aux;
  }

  primeiro_octante = (y1 - y0 <= x1 - x0);
  if (!primeiro_octante) {
    aux = x0; x0 = y0; y0 = aux;
    aux = x1; x1 = y1; y1 = aux;
  }

  dx = x1 - x0;
  dy = y1 - y0;
  d = 2*dy - dx;
  incrE = 2*dy;
  incrNE = 2*(dy - dx);
  x = x0;
  y = y0;

  if (primeiro_octante)
    if (inclinacao_negativa)
      putpixel(x, Y1 + Y0 - y, cor);
    else
      putpixel(x, y, cor);
  else
    if (inclinacao_negativa)
      putpixel(X1 + X0 - y, x, cor);
    else
      putpixel(y, x, cor);

  while (x < x1) {

    if (d < 0) {
      d = d + incrE;
      x = x + 1;
    } else {
      d = d + incrNE;
      x = x + 1;
      y = y + 1;
    }

    if (primeiro_octante)
      if (inclinacao_negativa)
	putpixel(x, Y1 + Y0 - y, cor);
      else
	putpixel(x, y, cor);
    else
      if (inclinacao_negativa)
	putpixel(X1 + X0 - y, x, cor);
      else
	putpixel(y, x, cor);

  }
}

/* ----------------------------------------------------------------------- */



/* ------------------------------------------------------------------------ */

void ProjetaPonto(float x, float y, float z) {

/* Calcula as coordenadas do ponto (x, y, z) no plano de projecao. E' feita
   uma ampliacao de TAM unidades e uma translacao da origem  do  sistema de
   coordenadas do plano de projecao para o ponto (A,  */

  float X, Y;

  /* Gira (x, y, z) de teta radianos em torno do eixo z e de fi radianos
     em torno do eixo y seguida de uma projecao ortografica na direcao x */

  X = y*cos(teta) + x*sin(teta);
  Y = z*cos(fi) + x*cos(teta)*sin(fi) - y*sin(fi)*sin(teta);

  /* Ampliacao e translacao de (X, Y) */
  proj_X = A + X*TAM;
  proj_Y = B - Y*TAM;
}

/* ------------------------------------------------------------------------- */

void DesenhaCubo(ponto *p1, ponto *p2, ponto *p3, ponto *p4,
		 ponto *q1, ponto *q2, ponto *q3, ponto *q4, int cor) {

  ponto_plano P1, P2, P3, P4, Q1, Q2, Q3, Q4;

  ProjetaPonto(p1->x, p1->y, p1->z); P1.x = proj_X, P1.y = proj_Y;
  ProjetaPonto(p2->x, p2->y, p2->z); P2.x = proj_X, P2.y = proj_Y;
  ProjetaPonto(p3->x, p3->y, p3->z); P3.x = proj_X, P3.y = proj_Y;
  ProjetaPonto(p4->x, p4->y, p4->z); P4.x = proj_X, P4.y = proj_Y;

  ProjetaPonto(q1->x, q1->y, q1->z); Q1.x = proj_X, Q1.y = proj_Y;
  ProjetaPonto(q2->x, q2->y, q2->z); Q2.x = proj_X, Q2.y = proj_Y;
  ProjetaPonto(q3->x, q3->y, q3->z); Q3.x = proj_X, Q3.y = proj_Y;
  ProjetaPonto(q4->x, q4->y, q4->z); Q4.x = proj_X, Q4.y = proj_Y;

  Reta(P1.x, P1.y, P2.x, P2.y, cor);
  Reta(P2.x, P2.y, P3.x, P3.y, cor);
  Reta(P3.x, P3.y, P4.x, P4.y, cor);
  Reta(P4.x, P4.y, P1.x, P1.y, cor);

  Reta(Q1.x, Q1.y, Q2.x, Q2.y, cor);
  Reta(Q2.x, Q2.y, Q3.x, Q3.y, cor);
  Reta(Q3.x, Q3.y, Q4.x, Q4.y, cor);
  Reta(Q4.x, Q4.y, Q1.x, Q1.y, cor);

  Reta(Q1.x, Q1.y, P1.x, P1.y, cor);
  Reta(Q2.x, Q2.y, P2.x, P2.y, cor);
  Reta(Q3.x, Q3.y, P3.x, P3.y, cor);
  Reta(Q4.x, Q4.y, P4.x, P4.y, cor);

}

/* ------------------------------------------------------------------------- */

void GiraCubo_z(ponto *p1, ponto *p2, ponto *p3, ponto *p4,
		 ponto *q1, ponto *q2, ponto *q3, ponto *q4, float angulo) {

  float x, y;
  float cosseno, seno;

  cosseno = cos(angulo), seno = sin(angulo);

  x = p1->x * cosseno - p1->y * seno;
  y = p1->x * seno + p1->y * cosseno;
  p1->x = x, p1->y = y;
  x = p2->x * cosseno - p2->y * seno;
  y = p2->x * seno + p2->y * cosseno;
  p2->x = x, p2->y = y;
  x = p3->x * cosseno - p3->y * seno;
  y = p3->x * seno + p3->y * cosseno;
  p3->x = x, p3->y = y;
  x = p4->x * cosseno - p4->y * seno;
  y = p4->x * seno + p4->y * cosseno;
  p4->x = x, p4->y = y;

  x = q1->x * cosseno - q1->y * seno;
  y = q1->x * seno + q1->y * cosseno;
  q1->x = x, q1->y = y;
  x = q2->x * cosseno - q2->y * seno;
  y = q2->x * seno + q2->y * cosseno;
  q2->x = x, q2->y = y;
  x = q3->x * cosseno - q3->y * seno;
  y = q3->x * seno + q3->y * cosseno;
  q3->x = x, q3->y = y;
  x = q4->x * cosseno - q4->y * seno;
  y = q4->x * seno + q4->y * cosseno;
  q4->x = x, q4->y = y;
}

/* ------------------------------------------------------------------------- */

void GiraCubo_y(ponto *p1, ponto *p2, ponto *p3, ponto *p4,
		 ponto *q1, ponto *q2, ponto *q3, ponto *q4, float angulo) {

  float x, z;
  float cosseno, seno;

  cosseno = cos(angulo), seno = sin(angulo);

  x = p1->x * cosseno - p1->z * seno;
  z = p1->x * seno + p1->z * cosseno;
  p1->x = x, p1->z = z;
  x = p2->x * cosseno - p2->z * seno;
  z = p2->x * seno + p2->z * cosseno;
  p2->x = x, p2->z = z;
  x = p3->x * cosseno - p3->z * seno;
  z = p3->x * seno + p3->z * cosseno;
  p3->x = x, p3->z = z;
  x = p4->x * cosseno - p4->z * seno;
  z = p4->x * seno + p4->z * cosseno;
  p4->x = x, p4->z = z;

  x = q1->x * cosseno - q1->z * seno;
  z = q1->x * seno + q1->z * cosseno;
  q1->x = x, q1->z = z;
  x = q2->x * cosseno - q2->z * seno;
  z = q2->x * seno + q2->z * cosseno;
  q2->x = x, q2->z = z;
  x = q3->x * cosseno - q3->z * seno;
  z = q3->x * seno + q3->z * cosseno;
  q3->x = x, q3->z = z;
  x = q4->x * cosseno - q4->z * seno;
  z = q4->x * seno + q4->z * cosseno;
  q4->x = x, q4->z = z;

}

/* ------------------------------------------------------------------------- */



 [COLOR="red"]void main(void)//erro
[/COLOR]  {

  ponto p1, p2, p3, p4, q1, q2, q3, q4;
  float angulo = M_PI/20.0;
 [COLOR="red"] int ch, cor = RED;//erro
[/COLOR] 

  IniciaModoGrafico();
 [COLOR="red"]setbkcolor(BLUE); //erro[/COLOR] 
  A = getmaxx()/2, B = getmaxy()/2;

  p1.x = -1, p1.y = -1, p1.z = -1;
  p2.x = 1, p2.y = -1, p2.z = -1;
  p3.x = 1, p3.y = 1, p3.z = -1;
  p4.x = -1, p4.y = 1, p4.z = -1;

  q1.x = -1, q1.y = -1, q1.z = 1;
  q2.x = 1, q2.y = -1, q2.z = 1;
  q3.x = 1, q3.y = 1, q3.z = 1;
  q4.x = -1, q4.y = 1, q4.z = 1;

  do {

    DesenhaCubo(&p1, &p2, &p3, &p4, &q1, &q2, &q3, &q4, cor);
    ch = getch();

    if (ch == 0) {
      ch = getch();
      DesenhaCubo(&p1, &p2, &p3, &p4, &q1, &q2, &q3, &q4, 0);

      switch (ch) {
	case SetaPDireita:
	  GiraCubo_z(&p1, &p2, &p3, &p4, &q1, &q2, &q3, &q4, -angulo); break;
	case SetaPEsquerda:
	  GiraCubo_z(&p1, &p2, &p3, &p4, &q1, &q2, &q3, &q4, angulo); break;
	case SetaPCima:
	  GiraCubo_y(&p1, &p2, &p3, &p4, &q1, &q2, &q3, &q4, -angulo); break;
	case SetaPBaixo:
	  GiraCubo_y(&p1, &p2, &p3, &p4, &q1, &q2, &q3, &q4, angulo); break;
	case TeclaF1:
	  cor = 1 + (cor + 1) % 15; break;
	case TeclaF2:
	  TAM *= 1.25; break;
	case TeclaF3:
	  TAM /= 1.25; break;
	case TeclaF4:
	  teta *= 1.25; break;
	case TeclaF5:
	  fi *= 1.25; break;
      }

    }
  } while (ch != ESC);

  closegraph();
}

/* ------------------------------------------------------------------------- */

/*** FIM DE "CUBO.C" ***/
//linha 301 erro: stray "\26' in program

Renan.mmerlo · 1 de outubro de 2009

amigo,

me parece que o que está errado é a definição da cor, RED e BLUE

verifique isso, acho que você deve defini-las de uma outra forma ou usar um #DEFINE la em cima para definir a palavra RED como o codigo utilizado para a cor vermelha nakela funcao...nao seria necessario utilizar o codigo da cor invés de seu nome (RED,BLUE,etc)?

abraço

sayroz · 2 de outubro de 2009

amigo,
me parece que o que está errado é a definição da cor, RED e BLUE

verifique isso, acho que você deve defini-las de uma outra forma ou usar um #DEFINE la em cima para definir a palavra RED como o codigo utilizado para a cor vermelha nakela funcao...nao seria necessario utilizar o codigo da cor invés de seu nome (RED,BLUE,etc)?

abraço

Parte grafica sou negação, Salvo se me engano, mas as palavras RED BLUE acho q seriam pre-definidas na biblioteca graphics.h (nao tenho certeza).

mas contudo estou aberto a sugestoes, se alguem souber como posso definir essas cores na função agradeço!