3D Objects Using Standard Perspective Projection

C program to show the projection of 3D Objects Using Standard
Perspective Projection.

Source Code:


#include<stdio.h>
#include<graphics.h>
#include<conio.h>
#include<math.h>

-----------------------  Global Declarations  -------------------------


 # define d 1.0

-----------------------  Function Prototypes  -------------------------

 void show_screen( );

 void draw_cube(int [8][3]);
 void draw_pyramid(int [5][3]);
 void get_projected_point(int&,int&,int&);
 void multiply_matrices(const float[4],const float[4][4],float[4]);

 void Line(const int,const int,const int,const int);


------------------------------  main( )  ------------------------------

 int main( )
    {
       int driver=VGA;
       int mode=VGAHI;

       initgraph(&driver,&mode,"c:/tc/bgi");

       show_screen( );

       int cube[8][3]={
			 {370,200,50},      // front left top
			 {470,200,50},      // front right top
			 {470,300,50},      // front right bottom
			 {370,300,50},      // front left bottom
			 {370,200,-50},     // back left top
			 {470,200,-50},     // back right top
			 {470,300,-50},     // back right bottom
			 {370,300,-50}      // back left bottom
		      };

       setcolor(15);
	 draw_cube(cube);

       settextstyle(0,0,1);
	 outtextxy(400,320,"Cube");

       int pyramid[5][3]={
			    {120,300,50},      //  base front left
			    {220,300,50},      //  base front right
			    {220,300,-50},     //  base back right
			    {120,300,-50},     //  base back left
			    {170,150,0}        //  top		
	 };

       setcolor(15);
	 draw_pyramid(pyramid);

       settextstyle(0,0,1);
	 outtextxy(135,320,"Pyramid");

       getch( );
       closegraph( );
       return 0;
    }

------------------------  Funcion Definitions  ------------------------
----------------------------  draw_cube( )  --------------------------

 void draw_cube(int edge_points[8][3])
    {
       for(int i=0;i<8;i++)
	  get_projected_point(edge_points[i][0],
				     edge_points[i][1],edge_points[i][2]);

	 Line(edge_points[0][0],edge_points[0][1],
				     edge_points[1][0],edge_points[1][1]);
	 Line(edge_points[1][0],edge_points[1][1],
				     edge_points[2][0],edge_points[2][1]);
	 Line(edge_points[2][0],edge_points[2][1],
				     edge_points[3][0],edge_points[3][1]);
	 Line(edge_points[3][0],edge_points[3][1],
				     edge_points[0][0],edge_points[0][1]);

	 Line(edge_points[4][0],edge_points[4][1],
				     edge_points[5][0],edge_points[5][1]);
	 Line(edge_points[5][0],edge_points[5][1],
				     edge_points[6][0],edge_points[6][1]);
	 Line(edge_points[6][0],edge_points[6][1],
				     edge_points[7][0],edge_points[7][1]);
	 Line(edge_points[7][0],edge_points[7][1],
				     edge_points[4][0],edge_points[4][1]);
	 Line(edge_points[0][0],edge_points[0][1],
				      edge_points[4][0],edge_points[4][1]);
	 Line(edge_points[1][0],edge_points[1][1],
				      edge_points[5][0],edge_points[5][1]);
	 Line(edge_points[2][0],edge_points[2][1],
				      edge_points[6][0],edge_points[6][1]);
	 Line(edge_points[3][0],edge_points[3][1],
				      edge_points[7][0],edge_points[7][1]);
    }


--------------------------  draw_pyramid( )  -------------------------


 void draw_pyramid(int edge_points[5][3])
    {
       for(int i=0;i<5;i++)
	  get_projected_point(edge_points[i][0],
				       edge_points[i][1],edge_points[i][2]);

	 Line(edge_points[0][0],edge_points[0][1],
				      edge_points[1][0],edge_points[1][1]);
	 Line(edge_points[1][0],edge_points[1][1],
				      edge_points[2][0],edge_points[2][1]);
	 Line(edge_points[2][0],edge_points[2][1],
				      edge_points[3][0],edge_points[3][1]);
	 Line(edge_points[3][0],edge_points[3][1],
				      edge_points[0][0],edge_points[0][1]);

	 Line(edge_points[0][0],edge_points[0][1],
				      edge_points[4][0],edge_points[4][1]);
	 Line(edge_points[1][0],edge_points[1][1],
				      edge_points[4][0],edge_points[4][1]);
	 Line(edge_points[2][0],edge_points[2][1],
				      edge_points[4][0],edge_points[4][1]);
	 Line(edge_points[3][0],edge_points[3][1],
				      edge_points[4][0],edge_points[4][1]);
    }


---------------------  get_projected_point( )  -----------------------


 void get_projected_point(int& x,int& y,int& z)
    {
       float Per_k[4][4]={
			    {d,0,0,0},
			    {0,d,0,0},
			    {0,0,0,1},
			    {0,0,0,d}
			 };

       float xy[4]={x,y,z,1};
       float new_xy[4]={0};

       multiply_matrices(xy,Per_k,new_xy);

       x=(int)(new_xy[0]+0.5);
       y=(int)(new_xy[1]+0.5);
       z=(int)(new_xy[2]+0.5);
    }


----------------------  multiply_matrices( )  ------------------------


 void multiply_matrices(const float matrix_1[4],
			      const float matrix_2[4][4],float matrix_3[4])
    {
       for(int count_1=0;count_1<4;count_1++)
	  {
	     for(int count_2=0;count_2<4;count_2++)
		matrix_3[count_1]+=
			   (matrix_1[count_2]*matrix_2[count_2][count_1]);
	  }
    }

--------------------------  Line( )  ------------------------


 void Line(const int x_1,const int y_1,const int x_2,const int y_2)
    {
       int color=getcolor( );

       int x1=x_1;
       int y1=y_1;

       int x2=x_2;
       int y2=y_2;

       if(x_1>x_2)
	  {
	     x1=x_2;
	     y1=y_2;

	     x2=x_1;
	     y2=y_1;
	  }

       int dx=abs(x2-x1);
       int dy=abs(y2-y1);
       int inc_dec=((y2>=y1)?1:-1);

       if(dx>dy)
	  {
	     int two_dy=(2*dy);
	     int two_dy_dx=(2*(dy-dx));
	     int p=((2*dy)-dx);

	     int x=x1;
	     int y=y1;

	     putpixel(x,y,color);

	     while(x--------------------------  show_screen( )  ---------------------------


 void show_screen( )
    {
       setfillstyle(1,1);
	 bar(180,26,445,38);

       settextstyle(0,0,1);
	 setcolor(15);

	 setcolor(11);
	   outtextxy(190,29,"Standard Perspective Projection");

	 setcolor(15);

	   for(int count=0;count<=30;count++)

	 setcolor(12);
	   outtextxy(227,450,"  Press any key to exit ");
    }