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

• Download vai.c
• Enviar nova versão

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" ***/


Comando strlen

Como verificar a validade de um CPF

Algoritmo de Dijkstra

Integração numérica - Método da Quadratura Gaussiana

[C] Agenda - LDE

Nenhum comentário foi encontrado.