/*******************************************************************
*                          FRACTAL CURVES                          *
* ---------------------------------------------------------------- *
* This program generates a fractal curve using the formula:        *
*              x' = x(x2-x1) - y(y2-y1) + x1                       *
*              y' = x(y2-y1) + y(x2-x1) + y1                       *
* using a basis composed of segments (such as a single segment, a  *
* square, a triangle etc.) forming a closed figure, and a genera-  *
* trix simple open figure, such as two bits of line at 60°.        *
* The basis is memorized by its summit coordinates stored in two   *
* tables Xbasis and Ybasis. The generatrix is stored in the same   *
* way in tables Xgen and Ygen.                                     *
* ---------------------------------------------------------------- *
* REFERENCE:                                                       *
* "Graphisme dans le plan et dans l'espace avec Turbo-Pascal 4.0   *
*  By R. Dony - MASSON, Paris 1990" [BIBLI 12].                    *
*                                                                  *
*                        Visual C++ version by J-P Moreau, Paris   *
*                          (use with fractals.mak and gr2d.cpp)    *
*                                   (www.jpmoreau.fr)              *
*******************************************************************/
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

HDC  hdc;
RECT rect;
HPEN hpen, hpenOld;

//Functions used here of module Gr2D.cpp
void Fenetre(double,double,double,double); 
void Cloture(int,int,int,int); 
void Bordure();
void PleinEcran();
void MoveXY(double,double);
void LineXY(double,double);

//"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;
  double dx,dy;
  if (ix2<ix1) {
	Swap(&ix1,&ix2); Swap(&iy1,&iy2);
  }
  il=(int) sqrt((ix2-ix1)*(ix2-ix1)+(iy2-iy1)*(iy2-iy1));
  dx=(double) (ix2-ix1)/il; 
  dy=(double) (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);
}


const limit = 4096;

typedef float *ptab; 

double Xbasis[11],Ybasis[11];
double Xgen[21],Ygen[21];
ptab   Xfract,Yfract;
short  PointsBase,PointsGen;
double f1,f2,f3,f4;
char   Title[60];
short  order;
int    id_begin=1;

extern MaxX, MaxY;

short Power(int basis,int exponant) {
  short i,prod;
  prod=1;
  for (i=1; i<=exponant; i++)  prod=prod*basis;
  return prod;
}

void Data() {
  if (id_begin) {
    strcpy(Title,"Triangular Von Koch snowflakes");
    PointsBase=3;
    Xbasis[0]=1;      Ybasis[0]=0;
    Xbasis[1]=-0.5;   Ybasis[1]= 0.866025;
    Xbasis[2]=-0.5;   Ybasis[2]=-0.866025;
    Xbasis[3]=1;      Ybasis[3]=0;
    PointsGen=5;
    Xgen[0]=0;        Ygen[0]=0;
    Xgen[1]=0.3333;   Ygen[1]=0;
    Xgen[2]=0.5;      Ygen[2]=0.2887;
    Xgen[3]=0.6666;   Ygen[3]=0;
    Xgen[4]=1;        Ygen[4]=0;
    f1=-1.1; f2=1.25; f3=-1.25; f4=1.1;
  }
  id_begin=0;
  order=6;
}

void CalculateCurve(short O, short B, short G) {
  short i,aux1,aux2,j,m1,m2,k;
  double x1, y1;
  Xfract=(float *) malloc(limit*sizeof(float));
  Yfract=(float *) malloc(limit*sizeof(float));
  Xfract[0]=0;
  Yfract[0]=0;
  Xfract[Power(G,O)]=1;
  Yfract[Power(G,O)]=0;
  for (i=0; i<O; i++) {
    aux1=Power(G,O-i);
    aux2=Power(G,O-i-1);
    j=0;
    do {
      m1=j+aux1;
      x1=Xfract[m1]-Xfract[j];
      y1=Yfract[m1]-Yfract[j];
      for (k=1; k<G; k++) {
        m2=j+k*aux2;
        Xfract[m2]=(float) (x1*Xgen[k]-y1*Ygen[k]+Xfract[j]);
        Yfract[m2]=(float) (y1*Xgen[k]+x1*Ygen[k]+Yfract[j]);
      }
      j += aux1;
    } while (j < Power(G,O));
  }
}

void DrawBasis() {
  int i;
  Fenetre(-2,2,-2,2);
  Cloture(10,int(0.33*(MaxX+1)),int(0.46*(MaxY+1)),MaxY-10);
  Bordure();
  MoveXY(Xbasis[0],Ybasis[0]);
  for (i=1; i<PointsBase+1; i++) LineXY(Xbasis[i],Ybasis[i]);
  OutText(25,20,"Basis");
}

void DrawGeneratrix() {
  const double r=-0.1;
  int i;
  Fenetre(-1,2,-1.5,1.5);
  Cloture(10,int(0.33*(MaxX+1)),25,int(0.44*(MaxY+1)));
  Bordure();
  MoveXY(r+Xgen[0],r+Ygen[0]);
  for (i=1; i<PointsGen; i++) LineXY(r+Xgen[i],r+Ygen[i]);
  OutText(25,int(0.58*(MaxY+1)),"Generatrix");
}

void DrawCurve(short O,short B, short G)  {
  double diff1,diff2,xx,yy;
  short i0,ix,m,n;
  char  s[20];
  Fenetre(f1,f2,f3,f4);
  PleinEcran();
  sprintf(s,"         Order = %2d",order);
  strcat(Title,s);
  i0=int(0.34*(MaxX+1));
  ix=150;
  OutText(ix,MaxY-50,Title);
  Cloture(i0,MaxX-10,25,MaxY-10);
  Bordure();
  MoveXY(Xbasis[0],Ybasis[0]);
  for (m=0; m<B; m++) {
    diff1=Xbasis[m+1] - Xbasis[m];
    diff2=Ybasis[m+1] - Ybasis[m];
    for (n=0; n<pow(G,O)+1; n++) {
      xx=diff1*Xfract[n] - diff2*Yfract[n] + Xbasis[m];
      yy=diff2*Xfract[n] + diff1*Yfract[n] + Ybasis[m];
      LineXY(xx,yy);
    }
  }
}

//draw linear_fractal
void Fractal() {
  //client drawing zone in pixels
  MaxX=(rect.right-rect.left);
  MaxY=(rect.bottom-rect.top);

  Data();
  CalculateCurve(order,PointsBase,PointsGen-1);
  DrawBasis();
  DrawGeneratrix();
  DrawCurve(order,PointsBase,PointsGen-1);
  free(Xfract); free(Yfract);
}


//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);
            hpen = CreatePen(PS_SOLID, 1, RGB(0, 0, 255));
            hpenOld = SelectObject(hdc,hpen);

            Fractal();
               
            SelectObject(hdc,hpenOld);
            DeleteObject(hpen);
            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[] = "Fractals";
    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
        " LINEAR FRACTALS",         // 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 fractals.cpp