Programa para demonstrar operadores

Publicado por Perfil removido 12/04/2005

[ Hits: 5.855 ]

Download vai.c




Programa para demonstrar operadores
Cubo 3d na tela !! EXELENTE

  



Esconder código-fonte

/*** 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 IniciaModoGrafico(void) {

/* Inicializa o modo grafico. O arquivo .BGI associado ao tipo de video
    utilizado (Ex.: EGAVGA.BGI) precisa estar no subdiretorio atual. */

  int gm, gd = DETECT;

  initgraph(&gd, &gm, "");
  if (graphresult() != grOk) exit(1);   /* Encerra a execucao do programa
             se houver erro na mudanca para o modo grafico */
}

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

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, B) */

  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;

}

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

void main(void) {

  ponto p1, p2, p3, p4, q1, q2, q3, q4;
  float angulo = M_PI/20.0;
  int ch, cor = RED;

  IniciaModoGrafico();
  setbkcolor(BLUE);
  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" ***/



Scripts recomendados

Boletim Escolar Com Manipulação de Arquivo

Fatorizando um número

Despertador em C

OpenGL - Planeta em Órbita

Descompactador Simples


  

Comentários

Nenhum comentário foi encontrado.


Contribuir com comentário




Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts