Problem z srand(time(NULL));

#include <GL/glut.h>
#include <GL/glu.h>
#include <stdlib.h>
#include <iostream>
#include <math.h>
#include "obiekty.h"
#include <ctime>

#ifdef near
#undef near
#endif

#ifdef far
#undef far
#endif

// rozmiary bryły obcinania

const GLdouble left = - 10.0;
const GLdouble right = 10.0;
const GLdouble bottom = - 10.0;
const GLdouble top = 10.0;
const GLdouble near = 40.0;
const GLdouble far = 80.0;

const int n = 150;
piksel tablica_p[ n ][ n ];
double bok_kwadratu = 20;
bool start_pauza = false;

//podaje sie gorny lewy rog i rozmiar kwadratu, a on tworzy kwadrat z pikseli 'n' na 'n'
void kwadrat( double x1, double y1, double bok, piksel p[ n ][ n ] )
{
    double e;
    e = bok / n;
   
    for( int i = 0; i < n; i++ )
    {
        for( int j = 0; j < n; j++ )
        {
            p[ i ][ j ].SetPolozenie( x1 + i * e, y1 - j * e );
            p[ i ][ j ].rysowanie_piksela( e );
           
            if( i == 0 || i == n - 1 || j == n - 1 )
                 p[ i ][ j ].SetOdcien( 0 );
           
            if( j == 0 )
                 p[ i ][ j ].SetOdcien( 4 );
           
        };
    };
}

void przeliczanie_potencjalu( double bok, piksel p[ n ][ n ] )
{
    double e = 0;
    double f = bok / n;
   
    for( int i = 1; i < n - 1; i++ )
    {
        for( int j = 1; j < n - 1; j++ )
        {
            e =( p[ i + 1 ][ j + 1 ].GetOdcien() + p[ i - 1 ][ j + 1 ].GetOdcien() + p[ i + 1 ][ j - 1 ].GetOdcien() + p[ i - 1 ][ j - 1 ].GetOdcien() ) / 4;
            p[ i ][ j ].SetOdcien( e );
            p[ i ][ j ].rysowanie_piksela( f );
        };
    };
}

// funkcja generująca scenę 3D

void Display()
{
    glClearColor( 1.0, 1.0, 1.0, 1.0 );
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
    glMatrixMode( GL_MODELVIEW );
   
    glLoadIdentity();
   
    // przesunięcie układu współrzędnych obiektu do środka bryły odcinania
    glTranslatef( 0, 0, -( near + far ) / 2 );
   
    kwadrat( - 10, 10, bok_kwadratu, tablica_p );
   
    glFlush();
    glutSwapBuffers();
}

void Timer( int value )
{
    if( start_pauza )
         przeliczanie_potencjalu( bok_kwadratu, tablica_p );
   
    Display();
   
    glutTimerFunc( 2, Timer, 0 );
}

// zmiana wielkości okna

void Reshape( int width, int height )
{
    glViewport( 0, 0, width, height );
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
   
    if( width < height && width > 0 )
         glFrustum( left, right, bottom * height / width, top * height / width, near, far );
    else
   
    if( width >= height && height > 0 )
         glFrustum( left * width / height, right * width / height, bottom, top, near, far );
   
    Display();
}

//obssluga startu i pauzy animacji
void SpecialKeys( int key, int x, int y )
{
    switch( key )
    {
    case GLUT_KEY_HOME:
        if( !start_pauza )
             start_pauza = true;
        else
             start_pauza = false;
       
        break;
    }
   
    // odrysowanie okna
    Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
}

int main( int argc, char * argv[] )
{
    srand( time( NULL ) );
    glutInit( & argc, argv );
    glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_ALPHA );
    glutInitWindowSize( 800, 600 );
    glutCreateWindow( "Potencjał" );
   
    glutSpecialFunc( SpecialKeys );
    glutDisplayFunc( Display );
    glutReshapeFunc( Reshape );
   
    glutTimerFunc( 20, Timer, 0 );
   
    glutMainLoop();
    return 0;
}