/***********************************************************************/
/* This program demonstrates how to use BIOS calls for programming the */
/* Atari Portfolio in graphics mode. The program should be compiled    */
/* with Turbo C 1.0                                                    */
/* Simple 3D engine implementation by RayeR (C) 2000                   */
/***********************************************************************/
// budem prekladat pro portfolio ?
#define PORTFOLIO

#include <conio.h>
#include <stdlib.h>
#include <dos.h>

typedef unsigned char Byte;

#define GFX 0x04
#define TXT 0x07
#define XRES 240
#define YRES 64
#define VRAMSIZE 1920
#define MAXX (XRES-1)
#define MAXY (YRES-1)
#define MIDX (XRES/2)
#define MIDY (YRES/2)
#define FP 10 // fixed point 6:10
#define FPR 6
#define FPPI (8-FPR)

/* camera position */
#define CX 11
#define CY 2
#define CZ 100

/* krychle - 8 vertexu, 12 faces   */
#define VNUM 8
#define FNUM 12
#define HEDGE (15<<FP)

int i;
Byte far *vram=MK_FP(0xB000,0); /* pointer do VRAM */
int  v[VNUM][3];  /* 3D vertexy */
Byte f[FNUM][3];  /* fejsy */
Byte p[VNUM][2];  /* 2D transformovane body */
Byte sintbl[91]={ /* predpocitana tabulka sinus */
		0,
		4,
		8,
		13,
		17,
		22,
		26,
		31,
		35,
		40,
		44,
		48,
		53,
		57,
		61,
		66,
		70,
		74,
		79,
		83,
		87,
		91,
		95,
		100,
		104,
		108,
		112,
		116,
		120,
		124,
		127,
		131,
		135,
		139,
		143,
		146,
		150,
		154,
		157,
		161,
		164,
		167,
		171,
		174,
		177,
		181,
		184,
		187,
		190,
		193,
		196,
		198,
		201,
		204,
		207,
		209,
		212,
		214,
		217,
		219,
		221,
		223,
		226,
		228,
		230,
		232,
		233,
		235,
		237,
		238,
		240,
		242,
		243,
		244,
		246,
		247,
		248,
		249,
		250,
		251,
		252,
		252,
		253,
		254,
		254,
		255,
		255,
		255,
		255,
		255,
		255
		};

void pfdelay(unsigned int bogoloops) /* 1s = asi 27000 loopu */
{
  unsigned int i;
  for (i=0; i<bogoloops; i++);
}

void setmode(Byte mode) /* set mode GFX/TXT */
{
  union REGS regs;
  regs.h.ah = 0;
  regs.h.al = mode;
  int86(0x10, &regs, &regs);
}

#ifndef PORTFOLIO
void putpix(Byte x, Byte y, Byte color) /* putpixel prez BIOS 0/1 */
{
  union REGS regs;
  regs.h.ah = 0x0c;
  regs.h.al = color;
  regs.h.bh = 0;
  regs.x.cx = x;
  regs.x.dx = y;
  int86(0x10, &regs, &regs);
}

#else
void putpix(Byte x, Byte y, Byte color) /* putpixel prez porty 0/1 */
{
  register int offset=x+y*XRES;
  int bit=offset%8;
  register int alo=offset>>3,ahi=alo>>8;
  outportb(0x8011,10);
  outportb(0x8010,alo%256);  // low Byte address
  outportb(0x8011,11);
  outportb(0x8010,ahi);  // high Byte address
  if (color!=0)
    outportb(0x8011,15); // set bit
  else
    outportb(0x8011,14); // clear bit
  outportb(0x8010,bit);  // bit num in Byte
}
#endif

Byte getpix(Byte x, Byte y) /* get pixel color 0/1 */
{
  union REGS regs;
  regs.h.ah = 0x0d;
  regs.h.bh = 0;
  regs.x.cx = x;
  regs.x.dx = y;
  int86(0x10, &regs, &regs);
  return(regs.h.al);
}

void refresh(void) /* zkopiruje VRAM na displej (do kontroleru HD) */
{
  union REGS regs;
  regs.h.ah = 0x12;
  int86(0x61, &regs, &regs);
}

void pfcls(Byte pattern)
{
  int i;
  for (i=0; i<VRAMSIZE; i++)
    vram[i]=pattern;
  refresh();
}

void line(Byte x1, Byte y1, Byte x2, Byte y2, Byte color) /* line */
{
  int x, y, d, a, b;
  int dx_diag, dy_diag;
  int dx_nondiag, dy_nondiag;
  int diag_inc, nondiag_inc;
  int i, swap;

  x = x1;
  y = y1;
  a = x2-x1;
  b = y2-y1;
  if (a<0) {
      a       = -a;
      dx_diag = -1;
  } else
      dx_diag = 1;
  if (b<0) {
      b       = -b;
      dy_diag = -1;
  } else
      dy_diag = 1;
  if (a<b) {
      swap       = a;
      a          = b;
      b          = swap;
      dx_nondiag = 0;
      dy_nondiag = dy_diag;
  } else {
      dx_nondiag = dx_diag;
      dy_nondiag = 0;
  }
  d           = b+b-a;
  nondiag_inc = b+b;
  diag_inc    = b+b-a-a;

  for(i=0; i<=a; i++) {
      putpix(x, y, color);
      if (d<0) {
	  x = x+dx_nondiag;
	  y = y+dy_nondiag;
	  d = d+nondiag_inc;
      } else {
	  x = x+dx_diag;
	  y = y+dy_diag;
	  d = d+diag_inc;
      }
  }
}

#define triangle(x1,y1,x2,y2,x3,y3,color) {line(x1,y1,x2,y2,color); line(x2,y2,x3,y3,color); line(x3,y3,x1,y1,color);}

void transform(void)
{
  Byte i;
  long zdivider;
  for (i=0; i<VNUM; i++)
    {
    zdivider=((v[i][2]>>FP)+CZ);
    p[i][0]=(int)( CZ*((v[i][0]>>FP)+CX)/zdivider+MIDX);
    p[i][1]=(int)(-CZ*((v[i][1]>>FP)+CY)/zdivider+MIDY);
    }
}

void render(Byte color)
{
  Byte i;
  for (i=0; i<FNUM; i++)
    triangle(p[f[i][0]][0],p[f[i][0]][1], p[f[i][1]][0],p[f[i][1]][1], p[f[i][2]][0],p[f[i][2]][1], color)
}

void move(int xo, int yo, int zo)
{
  Byte i;
  for (i=0; i<VNUM; i++)
    {
    v[i][0]+=xo<<FP;
    v[i][1]+=yo<<FP;
    v[i][2]+=zo<<FP;
    }
}

void scale(int xm, int ym , int zm)
{
  int i;
  for (i=0; i<VNUM; i++)
    {
    if (xm>0)
      v[i][0]=v[i][0]<<xm;
    else
      v[i][0]=v[i][0]>>-xm;
    if (ym>0)
      v[i][1]=v[i][1]<<ym;
    else
      v[i][1]=v[i][1]>>-ym;
    if (zm>0)
      v[i][2]=v[i][2]<<zm;
    else
      v[i][2]=v[i][2]>>-zm;
    }
}

int isin(char x)
{
  if (x>0)
    return(sintbl[x]>>FPPI);
  else
    return(-sintbl[-x]>>FPPI);
}

int icos(char x)
{
  if (x>0)
    return(sintbl[90-x]>>FPPI);
  else
    return(sintbl[90+x]>>FPPI);
}

void rotatex(Byte alfa)
{
  int i,temp;
  for (i=0; i<VNUM; i++)
    {
    temp=(v[i][2]>>FPR)*icos(alfa)-(v[i][1]>>FPR)*isin(alfa);
    v[i][1]=(v[i][2]>>FPR)*isin(alfa)+(v[i][1]>>FPR)*icos(alfa);
    v[i][2]=temp;
    }
}

void rotatey(Byte alfa)
{
  int i,temp;
  for (i=0; i<VNUM; i++)
    {
    temp=(v[i][0]>>FPR)*icos(alfa)-(v[i][2]>>FPR)*isin(alfa);
    v[i][2]=(v[i][0]>>FPR)*isin(alfa)+(v[i][2]>>FPR)*icos(alfa);
    v[i][0]=temp;
    }
}

void rotatez(Byte alfa)
{
  int i,temp;
  for (i=0; i<VNUM; i++)
    {
    temp=(v[i][0]>>FPR)*icos(alfa)-(v[i][1]>>FPR)*isin(alfa);
    v[i][1]=(v[i][0]>>FPR)*isin(alfa)+(v[i][1]>>FPR)*icos(alfa);
    v[i][0]=temp;
    }
}

void makebox(void)
{
  v[0][0]=-HEDGE;
  v[0][1]=HEDGE;
  v[0][2]=HEDGE;
  v[1][0]=HEDGE;
  v[1][1]=HEDGE;
  v[1][2]=HEDGE;
  v[2][0]=HEDGE;
  v[2][1]=-HEDGE;
  v[2][2]=HEDGE;
  v[3][0]=-HEDGE;
  v[3][1]=-HEDGE;
  v[3][2]=HEDGE;
  v[4][0]=-HEDGE;
  v[4][1]=HEDGE;
  v[4][2]=-HEDGE;
  v[5][0]=HEDGE;
  v[5][1]=HEDGE;
  v[5][2]=-HEDGE;
  v[6][0]=HEDGE;
  v[6][1]=-HEDGE;
  v[6][2]=-HEDGE;
  v[7][0]=-HEDGE;
  v[7][1]=-HEDGE;
  v[7][2]=-HEDGE;
}

main()
{
/* definice faces krychle */
  f[0][0]=0;
  f[0][1]=3;
  f[0][2]=2;
  f[1][0]=0;
  f[1][1]=1;
  f[1][2]=2;
  f[2][0]=1;
  f[2][1]=5;
  f[2][2]=6;
  f[3][0]=1;
  f[3][1]=2;
  f[3][2]=6;
  f[4][0]=0;
  f[4][1]=4;
  f[4][2]=7;
  f[5][0]=0;
  f[5][1]=3;
  f[5][2]=7;
  f[6][0]=4;
  f[6][1]=5;
  f[6][2]=6;
  f[7][0]=4;
  f[7][1]=7;
  f[7][2]=6;
  f[8][0]=0;
  f[8][1]=1;
  f[8][2]=5;
  f[9][0]=0;
  f[9][1]=4;
  f[9][2]=5;
  f[10][0]=3;
  f[10][1]=2;
  f[10][2]=6;
  f[11][0]=3;
  f[11][1]=7;
  f[11][2]=6;

  makebox();
  setmode(GFX);

  while (!kbhit())
    {
    for (i=0; i<16; i++)
      {
      rotatey(6);
      render(0);
      transform();
      render(1);
//      delay(100);
      pfdelay(10000);
      }
    makebox();
    }

  setmode(TXT);
  return(0);
}