Keskustelu: Koodit: C++: OpenGL fraktaalihärveli

//  OpenGL fraktaalihärveli
//  Tämän pitäisi toimia ainakin gcc 3.3.5 versiolla linuxissa.
//  Kääntämiseen tarvitaan GLUT ja muutama muu kirjasto.
//  Pitäisi kääntyä ihan vaan g++ *.cc -lglut
//
//  Tässä on esimerkki fraktaalihärvelistä.
//  Fraktaali on laskettu yksinkertaisella kaavalla z = x ^ y
//  Tässä on siis taso jonka korkeus tulee tuon kaavan mukaan.
//  Lisäksi päälle on isketty tekstuuri joka on laskettu saman kaavan mukaan.
//  Jos fraktaalimaista pintaa kääntelee oikeassa suunnassa voi nähdä yhtäläisyyksiä Sierpinskin kolmioon.
//  Pienellä muutoksella tästä saa vaikka maastogeneraattorin.
//  Valitan koodin ajoittaista sotkuisuutta ja kommenttien puutetta.
//
// Tätä koodia saa kopioida vapaasti, ja tehdä sille ihan mitä huvittaa.
// -Pkettu

#include <GL/glut.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

//tässä määritellään jotain muuttujia
GLfloat rotateScene = 0.0;
GLfloat lookx = 0.0;
GLfloat looky = 0.0;
GLfloat lookz = 0.0;
//jos haluaa johonkin liikettä kannattaa käyttää i muuttujaa joka myöhemmin synkronoidaan kellon kanssa.
GLfloat i = 0.0;
GLfloat lisai = 0.0;
GLfloat aika = 0.0;

//näihin muuttujiin tallennetaan liikkuminen
double liikx=0;
double liiky=0;
double liikz=0;
double ztemp=-10;
double hiirix;
double hiiriy;

GLfloat c1[] = {1,0, 1};
GLfloat c2[] = {0, 0, 0};

GLUquadricObj * quad = gluNewQuadric();

//paussi vaikka ei tätä kyllä edes tarvitse
bool pause=false;

GLfloat kaantyma = 0.0;

GLuint texture[1];
//tekstuurin tarkkuus
#define imageWidth 512
#define imageHeight 512

GLubyte image2[3*imageWidth*imageHeight];

float points[129][129][3];



//Tässä väsätään tekstuuri fraktaalille
void makeImage(void)
{
   int wi,wj;
   float ti, tj;
   for (wi = 0; wi < imageWidth; wi++) {
      ti = wi/imageWidth;
      for (wj = 0; wj < imageHeight; wj++) {
         tj =wj/imageHeight;
     //huomaa kaava wi^wj
     //tähän voi laittaa tilalle mitä huvittaa jos haluaa erilaisen tekstuurin
        image2[3*(imageHeight*wi+wj)+2] =(GLubyte)((int)wi^(int)(wj))*2;
      }
   }
}

//tässä lasketaan pinnan korkeuserot kaavalla x^y
void pisteet(void)
{
double z;
    for(double x=0; x<128; x++)
    {
        for(double y=0; y<128; y++)
        {
            points[(int)x][(int)y][0]=y*2-64;
            points[(int)x][(int)y][1]=x*2-64;
        //tähänkin voi laittaa mita huvittaa jos haluaa erilaiset muodot vaikkapa: sin(x/10)*50+cos(y/10)*50
                        z = ((int)x^(int)(y));
            points[(int)x][(int)y][2]=z;
             if(z<0)
             {
                 points[(int)x][(int)y][2]=0;
             }
        }
    }
}

void init(void)
{
//isketään täyteen ruutuun
glutFullScreen();

//tehdään tekstuuri
makeImage();

//säädetään tekstuurin asetukset
glBindTexture(GL_TEXTURE_2D, texture[1]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, imageWidth, imageHeight, 0,
                GL_RGB, GL_UNSIGNED_BYTE, image2);

   glEnable(GL_TEXTURE_2D);
}

//tässä piirretään maastoa
void maasto(void)
{
float float_x, float_y, float_xb, float_yb;

glPushMatrix();

gluQuadricTexture(quad, GL_TRUE);

//kuva pyörii hiiren avulla
glRotated(hiiriy-180,1,0,0);
glRotated(hiirix-180,0,0,1);
//liikutaan näppäimillä jotka on mainittu alempana
glTranslatef(liikx,liiky,liikz);

//piirretään muodot
for(int x=0;x<127;x++)
for(int y=0;y<127;y++)
{
glBindTexture(GL_TEXTURE_2D, texture[1]);
//tekstuurit venytetään oikeaan kokoon
float_x = float(x)/128.0f;
float_y = float(y)/128.0f;
float_xb = float(x+1)/128.0f;
float_yb = float(y+1)/128.0f;

glBegin(GL_QUADS);
glTexCoord2f( float_x, float_y);
glVertex3f( points[x][y][0]*2, points[x][y][1]*2, points[x][y][2]*2);

glTexCoord2f( float_x, float_yb );
glVertex3f( points[x][y+1][0]*2, points[x][y+1][1]*2, points[x][y+1][2]*2);

glTexCoord2f( float_xb, float_yb );
glVertex3f( points[x+1][y+1][0]*2, points[x+1][y+1][1]*2, points[x+1][y+1][2]*2);

glTexCoord2f( float_xb, float_y );
glVertex3f( points[x+1][y][0]*2, points[x+1][y][1]*2, points[x+1][y][2]*2);
glEnd();
}
glPopMatrix();
}



void display(void)
{
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glLoadIdentity ();
if(pause==false)
//i muuttuja muuttuu samaa tahtia kuin kello, jos haluaa jonkin liikkuvat tasaista nopeutta
i=(0.000007*clock())+lisai+aika;
//piirretään ylempänä määritelty maasto
maasto();
glutSwapBuffers ();
}

void reshape (int w, int h)
{
   glViewport (0, 0,(GLsizei) w,(GLsizei) h);
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity ();
   gluPerspective( 100,1.33333,0.1,10000000);
   glMatrixMode (GL_MODELVIEW);
}


void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
      case 27:
         exit(0);
         break;
//täällä on määritetty näppäimet joilla pääsee liikkumaan
      case 'z':
         lisai=lisai+3.0;
     break;
      case 'x':
         lisai=lisai-3.0;
     break;
      case '1':
         lisai=100;
     break;
      case '2':
         lisai=200;
     break;
      case '3':
         lisai=300;
     break;
      case '4':
         lisai=400;
     break;
      case '5':
         lisai=800;
      case 'w':
         liikx=liikx-5;
     break;
      case 's':
         liikx=liikx+5;
     break;
      case 'a':
         liiky=liiky+5;
     break;
      case 'd':
         liiky=liiky-5;
     break;
      case 'q':
         liikz=liikz+5;
     break;
      case 'e':
         liikz=liikz-5;
     break;
      case 'p':
         if(pause)
         pause=false;
     else
     pause=true;
     break;

   }
}

void hiiri(int x, int y)
{
hiirix=x/2;
hiiriy=y/2;
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
   glutInitWindowSize (1024, 768);
   glutInitWindowPosition (100, 100);
   glutCreateWindow(argv[0]);
   glutPassiveMotionFunc(hiiri);
   glutDisplayFunc(display);
   glutIdleFunc(display);
   glutReshapeFunc(reshape);
   glutKeyboardFunc(keyboard);
   pisteet();
   glEnable(GL_DEPTH_TEST);
      init ();
   glutMainLoop();
   return 0;
}