/******************************************************
*          SURFACES OF PARAMETRIC EQUATIONS           *
* --------------------------------------------------- *
* This program draws 3D surfaces defined by equations *
* x = f(u,v), y = g(u,v), z = h(u,v)  by using unit   *
* graph_3d.pas.                                       *
* --------------------------------------------------- *
* SAMPLE RUN:                                         *
*                                                     *
*       Surface Data:                                 *
*       =============                                 *
*                                                     *
*   Surface Type: 1. Ellipsoid                        *
*                 2. Sphere                           *
*                 3. Torus                            *
*                 4. Hyperboloid                      *
*   Your choice(1 to 4): 1                            *
*                                                     *
*   Projection type (1:perspective 2:parallel)        *
*   Your choice(1 or 2): 2                            *
*                                                     *
*   Value of distance to screen: 30                   *
*   Value of angle Theta (deg.): 60                   * 
*   Value of angle Phi   (deg.): 30                   *
*                                                     *
*   Input U begin, U end and step: -1.57 1.57 0.2     *
*   Input V begin, V end and step: -3.14 3.14 0.2     *
*   (An ellipsoid is displayed in parralel mode).     *
*                                                     *
*   Your choice(1 to 4): 2                            *
*                                                     *
*   Value of distance to screen: 25                   *
*   Value of angle Theta (deg.): 45                   * 
*   Value of angle Phi   (deg.): 30                   *
*                                                     *
*   Input U begin, U end and step: -3.14 3.14 0.2     *
*   Input V begin, V end and step: -3.14 3.14 0.2     *
*   (A shere is displayed in parralel mode).          *
*                                                     *
*   Your choice(1 to 4): 3                            *
*                                                     *
*   Value of distance to screen: 20                   *
*   Value of angle Theta (deg.): 30                   * 
*   Value of angle Phi   (deg.): 30                   *
*                                                     *
*   Input U begin, U end and step: -3.14 3.14 0.4     *
*   Input V begin, V end and step: -3.14 3.14 0.2     *
*   (A torus is displayed in parralel mode).          *
*                                                     *
*   Your choice(1 to 4): 4                            *
*                                                     *
*   Value of distance to screen: 100                  *
*   Value of angle Theta (deg.): 60                   * 
*   Value of angle Phi   (deg.): 30                   *
*                                                     *
*   Input U begin, U end and step: -1  1  0.1         *
*   Input V begin, V end and step: -1  1  0.1         *
*   (An hyperpoloid is displayed in parralel mode).   *
*                                                     *
*   Your choice(1 to 4): 3                            *
*                                                     *
*   Projection type (1:perspective 2:parallel)        *
*   Your choice(1 or 2): 1                            *
*                                                     *
*   Value of Rho               : 150                  *
*   Value of distance to screen: 2500                 *
*   Value of angle Theta (deg.): 30                   * 
*   Value of angle Phi   (deg.): 30                   *
*                                                     *
*   Input U begin, U end and step: -3.14 3.14 0.4     *
*   Input V begin, V end and step: -3.14 3.14 0.2     *
*   (A torus is displayed in perspective mode).       *
*                                                     *
* --------------------------------------------------- *
* Ref.: "Graphisme dans le plan et dans l'espace en   *
*        Turbo Pascal 4.0 By R. Dony, MASSON Paris,   *
*        1990" [BIBLI 12].                            *
*                                                     *
*       C++ Release in API style By J-P Moreau, Paris.*
*                     (www.jpmoreau.fr)               *
*******************************************************
NOTE: In perspective mode, for a given rho value, you
can increase the dimension of object by increasing the
value of distance to screen (see last sample run).
-----------------------------------------------------*/
#include <windows.h>
#include <stdio.h>
#include <math.h>

#define  perspective  1
#define  parallele    2

HDC  hdc;
RECT rect;

//Functions used here of module Graph_3D

//define drawing zone (ix1,ix2,iy1,iy2) in screen pixels
void Cloture(int,int,int,int);
//draw a frame around drawing zone (optional) 
void Bordure();
//MoveTo(x,y,z) in physical coordinates (pen is up)
void MoveXYZ(double,double,double);
//LineTo(x,y,z) in physical coordinates (pen is down)
void LineXYZ(double,double,double);
//Draw axes X,Y,Z
void Axes(double,double,double);
//calculate auxiliary projection variables
void InitProj(void);


//"home made" graphic commands for hdc environment used by above functions
void DrawPixel(int ix,int iy) {
  //sorry, no other available command found
  Rectangle(hdc,rect.left+ix,rect.top+iy,
	            rect.left+ix+2,rect.top+iy+1);
}

void Swap(int *i1,int *i2) {
  int it;
  it=*i1; *i1=*i2; *i2=it;
}

void DrawLine(int ix1,int iy1,int ix2,int iy2) {
  int i,il,ix,iy;
  float dx,dy;
  if (ix2<ix1) {
	Swap(&ix1,&ix2); Swap(&iy1,&iy2);
  }
  il=(int) sqrt((ix2-ix1)*(ix2-ix1)+(iy2-iy1)*(iy2-iy1));
  dx=(float) (ix2-ix1)/il; 
  dy=(float) (iy2-iy1)/il;
  ix=ix1; iy=iy1;
  for (i=1;i<il+1; i++) {
	DrawPixel(ix,iy);
	ix=(int) (ix1+i*dx); 
	iy=(int) (iy1+i*dy);
  }
}

void OutText(int ix,int iy,char *s) {
  RECT rct;
  rct.left=ix; rct.right=ix+10*strlen(s);
  rct.top=iy-5; rct.bottom=iy+15;
  DrawText(hdc, s, -1, &rct,
                DT_SINGLELINE | DT_CENTER | DT_VCENTER);
}

//***************************************
//global variables of SurfPara program
double udebut,ufin,du;
double vdebut,vfin,dv;
double A,B,C;
int  type;


double FX(double u,double v) {
  switch(type) {
    case 1: return A*cos(u)*cos(v); break;       //Ellipsoid
    case 2: return A*cos(u)*cos(v); break;       //sphere
    case 3: return (A+B*cos(u))*cos(v); break;   //torus
    case 4: return u;                            //hyperboloid
    default:return 0;
  }
}

double FY(double u,double v) {
  switch(type) {
    case 1: return B*cos(u)*sin(v); break;       //Ellipsoïd
    case 2: return B*cos(u)*sin(v); break;       //sphere
    case 3: return (A+B*cos(u))*sin(v); break;   //torus
    case 4: return v;                            //hyperboloid
    default:return 0;
  }
}

double FZ(double u,double v) {
  switch(type) {
    case 1: return C*sin(u); break;         //Ellipsoid
    case 2: return C*sin(u); break;         //sphere
    case 3: return C*sin(u); break;         //torus
    case 4: return u*u-v*v;                 //hyperboloid
    default:return 0;
  }
}

void Data() {
  int proj;
  double PI=3.1415926535;
  extern MaxX, projection;
  extern double de,phi,rho,theta;
// Surface Data:
// =============
// Surface Type: 1. Ellipsoid
//               2. Sphere
//               3. Torus
//               4. Hyperboloid
  type=3;
// Projection type (1:perspective 2:parallel)
  proj=2;
  if (proj==1) {
    projection=perspective;
    rho=150;
    de=MaxX*4;
  }
  else {
    projection=parallele;
    rho=1e20;
    de=MaxX/30;
  }
  switch(type) {
    case 1: theta=60; phi=30; de*=1.5;
	        udebut=0; ufin=2*PI; du=PI/20;
            vdebut=0; vfin=2*PI; dv=PI/20;
	        A=6.0; B=3.0; C=2.0; break;
    case 2: theta=60; phi=30; de*=1.5;
	        udebut=0; ufin=2*PI; du=PI/20;
            vdebut=0; vfin=2*PI; dv=PI/20;
			A=4.0; B=4.0; C=4.5; break;
    case 3: theta=phi=30; 
	        udebut=0; ufin=2*PI; du=PI/10;
            vdebut=0; vfin=2*PI; dv=PI/20;
	        A=6.0; B=3.0; C=3.0; break;
    case 4: theta=60; phi=30; de*=6;
	        udebut=-1; ufin=1; du=0.1;
            vdebut=-1; vfin=1; dv=0.1;
			A=1.0; B=1.0; C=1.0;
  }
} //Data()

void CourbesEnU() {
  double u,v,x,y,z;
  u=udebut;
  while (u <= ufin) {
    v=vdebut;
    x=FX(u,v);
    y=FY(u,v);
    z=FZ(u,v);
    MoveXYZ(x,y,z);
    while (v <= vfin) {
      x=FX(u,v);
      y=FY(u,v);
      z=FZ(u,v);
      LineXYZ(x,y,z);
      v += dv;
    }
    u += du;
  }
}

void CourbesEnV() {
  double u,v,x,y,z;
  v=vdebut;
  while (v <= vfin) {
    u=udebut;
    x=FX(u,v);
    y=FY(u,v);
    z=FZ(u,v);
    MoveXYZ(x,y,z);
    while (u <= ufin) {
      x=FX(u,v);
      y=FY(u,v);
      z=FZ(u,v);
      LineXYZ(x,y,z);
      u += du;
    }
    v += dv;
  }
}

void Affiche() {
  extern int MaxY,projection;
  extern double de,phi,rho,theta;
  char ch[100],t[30];
  if (projection == parallele) strcpy(ch," Rho=Infinity");
  else sprintf(ch,"Rho=%4.1f",rho);
  sprintf(t," Theta=%4.1f",theta); strcat(ch,t);
  sprintf(t," Phi=%4.1f",phi); strcat(ch,t);
  sprintf(t," Screen dist.=%4.1f ",de); strcat(ch,t);
  OutText(-20,10,ch);
  sprintf(t," U=[ %5.2f,",udebut); strcpy(ch,t);
  sprintf(t," %5.2f ] Step=%5.2f",ufin,du); strcat(ch,t);
  OutText(20,30,ch);  
  sprintf(t," V=[ %5.2f,",vdebut); strcpy(ch,t);
  sprintf(t," %5.2f ]  Step=%5.2f",vfin,dv); strcat(ch,t);
  OutText(17,50,ch);  
  switch(type) {
    case 1: strcpy(t," Ellipsoid "); break;
    case 2: strcpy(t," Sphere "); break;
    case 3: strcpy(t," Torus "); break;
    case 4: strcpy(t," Hyperboloid ");
  }
  OutText(450,MaxY-20,t); 
}

void SurfPara()  {
  extern int MaxX, MaxY;
  //define client drawing zone in screen pixels
  MaxX=(rect.right-rect.left);
  MaxY=(rect.bottom-rect.top);
  Data();
  Cloture(0,MaxX,0,MaxY);
  Bordure();
  InitProj();
  switch(type) {
  case 1: Axes(1.25*A,3.75*B,3*C);  break;
  case 2: Axes(1.5*A,1.85*B,1.25*C); break;
  case 3: Axes(2.75*A,3.75*B,3*C);  break;
  case 4: Axes(2*A,2.5*B,1.5*C);
  }
  CourbesEnU();
  CourbesEnV();
  Affiche();
}

//Handle window Paint and Destroy messages
long FAR PASCAL /*_export*/ WndProc(HWND hwnd,
    UINT message, UINT wParam, LONG lParam) 
{
    PAINTSTRUCT ps;
    
    switch (message) {
        case WM_PAINT:
			hdc = BeginPaint(hwnd, &ps);
			GetClientRect(hwnd, &rect);

            SurfPara();
               
            EndPaint(hwnd, &ps);
            return 0;
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
    }
    return DefWindowProc(hwnd, message, wParam, lParam);
}

// main program
int PASCAL WinMain(HANDLE hInstance, HANDLE hPrevInstance,
    LPSTR lpszCmdParam, int nCmdShow)
{
    static char szAppName[] = "SurfPara";
    HWND        hwnd;
    MSG         msg;
    WNDCLASS    wndclass;

    if (!hPrevInstance) {
        wndclass.style         = CS_HREDRAW | CS_VREDRAW;
        wndclass.lpfnWndProc   = WndProc;
        wndclass.cbClsExtra    = 0;
        wndclass.cbWndExtra    = 0;
        wndclass.hInstance     = hInstance;
        wndclass.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
        wndclass.hCursor       = LoadCursor(NULL, IDC_ARROW);
        wndclass.hbrBackground = GetStockObject(WHITE_BRUSH);
        wndclass.lpszMenuName  = NULL;
        wndclass.lpszClassName = szAppName;

        RegisterClass(&wndclass);
    }

    hwnd = CreateWindow(szAppName,  // window class name
        " PARAMETRIC SURFACES",     // window caption
        WS_OVERLAPPEDWINDOW,        // window style                       
        CW_USEDEFAULT,              // initial x position
        CW_USEDEFAULT,              // initial y position
        CW_USEDEFAULT,              // initial x size
        CW_USEDEFAULT,              // initial y size
        NULL,                       // parent window handle
        NULL,                       // window menu handle
        hInstance,                  // program instance handle
        NULL);                      // creation parameters

   ShowWindow(hwnd, nCmdShow);
   UpdateWindow(hwnd);

   while (GetMessage(&msg, NULL, 0, 0)) {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
   }
   return msg.wParam;
}

//end of file surfpara.cpp