Textures.cpp

#include "Textures.h"

GLuint Textures::tex_id[MAX_TEXTURES];

void Textures::Load ()
{
        PerlinNoise * perlin;

        glGenTextures(MAX_TEXTURES, tex_id);

        printf ("loading textures...\n");

        // first, load our only bitmap texture from disk
        if (!LoadBMP ("Textures\\Space4.bmp", tex_id[T_SPACE]))
        {printf ("Failed to load texture...\n");}

        printf ("generating textures...\n");

        // generate perlin noise textures
        perlin = new PerlinNoise (512, 512);
        perlin->SetBackgroundColor (1.0f, 0.5f, 0.5f, 1.0f);
        perlin->SetForegroundColor (0.0f, 0.1f, 0.8f, 1.0f);
        perlin->SetParameters (16.0, 0.5, 8, false);
        perlin->GenerateNoise ();
        perlin->TransformAB (2.0, 0.5, PerlinNoise::LinearTransform);
        perlin->FlushToColorBuffer ();
        CreatePerlinTexture (perlin, tex_id[T_PERLIN]);
        perlin->Push ();
                perlin->SetBackgroundColor (1.0f, 0.5f, 0.5f, 1.0f);
                perlin->SetForegroundColor (0.5f, 0.1f, 0.0f, 1.0f);
                perlin->SetParameters (4.0, 0.5, 8, false);
                perlin->GenerateNoise ();
                perlin->TransformAB (2.0, 0.5, PerlinNoise::LinearTransform);
                perlin->FlushToColorBuffer ();
                CreatePerlinTexture (perlin, tex_id[T_PERLIN2]);
                perlin->CombineColorBuffersAB (0.5, 0.5, PerlinNoise::WeightedSumCombiner);
        CreatePerlinTexture (perlin, tex_id[T_PERLIN3]);

        perlin->SetBackgroundColor (0.3f, 0.3f, 1.0f, 1.0f);
        perlin->SetForegroundColor (1.0f, 1.0f, 1.5f, 1.0f);
        perlin->SetParameters (20.0, 0.65, 8, false);
        perlin->GenerateNoise ();
        perlin->TransformAB (0.0f, 1.0f, PerlinNoise::RangeTransform);
        perlin->SmoothBorder (64);
        perlin->FlushToColorBuffer ();
        CreatePerlinTexture (perlin, tex_id[T_SKY]);

        delete perlin;
}

void Textures::Release ()
{
        glDeleteTextures (MAX_TEXTURES, tex_id);
}

GLuint Textures::GetId (int texture_id)
{
        return tex_id[texture_id];
}

bool Textures::LoadBMP (char * file_name, GLuint texture_id)
{
        FILE * file;
        BITMAPFILEHEADER header;
        BITMAPINFOHEADER info;
        GLubyte * raw_data;
        GLubyte BGR_swap;

        raw_data = NULL;
        file = NULL;

        file = fopen (file_name, "rb");

        if (file == NULL)
        {return NULL;}

        fread(&header, sizeof(BITMAPFILEHEADER), 1, file);

        if (header.bfType != 0x4D42)    // flag must have value 19778   
        {
                fclose(file);
                return false;
        }

        fread(&info, sizeof(BITMAPINFOHEADER), 1, file);

        if (info.biBitCount != 24)
        {
                printf ("Can only load bitmpas with 24-bit color depth\n");
                fclose (file);
                return false;
        }

        fseek(file, header.bfOffBits, SEEK_SET);

        info.biSizeImage = info.biWidth * info.biHeight * info.biBitCount / 8;

        raw_data = new GLubyte[info.biSizeImage];

        fread(raw_data, info.biSizeImage, 1, file);

        if (!raw_data)
        {
                fclose (file);
                return false;
        }

        for (unsigned int i = 0; i < info.biSizeImage; i+=3)
        {
                BGR_swap = raw_data[i];
                raw_data[i] = raw_data[i+2];
                raw_data[i+2] = BGR_swap;
        }

        // create texture now
        CreateTexture (texture_id, info.biWidth, info.biHeight, raw_data);

        // clean up ressources
        fclose (file);
        delete raw_data;

        return true;
}

void Textures::CreatePerlinTexture (PerlinNoise * perlin, GLuint texture_id)
{
        GLubyte * raw_data;
        int size_x, size_y;

        perlin->GetDimensions (size_x, size_y);
        raw_data = new GLubyte [size_x*size_y*3];
        perlin->ExportRGB256 (raw_data);
        CreateTexture (texture_id, size_x, size_y, raw_data);
        
        delete raw_data;
}

void Textures::CreateTexture (GLuint texture_id, int size_x, int size_y, GLubyte * raw_data)
{
        glBindTexture(GL_TEXTURE_2D, texture_id);
        gluBuild2DMipmaps (GL_TEXTURE_2D, 3, size_x, size_y, GL_RGB, GL_UNSIGNED_BYTE, raw_data);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}

---