Drop Word by Word

#include<graphics.h>
#include<conio.h>
#include<stdlib.h>
#include<stdio.h>
#include<dos.h>
#include<iostream.h>
#include<string.h>
void main()
{
int gd=DETECT,gm,i,j,k,l,x,y;
char s[100]=" ",s1[100]=" ";
initgraph(&gd,&gm," ");
cout<<"Enter the string:";
gets(s);
outtextxy(40,40,s);
y=50+textheight(s);
setviewport(45,y,500,400,0);
l=strlen(s);
s[l]='\0';
j=0;
for(i=0;i<=l;i++)
{s1[j]=s[i];
if(s[i]==' '||s[i]=='\0')
{
for(y=50;y<=350;y+=30)
{
outtextxy(x,y,s1);
delay(100);
clearviewport();
}
x+=textwidth(s1);
for(k=0;k<j;k++)
s1[k]='\0';
j=-1;
}
j++;
}
getch();
}

Rain Scenery

#include<graphics.h>

#include<conio.h>

#include<dos.h>

#include<stdlib.h>

class Rain

{

public:

int a,b;

public:

void background();

void rainfall();

};

void Rain::background()

{

setfillstyle(1,WHITE);

fillellipse(100,50,50,50);

      line(90,420,90,390);

line(90,390,95,420);

setfillstyle(1,WHITE);

bar(0,450,640,490);

setfillstyle(1,BROWN);

bar(500,230,520,450);

{

setcolor(2);

arc(490,240,0,180,25);

arc(530,240,0,180,25);

arc(490,235,0,180,25);

arc(490,230,0,170,25);

arc(530,235,0,180,25);

arc(530,230,0,180,25);

}

            setcolor(BROWN);

             line(10,400,90,400);

             line(10,400,25,460);

             line(25,460,80,460);

             line(90,400,80,460);

             line(50,400,50,300);

             setcolor(YELLOW);

             setfillstyle(1,YELLOW);

             fillellipse(50,289,10,10);

             setfillstyle(1,5);

             fillellipse(50,270,8,8);

             fillellipse(39,275,8,8);

             fillellipse(32,283,8,8);

             fillellipse(33,293,8,8);

             fillellipse(42,302,8,8);

             fillellipse(55,307,8,8);

             fillellipse(64,300,8,8);

             fillellipse(68,287,8,8);

             fillellipse(63,276,8,8);

}

void Rain::rainfall()

{

      for(int i=0;i<=600;i++)

                  {

                              if(i==300)

                              {

                                          cleardevice();

                                          setbkcolor(8);

                                          background();

                              }

                              setcolor(WHITE);

                              a=random(650);

                              b=random(650);

                              gotoxy(a,b);

                               line(a,b,a+3,b+3);

                              delay(10);

                   }

 }

void main()

{

int gdriver=DETECT,gmode;

initgraph(&gdriver, &gmode, "");

Rain objr;

objr.background();

objr.rainfall();

getch();

closegraph();

}

3D-Rotation

 # include <stdio.h>
 # include <graphics.h>
 # include  <conio.h>
 # include <math.h>
 #include<stdlib.h>
 int ch;
 int i,j,k,angle;
 void x_axis( int [5][3], int);
 void y_axis( int [5][3], int);
 void z_axis( int [5][3], int);
 void mult( int[5][3],float[4][4],float[5][3]);
 float y[4][4],x[4][4],z[4][4];
 void draw(int [5][3]);
 int s[5][3]={
        {40,130,50},      //  The co-ordinates
        {120,130,50},      //  to make a
        {160,90,-50},    //  pyramid
        {70,90,-50},   
        {80,20,0}       
         };
 float matrix_a;
 float matrix_b;
 float c[4][3];
 void main( )
 {
    int driver=DETECT,mode;
    initgraph(&driver,&mode,"");
    draw(s);
    printf("\n1.X_axis,2.Y_axis,3.Z_axis");
    printf("\nEnter ur choice:");
    scanf("%d",&ch);
    printf("Enter the angle:");
    scanf("%d",&angle);
    cleardevice();
    switch(ch)
    {
          case 1:
              x_axis(s,angle);
              break;
          case 2:
              y_axis(s,angle);
              break;
          case 3:
              z_axis(s,angle);
              break;
          default:
              exit(0);
    }
  getch();
  }
void x_axis( int p[5][3], int theta)
{
    float angle=(theta*(3.14/180));
    for(i=0;i<4;i++)
        for(j=0;j<4;j++)
            x[i][j]=0;
    //Matrix Initialization
    x[1][1]=cos(angle);x[1][2]=-sin(angle);
    x[2][1]=sin(angle);x[2][2]=cos(angle);
    x[0][0]=1;

    mult(p,x,c);

    for(i=0;i<5;i++)
        for(j=0;j<3;j++)
             p[i][j]=(int)(c[i][j]+0.5);
    draw(p);
}
void y_axis( int p[5][3], int theta)
{
    float angle=(theta*(3.14/180));
    for(i=0;i<4;i++)
        for(j=0;j<4;j++)
            y[i][j]=0;
    y[0][0]=cos(angle);y[0][1]=-sin(angle);
    y[2][0]=sin(angle);y[2][1]=cos(angle);
    y[1][1]=1;

    mult(p,y,c);
    for(i=0;i<5;i++)
        for(j=0;j<3;j++)
            p[i][j]=(int)(c[i][j]+0.5);
    draw(p);
}
void z_axis( int p[5][3], int theta)
{
float angle=(theta*(3.14/180));
    for(i=0;i<4;i++)
        for(j=0;j<4;j++)
            z[i][j]=0;
    z[0][0]=cos(angle);z[0][1]=-sin(angle);
    z[1][0]=sin(angle);z[1][1]=cos(angle);
    z[2][2]=1;

    mult(p,z,c);
    for(i=0;i<5;i++)
        for(j=0;j<3;j++)
             p[i][j]=(int)(c[i][j]+0.5);
    draw(p);
}


 void mult( int matrix_1[5][3],float matrix_2[4][4],float matrix_3[5][3])
    {
      for(i=0;i<5;i++)
      {
    for(j=0;j<3;j++)
    for( k=0;k<3;k++)
    matrix_3[i][j]+=(matrix_1[i][k]*matrix_2[k][j]);
      }
    }


 void draw(int points[5][3])
    {
      int a[5][3];

      for(i=0;i<5;i++)
      {
    a[i][0]=points[i][0];
    a[i][1]=points[i][1];
    a[i][2]=points[i][2];
     a[i][1]+=240;
     a[i][0]+=240;
      }

      line(a[0][0],a[0][1],a[1][0],a[1][1]);
      line(a[1][0],a[1][1],a[2][0],a[2][1]);
      line(a[2][0],a[2][1],a[3][0],a[3][1]);
      line(a[3][0],a[3][1],a[0][0],a[0][1]);

      line(a[0][0],a[0][1],a[4][0],a[4][1]);
      line(a[1][0],a[1][1],a[4][0],a[4][1]);
      line(a[2][0],a[2][1],a[4][0],a[4][1]);
      line(a[3][0],a[3][1],a[4][0],a[4][1]);
    }

3D-Translation & Scaling

#include<stdio.h>
#include<conio.h>
#include<math.h>
#include<process.h>
#include<graphics.h>
int x1,x2,y1,y2,mx,my,depth,t;
int tx,ty;
void draw();
void trans();
void scale();
void main()
{
    int gd=DETECT,gm,c;
    initgraph(&gd,&gm,"");
    printf("\n3D Translation & Scaling\n\n");
    printf("\nEnter top value(x1,y1):");
    scanf("%d%d",&x1,&y1);
    printf("Enter right bottom value(x2,y2):");
    scanf("%d%d",&x2,&y2);
    depth=(x2-x1)/4;
    draw();
    getch();
    while(1)
    {
    printf("\nPress 1 to translatio,2 to scaling:");
    scanf("%d",&t);
    switch(t)
    {
    case 1:
    trans();
    break;
    case 2:
    scale();
    break;
    default:
    exit(0);
    }
    }
}
void draw()
{
    cleardevice();
    bar3d(x1,y1,x2,y2,depth,1);
}
void trans()
{
    int a1,b1,a2,b2,dep;
    cleardevice();
    printf("Enter the translation vector");
    scanf("%d%d",&tx,&ty);
    a1=x1+tx;
    a2=x2+tx;
    b1=y1+ty;
    b2=y2+ty;
    dep=abs((a1-a2)/4);
    draw();
    sleep(2);
    cleardevice();
    bar3d(a1,b1,a2,b2,dep,1);
    setcolor(5);
    getch();
}

void scale()
{
    int a1,b1,a2,b2,dep;
    cleardevice();
    printf("Enter the scaling factor");
    scanf("%d%d",&tx,&ty);
    a1=x1*tx;
    a2=x2*tx;
    b1=y1*ty;
    b2=y2*ty;
    dep=abs((a1-a2)/4);
    draw();
    sleep(2);
    cleardevice();
    bar3d(a1,b1,a2,b2,dep,1);
    setcolor(5);
}

Cohen Sutherland Line Clipping Algorithm

#include<stdio.h>
#include<conio.h>
#include<math.h>
#include<graphics.h>
int pixels[2][4];
float xn,yn,xn1,yn1,m;
int xmin,ymin,xmax,ymax,x1,y1,x2,y2;
//int ch,n;
void encode(int x1,int y1,int x2,int y2)
{
    int i,j,f=1;
    for(i=0;i<2;i++)
        for(j=0;j<4;j++)
            pixels[i][j]=0;
    if(y1>ymax)
        pixels[0][0]=1;
    if(y1<ymin)
        pixels[0][1]=1;
    if(x1>xmax)
        pixels[0][2]=1;
    if(x1<xmin)
        pixels[0][3]=1;
    if(y2>ymax)
        pixels[1][0]=1;
    if(y2<ymin)
        pixels[1][1]=1;
    if(x2>xmax)
        pixels[1][2]=1;
    if(x2<xmin)
        pixels[1][3]=1;
    for(j=0;j<4;j++)
    {
        if((pixels[0][j]==0)&& (pixels[1][j]==0))
            continue;
        if((pixels[0][j]==1)&& (pixels[1][j]==1))
        {
            f=2;
            break;
        }
        f=3;
    }
    switch(f)
    {
    case 1:
        cleardevice();
        rectangle(xmin,ymin,xmax,ymax);
        line(x1,y1,x2,y2);
        break;
    case 2:
        printf("\nThe line is completely outside");
        break;
    case 3:
        m=(y2-y1)/(x2-x1);
        xn=x1;xn1=x2;
        yn=y1;yn1=y2;
        if(pixels[0][0]==1)
        {
            xn=x1+(ymax-y1)/m;
            yn=ymax;
        }
        if(pixels[0][1]==1)
        {
            xn=x1+(ymin-y1)/m;
            yn=ymin;
        }
        if(pixels[0][2]==1)
        {
            yn=y1+(xmax-x1)*m;
            xn=xmax;
        }
        if(pixels[0][3]==1)
        {
            yn=y1+(xmin-x1)*m;
            xn=xmin;
        }
        if(pixels[1][0]==1)
        {
            xn1=x2+(ymax-y2)/m;
            yn1=ymax;
        }
        if(pixels[1][1]==1)
        {
            xn1=x2+(ymin-y2)/m;
            yn1=ymin;
        }
        if(pixels[1][2]==1)
        {
            yn1=y2+(xmax-x2)*m;
            xn1=xmax;
        }
        if(pixels[1][3]==1)
        {
            yn1=y2+(xmin-x2)*m;
            xn1=xmin;
        }
        cleardevice();
        rectangle(xmin,ymin,xmax,ymax);
        line(xn,yn,xn1,yn1);
        break;
        }
}
void main()
{
int gd=DETECT,gm,i,j;
initgraph(&gd,&gm,"t:\\bgi");
printf("\nEnter the co-ordinates for the window:");
scanf("%d%d%d%d",&xmin,&ymin,&xmax,&ymax);
rectangle(xmin,ymin,xmax,ymax);
printf("\nenter the line co-ordinates:");
scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
line(x1,y1,x2,y2);
sleep(5);
encode(x1,y1,x2,y2);
printf("\nLine After Clipping");
getch();
//closegraph();
}