OpenGL heightmapa/bitmapa

Mam problem z heightmapami w Opengl. Kod poniżej poprawnie ładuje i wyświetla heightmapy mniejsze jednak przy większych pojawiają się błędy - mapa jest jakby na ukos. Gdzie może leżeć problem?

class Heightmapa
{
private:
    float ** mapa_wys;
    unsigned long roz_sz, roz_wys;
    unsigned textura;

public:
    void ZaladujHeightmape(char*, char*);
    void WyswietlHeightmape();
    ~Heightmapa();
};
void Heightmapa::ZaladujHeightmape(char * naz_h, char * naz_t)
{
    {


        unsigned rozmiar;

        unsigned char * dane;
        ifstream strum;

        strum.open(naz_h);
        if(!strum)
        {
            return;
        }

        strum.seekg(18);
        strum.read((char*)&roz_sz, 4);

        strum.seekg(22);
        strum.read((char*)&roz_wys, 4);

        strum.seekg(34);
        strum.read((char*)&rozmiar, 4);

        dane = new unsigned char[rozmiar];

        strum.seekg(54);
        strum.read((char*)dane, rozmiar);

        mapa_wys = new float*[roz_wys]; 
        for(int h = 0; h < roz_wys; ++h)
        {
            mapa_wys[h] = new float[roz_sz];
        }
        int i = 0;
        for (int j = 0; j < roz_wys; ++j) 
        {
            for(int k = 0; k < roz_sz; ++k)
            {
                mapa_wys[j][k] = dane[i];
                i+=3;
            }
        }
        ZaladujBitmape(naz_t, textura);

        delete[] dane;

        strum.close();
    }
}

void Heightmapa::WyswietlHeightmape()
{
    glPushMatrix();
    glBindTexture(GL_TEXTURE_2D, textura);
        glBegin(GL_TRIANGLES);
        for(int i = 0; i < roz_wys-1; ++i)
        {
            for(int j = 0; j < roz_sz-1; ++j)
            {
                  glTexCoord2f(0, 0);
                  glVertex3f(i, mapa_wys[i][j], j);
                  glTexCoord2f(0, 1);
                  glVertex3f((i+1), mapa_wys[(i+1)][j], j);
                  glTexCoord2f(1, 0);
                  glVertex3f(i, mapa_wys[i][(j+1)], (j+1));

                  glTexCoord2f(1, 0);
                  glVertex3f(i, mapa_wys[i][(j+1)], (j+1));
                  glTexCoord2f(0, 1);
                  glVertex3f((i+1), mapa_wys[(i+1)][j], j);
                  glTexCoord2f(1, 1);
                  glVertex3f((i+1), mapa_wys[(i+1)][(j+1)], (j+1));
            }
        }
        glEnd();
       glPopMatrix();
}
 

Przy jakich wielkościach pojawiają się błędy?

PS nie wykorzystuj polskiego nazewnictwa :P

Właśnie pokombinowałem z różnymi bitmapami i okazało się że nawet małe bitmapy mogą być źle wyświetlane np 263x65,207x200, z kolei bitmapa 196x188,200x200 działają poprawnie. A może problem nie jest związany z wielkością bitmapy a np. jej zawartością?

Z tego co napisales, @vernon, problem pojawia sie dla liczb nieparzystych.

Karta graficzna może mieć ograniczenia rozmiarów tekstury, np. żeby rozmiar był podzielny przez 2 albo przez 4, albo nawet że tekstura musi być kwadratowa.

Podobny problem mam z wczytywaniem samych bitmap - zależnie od rozmiaru mogą się źle wyświetlać.

Ok, problem rozwiązany odpowiedź znalazłem tu: http://forum.programuj.com/viewtopic.php?p=61790&sid=ced0d5a32f877f8b6c0db2f97799d68b tylko że nie rozumiem do końca o co w tym chodzi mógłby ktoś to wytłumaczyć?

Przede wszystkim nie wczytujesz pliku jako binarny.

strum.open(naz_h);

powinno wyglądać tak:

strum.open(naz_h, std::ios::binary);