/* ***********************************************************************
   *									 *
   *		    3-D Modeling and Shading Routines for 		 *
   *			Objects Constructed of Facets			 *
   *									 *
   *				Program by				 *
   *			   Christopher D. Watkins			 *
   *									 *
   *			     'C' conversion by				 *
   *                            Larry Sharp				 *
   *									 *
   ***********************************************************************
*/

#include "stdio.h"
#include "dos.h"
#include "conio.h"
#include "math.h"
#include "string.h"
#include "alloc.h"
#include "math.inc"
#include "graph.inc"
#include "model.inc"

/* ***********************************************************************
   *									 *
   *			       Toggle Switches				 *
   *									 *
   ***********************************************************************

   DoPreview    - display verticies
   DoWireFrame  - display wireframe
   DoSolidModel - display solid model
   VertSort     - vertically sort objects
*/

Boolean Preview;
Boolean WireFrame;
Boolean SolidModel;
Boolean VerticalSort;

void DoPreview(Boolean State)
{
  Preview=State;
}

void DoWireFrame(Boolean State)
{
  WireFrame=State;
}

void DoSolidModel(Boolean State)
{
  SolidModel=State;
}

void VertSort(Boolean Sort)
{
  VerticalSort=Sort;
}

/* ***********************************************************************
   *									 *
   *		           Affine Transformations			 *
   *									 *
   ***********************************************************************

   AffineTransformation    - translate, rotate and scale verticies for
			     viewing
   InvAffineTransformation - return verticies to original value
*/

void DoTransform(Matx4x4 XForm)
{
  TDA temp, temp2;

  for(VertexNum=1; VertexNum<=LastVertex; VertexNum++)
  {
    VecScalMultI(InvScaleData, Vertex[VertexNum], temp2);
    Transform(temp2, XForm, temp);
    VecScalMultInt(ScaleImage, temp, Vertex[VertexNum]);
  }
}

void DoInvTransform(Matx4x4 XForm)
{
  TDA temp, temp2;

  for(VertexNum=1; VertexNum<=LastVertex; VertexNum++)
  {
    VecScalMultI(InvScaleImage, Vertex[VertexNum], temp2);
    Transform(temp2, XForm, temp);
    VecScalMultInt(ScaleData, temp, Vertex[VertexNum]);
  }
}

void AffineTransformation(float Tx, float Ty, float Tz,
			  float Sx, float Sy, float Sz,
			  float Rx, float Ry, float Rz)
{
  Matx4x4 XForm;

  PrepareMatrix(Tx, Ty, Tz, Sx, Sy, Sz, Rx, Ry, Rz, XForm);
  DoTransform(XForm);
}

void InvAffineTransformation(float Tx, float Ty, float Tz,
			     float Sx, float Sy, float Sz,
			     float Rx, float Ry, float Rz)
{
  Matx4x4 XForm;

  PrepareInvMatrix(-Tx, -Ty, -Tz, 1.0/Sx, 1.0/Sy, 1.0/Sz, -Rx, -Ry, -Rz, XForm);
  DoInvTransform(XForm);
}

/* ***********************************************************************
   *									 *
   *		       Viewer and Light Source Vectors			 *
   *									 *
   ***********************************************************************

   GetViewVector      - unit vector in direction of viewer
   InitLightDirection - get direction for light source
   GetLightVector     - unit vector in direction of light source
*/

#define ViewPhi 270
#define ViewTheta 90

TDA View;

void GetViewVector()
{
  float Phi, Theta;
  float x, y, z;

  Phi=Radians((float)ViewPhi-Angl);
  Theta=Radians((float)ViewTheta-Tilt);
  x=sin(Theta)*cos(Phi);
  y=sin(Theta)*sin(Phi);
  z=cos(Theta);
  Vec(x, y, z, View);
}

float LightPhi;
float LightTheta;

void InitLightDirection(int LgtPhi, int LgtTheta)
{
  printf("Light Direction is %d around the z-Axis and\n", LgtPhi);
  printf("                   %d off the z-Axis\n", LgtTheta);
  LightPhi=(float)LgtPhi;
  LightTheta=(float)LgtTheta;
}

TDA Light;

void GetLightVector()
{
  float Phi, Theta;
  float x, y, z;

  Phi=Radians(LightPhi);
  Theta=Radians(LightTheta);
  x=sin(Theta)*cos(Phi);
  y=sin(Theta)*sin(Phi);
  z=cos(Theta);
  Vec(x, y, z, Light);
}

/* ***********************************************************************
   *									 *
   *			    Surface Normal Vector			 *
   *									 *
   ***********************************************************************

   GetSurfaceNormalVector - unit vector normal to surface
*/

TDA SrfNorm;

void GetSurfaceNormalVector(VoxelArray Face3d)
{
  float Length, Length2;
  TDA Dir1;
  TDA Dir2;
  TDA Temp1;
  TDA Temp2;
  TDA Temp3;
  TDA SrfNorm2;

  VecCopy(Face3d[2], Temp1);
  VecCopy(Face3d[1], Temp2);
  VecCopy(Face3d[LastVertexNumInFacet], Temp3);
  VecSub(Temp1, Temp2, Dir1);
  VecSub(Temp3, Temp2, Dir2);
  VecCross(Dir1, Dir2, SrfNorm);
  Length=VecLen(SrfNorm);
  VecCopy(Face3d[LastVertexNumInFacet], Temp1);
  VecCopy(Face3d[LastVertexNumInFacet-1], Temp2);
  VecCopy(Face3d[LastVertexNumInFacet-2], Temp3);
  VecSub(Temp1, Temp2, Dir1);
  VecSub(Temp3, Temp2, Dir2);
  VecCross(Dir1, Dir2, SrfNorm2);
  Length2=VecLen(SrfNorm2);
  if(Length==0.0)
    VecScalMult(1.0/Length2, SrfNorm2, SrfNorm);
  else
  {
    if(Length2==0.0)
      VecScalMult(1.0/Length, SrfNorm, SrfNorm);
    else
    {
      VecScalMult(1.0/Length, SrfNorm, SrfNorm);
      VecScalMult(1.0/Length2, SrfNorm2, SrfNorm2);
      VecAdd(SrfNorm, SrfNorm2, SrfNorm);
      VecScalMult(0.5, SrfNorm, SrfNorm);
    }
  }
}

/* ***********************************************************************
   *									 *
   *			   The Illumination Model			 *
   *									 *
   ***********************************************************************

   Intensity - calculated intensity of point on screen
*/

Byte Intensity()
{
  float Ambient=0.30;
  float DifRfl=0.50;
  float SpcRfl=0.20;
  float Gloss=5.0;
  float CosTheta;
  float CosAlpha;
  TDA Ref;
  float TwoCosTheta;
  TDA temp;

  CosTheta=VecDot(SrfNorm, Light);
  if(CosTheta<=0.0)
    return(Round(MaxInten*Ambient));
  else
  {
    TwoCosTheta=2.0*CosTheta;
    VecScalMult(TwoCosTheta, SrfNorm, temp);
    VecNormalize(temp);
    VecSub(temp, Light, Ref);
    VecNormalize(Ref);
    CosAlpha=VecDot(View, Ref);
    return(Round(MaxInten*(Ambient+DifRfl*CosTheta+SpcRfl*pow(CosAlpha, Gloss))));
  }
}

/* ************************************************************************
   *                                                                      *
   *			    Facet Visibility Test			  *
   *									  *
   ************************************************************************

   Visible - determine if facet is visible
*/

Boolean Reflect;
Boolean MirrorX;
Boolean MirrorY;
Boolean MirrorZ;

Boolean Visible(VoxelArray Face3d)
{
  float CosBeta;
  float nvx, nvy, nvz;
  TDA temp, v;
  Boolean vt;

  GetSurfaceNormalVector(Face3d);
  VecCopy(View, v);
  if((!(Preview || WireFrame)) && Reflect && MirrorZ)
    v[2]=-v[2];
  VecElemMult(1.0, SrfNorm, v, temp);
  UnVec(temp, &nvx, &nvy, &nvz);
  vt=true;
  CosBeta=nvx+nvy+nvz;
  if((MirrorZ || (!(MirrorX || MirrorY))) && (CosBeta<0.0))
    vt=false;
  else
  {
    CosBeta=-nvx+nvy+nvz;
    if(MirrorX && (CosBeta<0.0))
      vt=false;
    else
    {
      CosBeta=nvx-nvy+nvz;
      if(MirrorY && (CosBeta<0.0))
	vt=false;
    }
  }
  return(vt);
}

/* ***********************************************************************
   *									 *
   *			  Reflection Screen Buffer			 *
   *									 *
   ***********************************************************************
   Stores the reflective states of all screen pixel locations

   InitReflectionBuffer - clear reflective states
   Reflected		- indicates whether or not reflective
   MakeReflected	- makes a screen location reflective
*/

#define XBytes 39

Byte Refl[XBytes+1][MaxY+1];

void InitReflectionBuffer()
{
  int i, j;

  for(i=0; i<=XBytes; i++)
  {
    for(j=0; j<=MaxY; j++)
      Refl[i][j]=0;
  }
}

Boolean Reflected(int x, int y)
{
  Byte tmp;

  tmp=Refl[x/8][y]&(128>>(x%8));
  if(tmp==0)
    return(false);
  else
    return(true);
}

void MakeReflected(int x, int y)
{
  Refl[x/8][y]=Refl[x/8][y]|(128>>(x%8));
}

#include "addobjs.inc"

/* ***********************************************************************
   *									 *
   *			Polygonal Facet Fill Routine			 *
   *									 *
   ***********************************************************************

   GetProjectedCoords - 3D point mapped onto 2D screen
   PutFacet2	      - fills a facet
*/

void GetProjectedCoords(VoxelArray Face3d, PixelArray Face2d)
{
  float xt, yt, zt;

  for(VertexNumInFacet=1; VertexNumInFacet<=LastVertexNumInFacet; VertexNumInFacet++)
  {
    UnVec(Face3d[VertexNumInFacet], &xt, &yt, &zt);
    if(Reflect)
    {
      if(MirrorZ)
      {
	zt=-zt;
	if(EdgeReflector && (!(EdgeReflectorAtZero)))
	  zt-=200.0;
      }
      else
      {
	if(MirrorY)
	{
	  yt=-yt;
	  if(EdgeReflector || EdgeReflectorAtZero)
	    yt-=200.0;
	}
	else
	{
	  if(MirrorX)
	  {
	    xt=-xt;
	    if(EdgeReflector || EdgeReflectorAtZero)
	      xt-=200.0;
	  }
	}
      }
    }
    MapCoordinates(xt, yt, zt, &Face2d[VertexNumInFacet].x, &Face2d[VertexNumInFacet].y);
  }
  Face2d[LastVertexNumInFacet+1]=Face2d[1];
}

Boolean Mirroring;

void PutFacet2(PixelArray Face2d, Byte Color, Byte Intens)
{
  int xc, yc;
  int i, x;
  int OldVertNum;
  int VertNum;
  int mnx, mxx;
  int mny, mxy;
  float slope;

  if(Intens<1)
    return;
  if(Reflect && (Intens!=1))
  {
    --Intens;
    if(Intens!=2)
    {
      --Intens;
      if(Intens!=3)
	--Intens;
    }
  }
  mny=Face2d[1].y;
  mxy=Face2d[1].y;
  for(i=2; i<=LastVertexNumInFacet; i++)
  {
    if(Face2d[i].y>mxy)
      mxy=Face2d[i].y;
    if(Face2d[i].y<mny)
      mny=Face2d[i].y;
  }
  if(mny<0)
    mny=0;
  if(mxy>MaxY)
    mxy=MaxY;
  for(yc=mny; yc<=mxy; yc++)
  {
    mnx=MaxX+1;
    mxx=-1;
    OldVertNum=LastVertexNumInFacet;
    for(VertNum=1; VertNum<=LastVertexNumInFacet; VertNum++)
    {
      if((Face2d[OldVertNum].y>=yc) || (Face2d[VertNum].y>=yc))
      {
	if((Face2d[OldVertNum].y<=yc) || (Face2d[VertNum].y<=yc))
	{
	  if(Face2d[OldVertNum].y != Face2d[VertNum].y)
	  {
	    slope=(float)(Face2d[VertNum].x-Face2d[OldVertNum].x)/
		  (float)(Face2d[VertNum].y-Face2d[OldVertNum].y);
	    x=Round(slope*(float)((yc-Face2d[OldVertNum].y))+
				     Face2d[OldVertNum].x);
	    if(x<mnx)
	      mnx=x;
	    if(x>mxx)
	      mxx=x;
	  }
	}
      }
      OldVertNum=VertNum;
    }
    if(mnx<0)
      mnx=0;
    if(mxx>MaxX)
      mxx=MaxX;
    if(mnx<=mxx)
    {
      for(xc=mnx; xc<=mxx; xc++)
      {
	if(Mirroring)
	{
	  MakeReflected(xc, yc);
	  PutPixel(xc, yc, Color, Intens);
	}
	else
	{
	  if(!(Reflect))
	    PutPixel(xc, yc, Color, Intens);
	  else
	  {
	    if(Reflected(xc, yc))
	      PutPixel(xc, yc, Color, Intens);
	  }
	}
      }
    }
  }
}

/* ***********************************************************************
   *									 *
   *		   Load Description File and Scene Data			 *
   *									 *
   ***********************************************************************

   LoadDescAndScene - loads description file ".DES" and scene data
*/

Strg B;


Name SceneFile;

void GetSceneFile()
{
  int i;
  Byte x, y;

  printf("\nEnter File Name -> ");
  x=wherex();
  y=wherey();
  gets(SceneFile);
  if(!(strcmp(SceneFile, "")))
  {
    strcpy(SceneFile, "CUBEPLAN");
    gotoxy(x, y);
    puts(SceneFile);
  }
  puts("");
  for(i=0; i<strlen(SceneFile); i++)
    SceneFile[i]=toupper(SceneFile[i]);
}

void LoadDescAndScene(Name FileName)
{
  FILE *TextDiskFile;

  TextDiskFile=fopen(FileName, "r+t");
  fscanf(TextDiskFile, "%s", B);
  PutAxisAndPalette(Bool(B));
  if(Bool(B))
    printf("Axis and Palette Display On\n");
  else
    printf("Axis and Palette Display Off\n");
  fscanf(TextDiskFile, "%s", B);
  DoSolidModel(Bool(B));
  if(Bool(B))
    printf("Solid Model Display On\n");
  else
    printf("Solid Model Display Off\n");
  if(SolidModel)
  {
    fscanf(TextDiskFile, "%s", B);
    fscanf(TextDiskFile, "%s", B);
    DoPreview(false);
    DoWireFrame(false);
  }
  else
  {
    fscanf(TextDiskFile, "%s", B);
    DoPreview(Bool(B));
    if(Bool(B))
      printf("Vertex Display On\n");
    else
      printf("Vertex Display Off\n");
    fscanf(TextDiskFile, "%s", B);
    DoWireFrame(Bool(B));
    if(Bool(B))
      printf("Wire Frame Display On\n");
    else
      printf("Wire Frame Display Off\n");
  }
  fscanf(TextDiskFile, "%s", B);
  fclose(TextDiskFile);
  if(Bool(B))
  {
    printf("Loading Scene from Disk File\n");
    GetSceneFile();
    AddObjectsToSceneFromDiskFile(SceneFile);
  }
  else
  {
    printf("Loading Scene from Procedure\n\n");
    AddObjectsToSceneFromProcedure();
  }
  printf("Hit any key....\n");
  getch();
}

#include "dispobjs.inc"

/* ***********************************************************************
   *									 *
   *				Main Program				 *
   *									 *
   ***********************************************************************
*/

void main()
{
  Facet=farcalloc(((MaxFacet+1)*(MaxVertexNumInFacet+1)), sizeof(int));
  if(Facet==0)
  {
    printf("Not enough memory!\n");
    getch();
    exit(1);
  }
  Title();
  printf("3-D Modeling Program\n\n");
  InitReflectionBuffer();
  InitVertexBuffer();
  InitObjectBuffer();
  LoadDescAndScene("MODEL.DES");
  InitGraphics();
  AxisAndPalette();
  if(DrawAxisAndPalette)
    WaitForKey();
  DisplayObjectsInScene();
  ExitGraphics();
  farfree(Facet);
}