/*******************************************************************************
   Moduli:        piirrot.cpp
   Tarkoitus:     ......
   Projekti:      Winlin, Cum laude approbatur -harjoitustyö
   Tekijät:       Virpi Kivinen & Tiina Mäkinen

   Tehty:         1.1.96
   Muutettu:      12.7.96
   Mitä muutettu: 12.7.96  pistepiirtojen yksinkertaistaminen
                  Lisätty piirrot.h tiedostoon tietueeseen tGHwndt W laskuri
                  hiiren klikkauksia varten sekä muuttuja drag_draw pistepiirto-
                  ja varten (1 kun kuutiota, jonka sisään kuva lopulta syttyy
                  venytetään).
   Muutettu       14.7.96
   Mitä muutettu: + metodi oikea_yla(), joka palauttaa nurkkakoordinaatin
                  + metodi  cPiirrettavaObjekti::PiirraPois (kaikille sama)
                  + piirrot.h tiedostoon cSateellinen *otus tietueeseen tGHwndt W.
                    W.otuksessa (ei tietorakenteessa) on suunnikas jonka sisään
                    kuvat piirretään (2 ja 3 pisteen piirroissa).
   Muutettu       18.7.96
   Mitä muutettu: + W.edellinen (piirrot.h).
   Muutettu       20.7.96
   Mitä muutettu: + yritelm„ tehd„ cKuutio::tee_littea_kuutio, palauttaisi mat
                  riisin, jonka det==0 (viivojen piirtoon). EIPŽ ONNANNU!
                  + int cKuutio::tee_littea_kuutio(cVec loppup) tehty, muttei
                  kokeiltu.
   Puutteet:      mökki

*******************************************************************************/

#include<windows.h>
#include<windowsx.h>
#include<math.h>
#include"piirrot.h"
/*******************************************************************************
   cSateelliset saavat piirtometodissaan parametrina ikkunan (cMuunnettuIkkuna A), johon ne piirretään.
   Varsinainen piirto tehdään A:n metodeilla move ja line, jotka muuntavat reaalikoordinaatit
   näytön koordinaateiksi kertomalla niitä Origo, Apu (koordinaatiston kiertoa vast.) ja Muunnos (kuvausta vast.)
   matriiseilla

   Mökki ja Oma Piirto puuttuu!!!!
 21.04.
      int piirretaanko(cMuunnettuIkkuna I) -Palauttaa 1, jos Ikkuna johon piirretään on alkukuva tai
                                            objekti jota piirretään voidaan piirtää kuvaikkunaan.
/******************************************************************************/
int cPiirrettava_objekti::vaihdavari(HPEN v)
{
  vari=v;
  return 0;
}

int cPiirrettava_objekti::piirretaanko(cMuunnettuIkkuna I)
{
  if (!(I.Kuva())||kuvattu) return 1;
  return 0;
}

int cPiirrettava_objekti::PiirraPois(cMuunnettuIkkuna A)//14.7
{
  A.luo_kyna(vari);
  int oldROP= SetROP2(A.Hdc(),R2_NOT);
  if ( Mat.ei_litussa())
    piirra(A);
  else {
//      cViiva viiva(kp,oikea_yla(),Mat);
//      viiva.piirra(A);
    cMatrix C;
    C=A.muunna(Mat); //Hiiren klikkauksista koottu otuksen matriisi
    A.move(kp);
    A.line(oikea_yla());
    A.palauta(C); //muunnettuikkunan alkuperäinen matriisi takaisin.
  }

  SetROP2(A.Hdc(),oldROP);
  A.poista_kyna();
  return 0;
}

cVec cPiirrettava_objekti::anna_paikka(void)
{//26.6
  cVec apu(Mat[0][3],Mat[1][3],Mat[2][3]);
  return apu;
}

/******************************************************************************/
int cKuutio::piirra(cMuunnettuIkkuna A) const
{
  cMatrix C;
  C=A.muunna(Mat); //Hiiren klikkauksista koottu otuksen matriisi

  cVec a(kp),
       b(sade+a[0],a[1],a[2]),
       c(b[0],sade+b[1],a[2]),
       d(a[0],c[1],a[2]);

  A.move(a);
  A.line(b);A.line(c);A.line(d);A.line(a);

 //kolmiulotteiset kuvat piirretään vasta kun on valittu 4x4-matriisi.
  if (W.dimensio > 3) {
    cVec e(a[0],a[1],kerroin*(a[2]+sade)),
         f(b[0],a[1],e[2]),
         g(b[0],c[1],e[2]),
         h(a[0],c[1],e[2]);
    A.line(e);
    A.line(f);A.line(g);A.line(h);A.line(e);
    A.move(b);A.line(f);
    A.move(c);A.line(g);
    A.move(d);A.line(h);
  }

  A.palauta(C); //muunnettuikkunan alkuperäinen matriisi takaisin.
  return 0;
}

cVec cKuutio::oikea_yla(void)
{//14.7
  cVec apu(kp[0]+sade,kp[1]+sade,kp[2]+kerroin*sade);//muuntamaton nurkka
  apu = Mat*apu;                                     //muunnettu nurkka
  return apu;
}

int cKuutio::aseta_loppupiste(const cVec &l)//27.6
{
  Mat[0][0]= l[0]-Mat[0][3];
  Mat[1][1]= l[1]-Mat[1][3];
  return 0;
}

//20.07
int cKuutio::tee_littea_kuutio(cVec loppup)//20.07
{
  cMatrix apu;
  double dx=loppup[0]-Mat[0][3];
  double dy=loppup[1]-Mat[1][3];
/*
    if (!(dx==0 && dy == 0)){
 */
     double pituus =sqrt(dx*dx+dy*dy);
/*      apu.skaalaus(pituus,pituus,1.0);
      apu[1][1]=0;
//      Mat = apu*Mat;
      Mat *= apu;
    }
*/
#define EPS 0.000001
  if (!((-EPS<dx&&dx<EPS)&&(-EPS<dy&&dy<EPS)) ) {
//    if (!(dx==0 && dy == 0)){
    //27.07 kulma täytyy muuttaa asteiksi
    double angle=180*atan2(dy,dx)/M_PI;
    apu.kierto(angle,3);  //nollan sijoitus??
    Mat *= apu;
//      Mat = apu * Mat;
    apu.diagonaali();
    apu[0][0]=pituus;
    apu[1][1]=0;
    Mat *= apu;
  }
  return 0;
}

cMatrix cKuutio:: matsij(const cMatrix &C)
{
  cMatrix apu(Mat);
  Mat=C;
  return apu;
}

cMatrix cKuutio:: matker(const cMatrix &C)
{
  cMatrix apu(Mat);
  Mat = C * Mat;
  return apu;
}
/******************************************************************************/
int cEllipsi::piirra(cMuunnettuIkkuna H) const
{
  cMatrix C;
  C=H.muunna(Mat);
  double t = 0;
  double dt = M_PI/100;

  cVec lp;
  lp[0]=sade*cos(t)+kp[0]; lp[1]=kerroin*sade*sin(t)+kp[1]; lp[2]=kp[2];
  cVec edellinen;
  H.move(lp);
  while ( t <= 2*M_PI ){
    t += dt;
    lp[0]=sade*cos(t)+kp[0]; lp[1]=kerroin*sade*sin(t)+kp[1];
    H.line(lp);
  }// jOS haluttais tehdä sylinterejä
  if (W.dimensio > 3){
    t=0;
    lp[0]=sade*cos(t)+kp[0];
    lp[1]=kerroin*sade*sin(t)+kp[1];
    lp[2]=kerroin*(kp[2]+sade);
    edellinen = lp;
    H.move(lp);
    while ( t <= 2*M_PI ){
      t += dt;
      lp[0]=sade*cos(t)+kp[0]; lp[1]=kerroin*sade*sin(t)+kp[1];

      if (-EPSILON<cos(t)&&cos(t)<EPSILON){ //seinät!!!!!!!!!!!???????
        lp[2]=kp[2];                  //mennee hupsuihin kohtiin 3p-piirrossa
        H.line(lp);
        lp[2]=kerroin*(kp[2]+sade);
      }
      H.line(lp);
    }
  }

  H.palauta(C);
  return 0;
}

/******************************************************************************/
int cParaabeli::piirra(cMuunnettuIkkuna H) const
{
  cMatrix C;
  C=H.muunna(Mat);
  double i=sqrt(H.Jako());
  double t = -i,j = i;
  double dt = 0.1;

  cVec lp;
  lp[0]=kp[0]+t; lp[1]=kerroin*(kp[1]+(t-sade)*(t-sade)); lp[2]=kp[2];
  H.move(lp);
  while (t <= j){
    t += dt;
    lp[0]=kp[0]+t; lp[1]=kerroin*(kp[1]+(t-sade)*(t-sade));
    H.line(lp);
  }
  H.palauta(C);
  return 0;
}

/******************************************************************************/
int cYspiraali::piirra(cMuunnettuIkkuna H) const
  // y-akselin ympäri
{
  cMatrix C;
  C=H.muunna(Mat);
  double t = 0;
  double dt = 0.1;

  cVec lp;
  lp[0]=sade*cos(M_PI/2*t)+kp[0];
  lp[1]=kp[1]+t/2;
  lp[2]=-kerroin*sade*sin(M_PI/2*t)+kp[1];
  H.move(lp);
  while ( t <= 4*M_PI ){
    t += dt;
    lp[0]=sade*cos(M_PI/2*t)+kp[0];
    lp[1]=kp[1]+t/2;
    lp[2]=-kerroin*sade*sin(M_PI/2*t)+kp[1];
    H.line(lp);
  }
  H.palauta(C);
  return 0;
}

/******************************************************************************/
int cZspiraali::piirra(cMuunnettuIkkuna H) const
  // z-akselin ympäri
{
  cMatrix C;
  C=H.muunna(Mat);
  double t = 0;
  double dt = 0.1;

  cVec lp;
  lp[0]=sade*cos(M_PI/2*t)+kp[0];
  lp[2]=kp[2]+t/2;
  lp[1]=kerroin*sade*sin(M_PI/2*t)+kp[1];
  H.move(lp);
  while ( t <= 6*M_PI ){
    t += dt;
    lp[0]=sade*cos(M_PI/2*t)+kp[0];
    lp[2]=kp[2]+t/2;
    lp[1]=kerroin*sade*sin(M_PI/2*t)+kp[1];
    H.line(lp);
  }
  H.palauta(C);
  return 0;
}

/******************************************************************************/
int cViiva::aseta_alkupiste(const cVec &a)
{
  kp=a;
  return 0;
}

int cViiva::aseta_loppupiste(const cVec &l)
{
  lp=l;
  return 0;
}

int cViiva::piirra(cMuunnettuIkkuna A) const
{
  cMatrix C;
  C=A.muunna(Mat);
  A.move(kp);
  A.line(lp);
  A.palauta(C);
  return 0;
}

cVec cViiva::oikea_yla(void)//14.7
{
   return lp;
}

/******************************************************************************/
int cKolmio::piirra(cMuunnettuIkkuna A) const
{
  cMatrix C;
  C=A.muunna(Mat);
  A.move(kp);
  cVec a(kp[0]+sade,kp[1]);        A.line(a);
  cVec b(kp[0]+sade/2,kp[1]+sade); A.line(b);
  A.line(kp);
  if (W.dimensio > 3) {
    cVec c(kp[0],kp[1],kerroin*(kp[2]+sade));  A.line(c);
    cVec d(a[0],a[1],kerroin*(a[2]+sade));     A.line(d);
    cVec e(b[0],b[1],kerroin*(b[2]+sade));     A.line(e);
    A.line(c);

    A.move(a); A.line(d);
    A.move(b); A.line(e);
  }
  A.palauta(C);

  return 0;
}

/******************************************************************************/
int cMokki::piirra(cMuunnettuIkkuna A) const
{
  cMatrix C;
  C=A.muunna(Mat);
  Ku.piirra(A);
  cVec a(0.25,0.25,0.0);  A.move(a); //ikkuna
  cVec b(0.25,0.75,0.0);  A.line(b);
  cVec c(0.5,0.25,0.0);   A.move(c);
  cVec d(0.5,0.75,0.0);   A.line(d);
  cVec e(0.75,0.25,0.0);  A.move(e);
  cVec f(0.75,0.75,0.0);  A.line(f);
  A.move(a); A.line(e);
  A.move(b); A.line(f);
  cVec g(0.25,0.5,0.0);   A.move(g);
  cVec h(0.75,0.5,0.0);   A.line(h);
  if (W.dimensio>3){
    cVec i(1.0,0.0,0.25);   A.move(i); //ovi
    cVec j(1.0,0.75,0.25);  A.line(j);
    cVec k(1.0,0.75,0.75);  A.line(k);
    cVec l(1.0,0.0,0.75);   A.line(l);
  }
  cMatrix D;                           //katto
  D.siirto(-0.25,1.0,0.0);
  A.muunna(D);
  D.skaalaus(1.5,1,1);
  A.muunna(D);
  Ko.piirra(A);
  A.palauta(C);
  return 0;
}

/******************************************************************************/
void cVarit::tuhoa(void)
{
  int i;
  for (i=0; i<VAREJA; i++)
    DeleteObject(Varit[i]);
}

/******************************************************************************/
const HPEN &cVarit::operator[]( int i) const
{
  if ( i<0||VAREJA<=i ) return Varit[0];  //laiton viittaus
  return Varit[i];
}