src/backdrop.cpp

Go to the documentation of this file.

#include "backdrop.h"

BACKDROP::BACKDROP()
{
        //TEXTURE_PATH = settings.GetDataDir() + "/tex";
        error_log.open("logs/backdrop.log");
        initdone = false;
        sky_tex_img = NULL;
}

extern bool verbose_output;
BACKDROP::~BACKDROP()
{
        if (verbose_output)
                cout << "backdrop deinit" << endl;
        
        error_log.close();
}

void BACKDROP::DeInit()
{
        if (initdone)
        {
                //glDeleteTextures(1, &sun_texture);
                //glDeleteTextures(1, &rain_texture);
                //glDeleteTextures(1, &cloud_texture);
                //glDeleteTextures(1, &moon_texture);
                //glDeleteTextures(1, &stars_texture);
                //glDeleteTextures(1, &sun_texture_ref);
                //glDeleteTextures(1, &sky_texture);
                
                sun_texture.Unload();           
                rain_texture.Unload();
                cloud_texture.Unload();
                moon_texture.Unload();
                stars_texture.Unload();
                sun_texture_ref.Unload();
                sky_texture.Unload();
                
                if (sky_tex_img)
                {
                        SDL_FreeSurface( sky_tex_img );
                }
                
                initdone = false;
        }
}

void BACKDROP::Init()
{
        fogdensity = 0.0005f;
        
        //*** Load Texture ***
        string filepath = "weather/star.png";
        sun_texture.Load(filepath, false);
        
        /*SDL_Surface *TextureImage[1];                                 // Create Storage Space For The Texture
        
        int format = GL_RGB;

        // Load The Bitmap, Check For Errors, If Bitmap's Not Found Quit
        if ((TextureImage[0]=IMG_Load(buffer)))
        {
                //SDL_SetAlpha(TextureImage[0], 0, 0);
                
                glGenTextures(1, &sun_texture);                                 // Create Texture
                
                // Create MipMapped Texture
                glBindTexture(GL_TEXTURE_2D, sun_texture);
                glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
                
                {
                        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
                        glTexImage2D( GL_TEXTURE_2D, 0, format, TextureImage[0]->w, TextureImage[0]->h, 0, format, GL_UNSIGNED_BYTE, TextureImage[0]->pixels );
                }
        }
        else
        {
                //quit, bitmap not found
                error_log << "Could not find texture: " << buffer << "\n";
        }

        if (TextureImage[0])                                                            // If Texture Exists
        {
                // Free up any memory we may have used
        SDL_FreeSurface( TextureImage[0] );
        }*/
        
        
        filepath = "weather/star_reflection.png";
        //strcpy(buffer, filepath.c_str());
        //sun_texture_ref = utility.TexLoad(filepath, GL_RGB, false);
        sun_texture_ref.Load(filepath, false);
        /*format = GL_RGBA;

        // Load The Bitmap, Check For Errors, If Bitmap's Not Found Quit
        if ((TextureImage[0]=IMG_Load(buffer)))
        {
                //SDL_SetAlpha(TextureImage[0], 0, 0);
                
                glGenTextures(1, &sun_texture_ref);                                     // Create Texture
                
                // Create MipMapped Texture
                glBindTexture(GL_TEXTURE_2D, sun_texture_ref);
                glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
                
                {
                        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
                        glTexImage2D( GL_TEXTURE_2D, 0, format, TextureImage[0]->w, TextureImage[0]->h, 0, format, GL_UNSIGNED_BYTE, TextureImage[0]->pixels );
                }
        }
        else
        {
                //quit, bitmap not found
                error_log << "Could not find texture: " << buffer << "\n";
        }
        if (TextureImage[0])                                                            // If Texture Exists
        {
                // Free up any memory we may have used
        SDL_FreeSurface( TextureImage[0] );
        }*/
        
        string tex_size;
        settings.Get( "display.texture_size", tex_size );
        filepath = settings.GetFullDataPath("textures/" + tex_size + "/weather/clearSky-joe.png");
        //strcpy(buffer, filepath.c_str());

        //sky_texture = utility.TexLoad(filepath, GL_RGB, false);
        sky_texture.Load(filepath, false);
        sky_tex_img = IMG_Load(filepath.c_str());
        
        
        filepath = "weather/raindrop.tga";
        //strcpy(buffer, filepath.c_str());
        rain_texture.Load(filepath, false);
        /*format = GL_RGBA;
        // Load The Bitmap, Check For Errors, If Bitmap's Not Found Quit
        if ((TextureImage[0]=IMG_Load(buffer)))
        {
                //SDL_SetAlpha(TextureImage[0], 0, 0);
                
                glGenTextures(1, &rain_texture);                                        // Create Texture
                
                // Create Texture
                glBindTexture(GL_TEXTURE_2D, rain_texture);
                glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

                glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
                glTexImage2D( GL_TEXTURE_2D, 0, format, TextureImage[0]->w, TextureImage[0]->h, 0, format, GL_UNSIGNED_BYTE, TextureImage[0]->pixels );
        }
        else
        {
                error_log << "Could not find texture: " << buffer << "\n";
        }*/
        //cout << "boo" << endl;
        
        cloud_texture.Load("weather/clouds.png", true);
        
        
        //check for volumetric fog
        /*char extensions[ 16384 ];
        int i;
        int num_ext = 2;
    string extnames[num_ext];
        bool hasext[num_ext];
        bool extsufficient = true;
        extnames[0]     = "GL_ARB_fog_coord";
        extnames[1]     = "GL_ARB_multitexture";
        //extnames[2]   = "GL_NV_register_combiners";
        //extnames[3]   = "GL_NV_texture_shader";
    char *buf;
        
        for (i = 0; i < num_ext; i++)
                hasext[i] = false;

    sprintf( extensions, "%s", (char *)glGetString( GL_ARBENSIONS ) );
        //cout << extensions << endl;
    buf = strtok( extensions, " " );
    while( buf != NULL )
    {
                for (i = 0; i < num_ext; i++)
                {
                        if( !strcmp( extnames[i].c_str(), buf ) )
                        {
                                hasext[i] = true;
                        }
                }
                
                buf = strtok( NULL, " " );
    }
        
        for (i = 0; i < num_ext; i++)
        {
                if (!hasext[i])
                        extsufficient = false;
        }

        if (!extsufficient)
        {
        error_log << "You are missing required extensions.  Expect a crash.\n" << endl;
                error_log << "You need at least a Geforce 3 for these extensions.\n" << endl;
                for (i = 0; i < num_ext; i++)
                {
                        error_log << extnames[i] << ": ";
                        if (hasext[i])
                                error_log << "YES" << endl;
                        else
                                error_log << "NO" << endl;
                }
        }*/

        //set up fog
        float fogcolor[4] = {  0.53f, 0.74f, 0.91f, 0.0f  };
        glFogfv(GL_FOG_COLOR, fogcolor);
        glFogf(GL_FOG_START, 100);
        glFogf(GL_FOG_END, 1000);
        glFogf(GL_FOG_DENSITY, 0.0005f);
        //glFogi(GL_FOG_MODE, GL_LINEAR);
        glFogi(GL_FOG_MODE, GL_EXP);
        glEnable(GL_FOG);

        
        //set up fog
        /*                                                                                      // Enable Fog
        glFogi(GL_FOG_MODE, GL_LINEAR);                                                                         // Fog Fade Is Linear
        float fogcolor[4];
        fogcolor[0] = 0.09f;
        fogcolor[1] = 0.25f;
        fogcolor[2] = 0.38f;
        fogcolor[3] = 0.2f;
        int i;
        for (i = 0; i < 4; i++)
                fogcolor[i] *= 0.5f;
        glFogfv(GL_FOG_COLOR, fogcolor);
        glFogf(GL_FOG_START,  1.0f);                                                                            // Set The Fog Start
        glFogf(GL_FOG_END,    0.0f);                                                                            // Set The Fog End
        glHint(GL_FOG_HINT, GL_NICEST);                                                                         // Per-Pixel Fog Calculation
        glFogi(GL_FOG_COORDINATE_SOURCE_ARB, GL_FOG_COORDINATE_ARB);*/
        
        sunpos_lng = 0.0f;
        sunpos_lat = 0.7f;
        
        moonpos_lng = 0.0f;
        moonpos_lat = 0.2f;
        
        moon_texture.Load("weather/moon.png", false);
        stars_texture.Load("weather/stars.png", false);
}

void BACKDROP::Draw(VERTEX tersize)
{
        //setup gl flags
        //glEnable(GL_BLEND);
        glDisable(GL_BLEND);
        glDisable( GL_TEXTURE_2D );
        glDisable( GL_LIGHTING);
        //glDisable(GL_FOG);
        //glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
        glDisable(GL_DEPTH_TEST);
        /*glBegin(GL_QUADS);
        
        //setup custom vars
        float watercol[4];
        watercol[0] = 0.0f;
        watercol[1] = 0.0f;
        watercol[2] = 0.0f;
        watercol[3] = 1.0f;
        glColor4fv(watercol);
        //float yheight = 3.9f;
        float yheightb = 0.1f;
        float xw2 = 5000;
        float yw2 = 5000;
        float xw1 = tersize.x;
        float yw1 = tersize.z;
        
        //draw caustics
        float yheightf = 0.0f;
        float counter = 0.0001f;
        float yheight;
        float ystart = 0.0f;

        yheightf = ystart;
        yheight = yheightf*tersize.y;
        glColor4fv(watercol);
        //glNormal3f(0,1,0);
        glVertex3f(-xw2,yheight,-yw2);
        glVertex3f(-xw2,yheight,yw2);
        glVertex3f(xw2,yheight,yw2);
        glVertex3f(xw2,yheight,-yw2);
        
        glEnd();*/

        glEnable(GL_FOG);
        glEnable(GL_DEPTH_TEST);
        glDisable(GL_BLEND);
        glColor4f(1.0f,1.0f,1.0f,1.0f);
        glEnable( GL_TEXTURE_2D );
        glEnable( GL_LIGHTING);
}

void BACKDROP::DrawSky(double daytime, float transparency)
{
        daytime_cache = daytime;
        sunpos_lat = daytime*3.141593f*2.0f;
        
        moonpos_lat = (daytime+0.4)*3.141593f*2.0f;
        
        //setup gl flags
        glPushAttrib(GL_ALL_ATTRIB_BITS);
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glEnable( GL_TEXTURE_2D );
        glDisable(GL_LIGHTING);
        glDisable(GL_DEPTH_TEST);
        glDisable(GL_FOG);
        
        QUATERNION cor, qx, qy, qz, qt;
        double temp_radius, temp_long, temp_lat;
        GLdouble temp_matrix[16];
        temp_radius = sqrt(cam.position.x*cam.position.x+cam.position.z*cam.position.z+(cam.position.y+EARTH_RADIUS)*(cam.position.y+EARTH_RADIUS));
        temp_long = atan2((double)(cam.position.y+EARTH_RADIUS),(double)cam.position.x);
        temp_lat = acos(cam.position.z/temp_radius);
        temp_lat -= 1.570796f;
        temp_long -= 1.570796f;
        qz.SetAxisAngle(-temp_long, 0, 0, 1);
        qx.SetAxisAngle(temp_lat, 1, 0, 0);
        qt = qx*qz;
        qt.GetMat(temp_matrix);
        
        DrawStars(daytime, transparency, temp_matrix);
        DrawMoon(daytime, transparency, temp_matrix);
        DrawSkyGradient(daytime, transparency, temp_matrix);
        /*glColorMask(1,1,1,1);
        glClearColor( 0.0f, 0.0f, 0.0f, 0.0f ); 
        glClear(GL_COLOR_BUFFER_BIT);*/
        DrawSun(daytime, transparency, temp_matrix);
        DrawClouds(daytime, transparency, temp_matrix);
        
        glPopAttrib();
}

void BACKDROP::DrawSkyGradient(double daytime, float transparency, GLdouble *temp_matrix)
{
        //setup gl flags
        glPushAttrib(GL_ALL_ATTRIB_BITS);
        glEnable(GL_BLEND);
        //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glBlendFunc(GL_SRC_ALPHA, GL_DST_COLOR);
        glEnable( GL_TEXTURE_2D );
        glDisable(GL_LIGHTING);
        glDisable(GL_DEPTH_TEST);
        glDisable(GL_FOG);
        
        //variables to help with hemisphere generation
        int lng,lat;
        int num_longitudes = 12;
        int num_lattitudes = 12;
        float hem_radius = 10.0f;
        //float safety_factor = 0.15f;
        float safety_factor = 0.0f;
        float hem_height = hem_radius;
        float pi = 3.141593f;
        
        int i;
        
        glPushMatrix();
        glMultMatrixd(temp_matrix);
        
        float colhoriz[3], colzenith[3];
        colhoriz[0] = .53f;
        colhoriz[1] = .74f;
        colhoriz[2] = .91f;
        
        /*colzenith[0] = 0.0f;
        colzenith[1] = 100.0f/255.0f;
        colzenith[2] = 200.0f/255.0f;*/
        colzenith[0] = 0.0f;
        colzenith[1] = 50.0f/255.0f;
        colzenith[2] = 100.0f/255.0f;
        
        VERTEX * oldset;
        VERTEX * curset;
        oldset = new VERTEX [num_longitudes+1];
        curset = new VERTEX [num_longitudes+1];
        VERTEX oldrot;
        
        QUATERNION qrot, qtemp;
        
        sky_texture.Activate();
        
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        
        glBegin(GL_QUADS);

        int num_repeats = 0;
        int old_repeats = 0;
        
        glColor4f(1.0f,1.0f,1.0f,transparency);

        int pass;
        for (pass = 0; pass < 2; pass++)
        {
                for (lat = 0; lat <= num_lattitudes; lat++)
                {
                        qrot.SetAxisAngle((pi/2.0f)*((float)lat/(float)num_lattitudes), 0, 0, 1);
                        VERTEX rotvec;
                        rotvec.x = hem_radius;
                        rotvec = qrot.RotateVec(rotvec);
                        
                        for (lng = 0; lng <= num_longitudes; lng++)
                        {
                                VERTEX currot;
                                float curcol[4];
                                
                                qtemp.SetAxisAngle(2.0f*pi*((float)lng/(float)num_longitudes), 0, 1, 0);
                                currot = qtemp.RotateVec(rotvec);
                                //cout << currot.x << "," << currot.y << "," << currot.z << endl;
                                
                                if (lat > 0 && lng > 0)
                                {
                                        //glColor4f(0.53f, 0.74f, 0.91f, 1.0f);
                                        float rheight;
        
                                        rheight = 1.0f-currot.y/hem_height;
                                        //rheight = (rheight-1)*(rheight-1)*(rheight-1)+1;
        
                                        for (i = 0; i < 3; i++)
                                                curcol[i] = colhoriz[i]*(1.0f-rheight)+colzenith[i]*rheight;
                                        //glColor4fv(curcol);
                                        glTexCoord2f(daytime,rheight);
                                        
                                        glVertex3f(oldrot.x, oldrot.y-safety_factor, oldrot.z);
                                        glVertex3f(currot.x, currot.y-safety_factor, currot.z);
        
                                        rheight = 1.0f-oldset[lng].y/hem_height;
                                        //rheight = (rheight-1)*(rheight-1)*(rheight-1)+1;
                                        
                                        for (i = 0; i < 3; i++)
                                                curcol[i] = colhoriz[i]*(1.0f-rheight)+colzenith[i]*(rheight);
                                        //glColor4fv(curcol);
                                        glTexCoord2f(daytime,rheight);  
                                        glVertex3f(oldset[lng].x, oldset[lng].y-safety_factor, oldset[lng].z);
                                        glVertex3f(oldset[lng-1].x, oldset[lng-1].y-safety_factor, oldset[lng-1].z);
                                }
                                
                                oldrot = currot;
                                curset[lng] = currot;
                        }
                        
                        VERTEX * tptr = curset;
                        curset = oldset;
                        oldset = tptr;
                        old_repeats = num_repeats;
                }
                
                hem_radius = -hem_radius;
                hem_height = hem_radius;
        }
        
        delete [] curset;
        delete [] oldset;
        
        glEnd();
        glPopMatrix();
        glPopAttrib();
}

void BACKDROP::DrawSun(double daytime, float transparency, GLdouble *temp_matrix)
{
        int i;
        float hem_radius = 10.0f;
        float hem_height = hem_radius;
        
        //okay, now plop on the SUN
        glPushAttrib(GL_ALL_ATTRIB_BITS);
        glEnable(GL_TEXTURE_2D);
        glEnable(GL_BLEND);
        glClear(GL_DEPTH_BUFFER_BIT);
        float sunsize = 2.0f;
        /*float reflection_elongation_y = 1.0f; //how much the sun is stretched by in
                                                                                // the reflection rendering
        float reflection_elongation_x = 1.0f;*/
        float sunsize_x = sunsize;
        float sunsize_y = sunsize;
        
        VERTEX sunquad[4];
        for (i = 0; i < 4; i++) //generate the sun quad
        {
                if (i == 0 || i == 3)
                {
                        sunquad[i].y = -sunsize_y;
                }
                else
                {
                        sunquad[i].y = sunsize_y; //only elongate in -y direction
                }
                if (i < 2)
                        sunquad[i].x = -sunsize_x;
                else
                        sunquad[i].x = sunsize_x;
        }
        QUATERNION sunquat, sunquat2;
        //float sunheight = atan2(LightPosition[1],LightPosition[2]); //sun angular height in radians
        float transform_matrix[16];
        glPushMatrix();
        glMultMatrixd(temp_matrix);
        
        //float sundir = atan2(LightPosition[0],LightPosition[2]);
        sunquat.SetAxisAngle(sunpos_lng+3.141593/2.0, 0, 0, 1);
        sunquat.GetMat(transform_matrix); //crank it around the sky
        glMultMatrixf(transform_matrix);
        
        sunquat2.SetAxisAngle(sunpos_lat, 0, 1, 0);
        sunquat2.GetMat(transform_matrix); //crank it up into the sky
        glMultMatrixf(transform_matrix);
        
        glTranslatef(hem_height,0,0); //put the sun at an arm's length

        //compensate
        sunquat2.ReturnConjugate().GetMat(transform_matrix);
        glMultMatrixf(transform_matrix);
        
        //if (reflection)
        //      sunquat.GetMat(transform_matrix);
        //else  
                sunquat.ReturnConjugate().GetMat(transform_matrix);
        glMultMatrixf(transform_matrix);

        cam.dir.ReturnConjugate().GetMat(transform_matrix); //set the sun's orientation to the camera's direction
        glMultMatrixf(transform_matrix);
        
        glColor4f(1.0f, 1.0f, 1.0f, transparency);
        //glBindTexture(GL_TEXTURE_2D, sun_texture_ref);
        sun_texture_ref.Activate();
        glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
        //then draw the thing
        glBegin(GL_QUADS);
        for (i = 0; i < 4; i++)
        {
                switch(i)
                {
                        case 0:
                                glTexCoord2f(0,0);
                                break;
                        case 1:
                                glTexCoord2f(1,0);
                                break;
                        case 2:
                                glTexCoord2f(1,1);
                                break;
                        case 3:
                                glTexCoord2f(0,1);
                                break;
                }
                
                glVertex3f(sunquad[i].x, sunquad[i].y, sunquad[i].z);
        }
        glEnd();
        glPopMatrix();
        
        glPopAttrib();
}

void BACKDROP::DrawClouds(double daytime, float transparency, GLdouble *temp_matrix)
{
        //draw the cloud layer
        cloudthresh = weathersystem.GetCloudCover();
        glPushAttrib(GL_ALL_ATTRIB_BITS);
        glPushMatrix();
        glEnable(GL_TEXTURE_2D);
        glEnable(GL_BLEND);
        
        glEnable(GL_FOG);
        float oldfog = fogdensity;
        SetFogStrength(fogdensity*300.0f);
        RefreshFog();

        glClear(GL_DEPTH_BUFFER_BIT);
        glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
        //glBlendFunc( GL_SRC_ALPHA, GL_ONE );
        float origalpha = transparency;
        float fadealpha = 1.0f;
        float cloudcolor = sin(sunpos_lat);
        float cloudscale = 20000.0f;//this should be the same as the variable
                                                           // of the same name in terrain.drawsub() for the
                                                           // the clouds to line up.
        //the higher the number, the higher the clouds seem.  don't set above 10.
        // in fact, keep it at 1.0, always.
        float cloudrep = 1.0f;
        float cloudoffset_x, cloudoffset_z;
        cloudoffset_x = windx;//10.0f;
        //0.1 is the glscale y factor
        cloudoffset_z = windz;//10.0f;
        cloudcolor += 0.4f;
        if (cloudcolor < 0)
                cloudcolor *= 10.0f; //to simulate sun disappearing behind horizon
        if (cloudcolor < 0.1f)
                cloudcolor = 0.1f;
        if (cloudcolor > 1.0f)
                cloudcolor = 1.0f;
        glColor4f(cloudcolor, cloudcolor, cloudcolor, origalpha);
        glTranslatef(0,-0.4f,0);
        
        /*temp_radius = sqrt(cam.position.x*cam.position.x+cam.position.z*cam.position.z+(cam.position.y+EARTH_RADIUS)*(cam.position.y+EARTH_RADIUS));
        temp_long = atan2((double)(cam.position.y+EARTH_RADIUS),(double)cam.position.x);
        temp_lat = acos(cam.position.z/temp_radius);
        temp_lat -= 1.570796f;
        temp_long -= 1.570796f;
        qz.SetAxisAngle(-temp_long, 0, 0, 1);
        qx.SetAxisAngle(temp_lat, 1, 0, 0);
        qt = qx*qz;
        qt.GetMat(temp_matrix);*/
        glMultMatrixd(temp_matrix);
        
        glScalef(1.0,0.1f,1.0f);
        //glTranslatef(0,-15.0f,0);
        //glScalef(10.0,10.0f,10.0f);
        int num_repeats = 0;
        int old_repeats = 0;
        int num_longitudes = 12;
        int num_lattitudes = 12;
        //glBindTexture(GL_TEXTURE_2D, cloud_texture);
        cloud_texture.Activate();
        
        VERTEX * oldset = new VERTEX [num_longitudes+1];
        VERTEX * curset = new VERTEX [num_longitudes+1];
        float hem_height = 10.0f;
        float hem_radius = 10.0f;
        int pass, lat, lng;
        QUATERNION qrot, qtemp;
        VERTEX oldrot;
        float safety_factor = 0.0f;
        float pi = 3.141593f;
        glBegin(GL_QUADS);
        for (pass = 0; pass < 2; pass++)
        {
                for (lat = 0; lat <= num_lattitudes; lat++)
                {
                        if (pass == 0)
                                qrot.SetAxisAngle((pi/2.0f)*((float)lat/(float)num_lattitudes), 0, 1, 0);
                        else
                                qrot.SetAxisAngle((pi/2.0f)*((float)lat/(float)num_lattitudes), 0, -1, 0);
                        VERTEX rotvec;
                        rotvec.z = hem_radius;
                        rotvec = qrot.RotateVec(rotvec);
                        
                        for (lng = 0; lng <= num_longitudes; lng++)
                        {
                                VERTEX currot;
                                float curcol[4];
                                
                                curcol[4] = 1.0f;
                                
                                //if (pass == 0)
                                        qtemp.SetAxisAngle(2.0f*pi*((float)lng/(float)num_longitudes), 1, 0, 0);
                                //else
                                //      qtemp.SetAxisAngle(2.0f*pi*((float)lng/(float)num_longitudes), 0, 0, -1);
                                currot = qtemp.RotateVec(rotvec);

                                if (lat > 0 && lng > 0)
                                {
                                        float rheight;

                                        float vtile = 1.0f;
                                        //float utile = 4.0f;
                                        
                                        float texu, texv, cx, cv;
                                        
                                        rheight = 1.0f-vtile*currot.x/hem_height;
                                        
                                        float fadeterm = 25.0f;
                                        float alphafactor;
                                        alphafactor = oldrot.x*oldrot.x+oldrot.z*oldrot.z;
                                        alphafactor /= (hem_radius*hem_radius-fadeterm);
                                        if (alphafactor > 1)
                                                alphafactor = 1.0f;
                                        alphafactor = 1.0f - alphafactor;
                                        glColor4f(cloudcolor, cloudcolor, cloudcolor, 
                                                alphafactor*origalpha+(1.0f-alphafactor)*fadealpha);
                                        
                                        //texu = utile*(lng-1)/(float)num_longitudes+cloudoffset_x;
                                        //texv = rheight+cloudoffset_z;
                                        cx = oldrot.x;
                                        cv = oldrot.z;
                                        texu = (cx/hem_height+cloudoffset_x)*cloudrep+(-cam.position.x/cloudscale)/cloudrep;
                                        texv = (cv/hem_height+cloudoffset_z)*cloudrep+(-cam.position.z/cloudscale)/cloudrep;
                                        glTexCoord2f(texu, texv);
                                        glVertex3f(oldrot.x, oldrot.y-safety_factor, oldrot.z);
                                        
                                        alphafactor = currot.x*currot.x+currot.z*currot.z;
                                        alphafactor /= (hem_radius*hem_radius-fadeterm);
                                        if (alphafactor > 1)
                                                alphafactor = 1.0f;
                                        alphafactor = 1.0f - alphafactor;
                                        glColor4f(cloudcolor, cloudcolor, cloudcolor, 
                                                alphafactor*origalpha+(1.0f-alphafactor)*fadealpha);
                                        
                                        //texu = utile*(lng)/(float)num_longitudes+cloudoffset_x;
                                        //texv = rheight+cloudoffset_z;
                                        cx = currot.x;
                                        cv = currot.z;
                                        texu = (cx/hem_height+cloudoffset_x)*cloudrep+(-cam.position.x/cloudscale)/cloudrep;
                                        texv = (cv/hem_height+cloudoffset_z)*cloudrep+(-cam.position.z/cloudscale)/cloudrep;
                                        glTexCoord2f(texu, texv);
                                        glVertex3f(currot.x, currot.y-safety_factor, currot.z);
        
                                        rheight = 1.0f-vtile*oldset[lng].x/hem_height;

                                        alphafactor = oldset[lng].x*oldset[lng].x+oldset[lng].z*oldset[lng].z;
                                        alphafactor /= (hem_radius*hem_radius-fadeterm);
                                        if (alphafactor > 1)
                                                alphafactor = 1.0f;
                                        alphafactor = 1.0f - alphafactor;
                                        glColor4f(cloudcolor, cloudcolor, cloudcolor, 
                                                alphafactor*origalpha+(1.0f-alphafactor)*fadealpha);
                                        
                                        //texu = utile*(lng)/(float)num_longitudes+cloudoffset_x;
                                        //texv = rheight+cloudoffset_z;
                                        cx = oldset[lng].x;
                                        cv = oldset[lng].z;
                                        texu = (cx/hem_height+cloudoffset_x)*cloudrep+(-cam.position.x/cloudscale)/cloudrep;
                                        texv = (cv/hem_height+cloudoffset_z)*cloudrep+(-cam.position.z/cloudscale)/cloudrep;
                                        glTexCoord2f(texu, texv);
                                        glVertex3f(oldset[lng].x, oldset[lng].y-safety_factor, oldset[lng].z);
                                        
                                        alphafactor = oldset[lng-1].x*oldset[lng-1].x+oldset[lng-1].z*oldset[lng-1].z;
                                        alphafactor /= (hem_radius*hem_radius-fadeterm);
                                        if (alphafactor > 1)
                                                alphafactor = 1.0f;
                                        alphafactor = 1.0f - alphafactor;
                                        glColor4f(cloudcolor, cloudcolor, cloudcolor, 
                                                alphafactor*origalpha+(1.0f-alphafactor)*fadealpha);
                                        
                                        //texu = utile*(lng-1)/(float)num_longitudes+cloudoffset_x;
                                        //texv = rheight+cloudoffset_z;
                                        cx = oldset[lng-1].x;
                                        cv = oldset[lng-1].z;
                                        texu = (cx/hem_height+cloudoffset_x)*cloudrep+(-cam.position.x/cloudscale)/cloudrep;
                                        texv = (cv/hem_height+cloudoffset_z)*cloudrep+(-cam.position.z/cloudscale)/cloudrep;
                                        glTexCoord2f(texu, texv);
                                        glVertex3f(oldset[lng-1].x, oldset[lng-1].y-safety_factor, oldset[lng-1].z);
                                }
                                
                                oldrot = currot;
                                curset[lng] = currot;
                        }
                        
                        VERTEX * tptr = curset;
                        curset = oldset;
                        oldset = tptr;
                        old_repeats = num_repeats;
                }

                //hem_height = -hem_height;
                //hem_radius = -hem_radius;
        }
        delete [] curset;
        delete [] oldset;
        glEnd();
        
        /*GLUquadricObj *quadratic;
        quadratic=gluNewQuadric();                      // Create A Pointer To The Quadric Object ( NEW )
        gluQuadricNormals(quadratic, GLU_SMOOTH);       // Create Smooth Normals ( NEW )
        gluQuadricTexture(quadratic, GL_TRUE);          // Create Texture Coords ( NEW )
        gluSphere(quadratic,10.0f,32,32);
        gluDeleteQuadric(quadratic);*/
        
        SetFogStrength(oldfog);
        RefreshFog();
        glPopAttrib();
        glPopMatrix();
}

void BACKDROP::DrawStars(double daytime, float transparency, GLdouble *temp_matrix)
{
        //draw the star layer
        glPushAttrib(GL_ALL_ATTRIB_BITS);
        glPushMatrix();
        glEnable(GL_TEXTURE_2D);
        glEnable(GL_BLEND);
        
        glClear(GL_DEPTH_BUFFER_BIT);
        glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
        //glBlendFunc( GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR );
        //glBlendFunc( GL_ONE_MINUS_DST_ALPHA, GL_DST_ALPHA );
        //glBlendFunc( GL_SRC_ALPHA, GL_ONE );
        //float cloudscale = 20000.0f;//this should be the same as the variable
                                                           // of the same name in terrain.drawsub() for the
                                                           // the clouds to line up.
        //the higher the number, the higher the clouds seem.  don't set above 10.
        // in fact, keep it at 1.0, always.
        //float cloudrep = 40.0f;
        //float cloudtile = 10.0f;
        //cloudtile = 2.0f;
        //cloudscale = 1000.0f;
        float fogcolor[4];
        GetSkyColor(fogcolor);
        glColor4f(1.0,1.0,1.0,1.0-fogcolor[3]);
        glTranslatef(0,-0.4f,0);
        
        /*temp_radius = sqrt(cam.position.x*cam.position.x+cam.position.z*cam.position.z+(cam.position.y+EARTH_RADIUS)*(cam.position.y+EARTH_RADIUS));
        temp_long = atan2((double)(cam.position.y+EARTH_RADIUS),(double)cam.position.x);
        temp_lat = acos(cam.position.z/temp_radius);
        temp_lat -= 1.570796f;
        temp_long -= 1.570796f;
        qz.SetAxisAngle(-temp_long, 0, 0, 1);
        qx.SetAxisAngle(temp_lat, 1, 0, 0);
        qt = qx*qz;
        qt.GetMat(temp_matrix);*/
        glMultMatrixd(temp_matrix);
        
        //glScalef(1.0,0.1f,1.0f);
        glScalef(1.0,1.0f,1.0f);
        
        //glBindTexture(GL_TEXTURE_2D, stars_texture);
        stars_texture.Activate();
        glMatrixMode(GL_TEXTURE);
        glLoadIdentity();
        glScalef(10.0f,10.0f,10.0f);
        
        glMatrixMode(GL_MODELVIEW);
        glRotatef(90,1,0,0);
        GLUquadricObj *quadratic;
        quadratic=gluNewQuadric();
        gluQuadricTexture(quadratic, GL_TRUE);
        gluSphere(quadratic,1.0f,32,32);
        gluDeleteQuadric(quadratic);
        
        glMatrixMode(GL_TEXTURE);
        glLoadIdentity();
        glMatrixMode(GL_MODELVIEW);
        
        //glTranslatef(0,-15.0f,0);
        //glScalef(10.0,10.0f,10.0f);
        /*int num_repeats = 0;
        int old_repeats = 0;
        int num_longitudes = 12;
        int num_lattitudes = 12;
        glBindTexture(GL_TEXTURE_2D, stars_texture);
        float cloudoffset_x, cloudoffset_z;
        cloudoffset_x = cloudoffset_z = 0.0f;
        VERTEX * oldset = new VERTEX [num_longitudes+1];
        VERTEX * curset = new VERTEX [num_longitudes+1];
        float hem_height = 10.0f;
        float hem_radius = 10.0f;
        int pass, lat, lng;
        QUATERNION qrot, qtemp;
        VERTEX oldrot;
        float safety_factor = 0.0f;
        float pi = 3.141593f;
        glBegin(GL_QUADS);
        for (pass = 0; pass < 2; pass++)
        {
                for (lat = 0; lat <= num_lattitudes; lat++)
                {
                        if (pass == 0)
                                qrot.SetAxisAngle((pi/2.0f)*((float)lat/(float)num_lattitudes), 0, 1, 0);
                        else
                                qrot.SetAxisAngle((pi/2.0f)*((float)lat/(float)num_lattitudes), 0, -1, 0);
                        VERTEX rotvec;
                        rotvec.z = hem_radius;
                        rotvec = qrot.RotateVec(rotvec);
                        
                        for (lng = 0; lng <= num_longitudes; lng++)
                        {
                                VERTEX currot;
                                float curcol[4];
                                
                                curcol[4] = 1.0f;
                                
                                //if (pass == 0)
                                        qtemp.SetAxisAngle(2.0f*pi*((float)lng/(float)num_longitudes), 1, 0, 0);
                                //else
                                //      qtemp.SetAxisAngle(2.0f*pi*((float)lng/(float)num_longitudes), 0, 0, -1);
                                currot = qtemp.RotateVec(rotvec);

                                if (lat > 0 && lng > 0)
                                {
                                        float rheight;

                                        float vtile = 1.0f;
                                        //float vtile = 0.5f;
                                        //float utile = 4.0f;
                                        
                                        float texu, texv, cx, cv;
                                        
                                        rheight = 1.0f-vtile*currot.x/hem_height;
                                        
                                        float fadeterm = 25.0f;
                                        float alphafactor;
                                        alphafactor = oldrot.x*oldrot.x+oldrot.z*oldrot.z;
                                        alphafactor /= (hem_radius*hem_radius-fadeterm);
                                        if (alphafactor > 1)
                                                alphafactor = 1.0f;
                                        alphafactor = 1.0f - alphafactor;
                                        //glColor4f(cloudcolor, cloudcolor, cloudcolor, 
                                                //alphafactor*origalpha+(1.0f-alphafactor)*fadealpha);
                                        
                                        //texu = utile*(lng-1)/(float)num_longitudes+cloudoffset_x;
                                        //texv = rheight+cloudoffset_z;
                                        cx = oldrot.x;
                                        cv = oldrot.z;
                                        texu = (cx/hem_height+cloudoffset_x)*cloudtile+(-cam.position.x/cloudscale)/cloudtile;
                                        texv = (cv/hem_height+cloudoffset_z)*cloudtile+(-cam.position.z/cloudscale)/cloudtile;
                                        glTexCoord2f(texu, texv);
                                        glVertex3f(oldrot.x, oldrot.y-safety_factor, oldrot.z);
                                        
                                        alphafactor = currot.x*currot.x+currot.z*currot.z;
                                        alphafactor /= (hem_radius*hem_radius-fadeterm);
                                        if (alphafactor > 1)
                                                alphafactor = 1.0f;
                                        alphafactor = 1.0f - alphafactor;
                                        //glColor4f(cloudcolor, cloudcolor, cloudcolor, 
                                                //alphafactor*origalpha+(1.0f-alphafactor)*fadealpha);
                                        
                                        //texu = utile*(lng)/(float)num_longitudes+cloudoffset_x;
                                        //texv = rheight+cloudoffset_z;
                                        cx = currot.x;
                                        cv = currot.z;
                                        texu = (cx/hem_height+cloudoffset_x)*cloudtile+(-cam.position.x/cloudscale)/cloudtile;
                                        texv = (cv/hem_height+cloudoffset_z)*cloudtile+(-cam.position.z/cloudscale)/cloudtile;
                                        glTexCoord2f(texu, texv);
                                        glVertex3f(currot.x, currot.y-safety_factor, currot.z);
        
                                        rheight = 1.0f-vtile*oldset[lng].x/hem_height;

                                        alphafactor = oldset[lng].x*oldset[lng].x+oldset[lng].z*oldset[lng].z;
                                        alphafactor /= (hem_radius*hem_radius-fadeterm);
                                        if (alphafactor > 1)
                                                alphafactor = 1.0f;
                                        alphafactor = 1.0f - alphafactor;
                                        //glColor4f(cloudcolor, cloudcolor, cloudcolor, 
                                                //alphafactor*origalpha+(1.0f-alphafactor)*fadealpha);
                                        
                                        //texu = utile*(lng)/(float)num_longitudes+cloudoffset_x;
                                        //texv = rheight+cloudoffset_z;
                                        cx = oldset[lng].x;
                                        cv = oldset[lng].z;
                                        texu = (cx/hem_height+cloudoffset_x)*cloudtile+(-cam.position.x/cloudscale)/cloudtile;
                                        texv = (cv/hem_height+cloudoffset_z)*cloudtile+(-cam.position.z/cloudscale)/cloudtile;
                                        glTexCoord2f(texu, texv);
                                        glVertex3f(oldset[lng].x, oldset[lng].y-safety_factor, oldset[lng].z);
                                        
                                        alphafactor = oldset[lng-1].x*oldset[lng-1].x+oldset[lng-1].z*oldset[lng-1].z;
                                        alphafactor /= (hem_radius*hem_radius-fadeterm);
                                        if (alphafactor > 1)
                                                alphafactor = 1.0f;
                                        alphafactor = 1.0f - alphafactor;
                                        //glColor4f(cloudcolor, cloudcolor, cloudcolor, 
                                                //alphafactor*origalpha+(1.0f-alphafactor)*fadealpha);
                                        
                                        //texu = utile*(lng-1)/(float)num_longitudes+cloudoffset_x;
                                        //texv = rheight+cloudoffset_z;
                                        cx = oldset[lng-1].x;
                                        cv = oldset[lng-1].z;
                                        texu = (cx/hem_height+cloudoffset_x)*cloudtile+(-cam.position.x/cloudscale)/cloudtile;
                                        texv = (cv/hem_height+cloudoffset_z)*cloudtile+(-cam.position.z/cloudscale)/cloudtile;
                                        glTexCoord2f(texu, texv);
                                        glVertex3f(oldset[lng-1].x, oldset[lng-1].y-safety_factor, oldset[lng-1].z);
                                }
                                
                                oldrot = currot;
                                curset[lng] = currot;
                        }
                        
                        VERTEX * tptr = curset;
                        curset = oldset;
                        oldset = tptr;
                        old_repeats = num_repeats;
                }

                //hem_height = -hem_height;
                //hem_radius = -hem_radius;
        }
        delete [] curset;
        delete [] oldset;
        glEnd();*/
        
        /*GLUquadricObj *quadratic;
        quadratic=gluNewQuadric();                      // Create A Pointer To The Quadric Object ( NEW )
        gluQuadricNormals(quadratic, GLU_SMOOTH);       // Create Smooth Normals ( NEW )
        gluQuadricTexture(quadratic, GL_TRUE);          // Create Texture Coords ( NEW )
        gluSphere(quadratic,10.0f,32,32);
        gluDeleteQuadric(quadratic);*/
        
        glPopAttrib();
        glPopMatrix();
}

void BACKDROP::RefreshFog()
{
        //set up fog
        float fogcolor[4];
        GetHorizonColor(fogcolor);
        fogcolor[3] = 0.0f;
        
        //desaturate fog based on cloud cover
        float colmean = (fogcolor[0] + fogcolor[1] + fogcolor[2])/3.0f;
        float cloudiness;
        if (cloudthresh >= 0)
                cloudiness = 0.0f;
        else
                cloudiness = -(cloudthresh/100.0f); //decrease 50.0f to make the fog
                                                                                        //desaturate faster
        
        //clamp
        if (cloudiness > 1.0f)
                cloudiness = 1.0f;
        if (cloudiness < 0.0f)
                cloudiness = 0.0f;
        
        int i;
        for (i = 0; i < 3; i++)
        {
                fogcolor[i] = fogcolor[i]*(1.0f-cloudiness) + colmean*cloudiness;
        }
        
        glFogfv(GL_FOG_COLOR, fogcolor);
        glFogf(GL_FOG_DENSITY, fogdensity);
        glFogi(GL_FOG_MODE, GL_EXP);
        glEnable(GL_FOG);
}

struct pix24
{
        unsigned char r;
        unsigned char g;
        unsigned char b;
};

struct pix32
{
        unsigned char r;
        unsigned char g;
        unsigned char b;
        unsigned char a;
};

void BACKDROP::GetHorizonColor(float * color3)
{
        /*color3[0] = 0.53f;
        color3[1] = 0.74f;
        color3[2] = 0.91f;*/
        
        struct pix32 * pix;
                
        pix = (struct pix32 *) sky_tex_img->pixels;
        
        float dx;
        int x;
        int sky_tex_size = 16;
        dx = (daytime_cache*sky_tex_size);
        x = (int)dx;
        dx = dx - x;
        x %= sky_tex_size;
        int idx1 = x + 15*sky_tex_size;
        x++;
        x %= sky_tex_size;
        int idx2 = x + 15*sky_tex_size;
        
        color3[0] = (1.0f-dx)*pix[idx1].r/255.0f+dx*pix[idx2].r/255.0f;
        color3[1] = (1.0f-dx)*pix[idx1].g/255.0f+dx*pix[idx2].g/255.0f;
        color3[2] = (1.0f-dx)*pix[idx1].b/255.0f+dx*pix[idx2].b/255.0f;
        color3[3] = (1.0f-dx)*pix[idx1].a/255.0f+dx*pix[idx2].a/255.0f;
}

void BACKDROP::GetSkyColor(float * color3)
{
        /*color3[0] = 0.53f;
        color3[1] = 0.74f;
        color3[2] = 0.91f;*/
        
        struct pix32 * pix;
        
        pix = (struct pix32 *) sky_tex_img->pixels;
        
        float dx;
        int x;
        int sky_tex_size = 16;
        dx = (daytime_cache*sky_tex_size);
        x = (int)dx;
        dx = dx - x;
        x %= sky_tex_size;
        //int idx1 = x + 15*sky_tex_size;
        int idx1 = x;
        x++;
        x %= sky_tex_size;
        //int idx2 = x + 15*sky_tex_size;
        int idx2 = x;
        
        color3[0] = (1.0f-dx)*pix[idx1].r/255.0f+dx*pix[idx2].r/255.0f;
        color3[1] = (1.0f-dx)*pix[idx1].g/255.0f+dx*pix[idx2].g/255.0f;
        color3[2] = (1.0f-dx)*pix[idx1].b/255.0f+dx*pix[idx2].b/255.0f;
        color3[3] = (1.0f-dx)*pix[idx1].a/255.0f+dx*pix[idx2].a/255.0f;
}

void BACKDROP::SetFogStrength(float density)
{
        fogdensity = density;
        glFogf(GL_FOG_DENSITY, fogdensity);
}

void BACKDROP::SetWindoffset(float windoffset_x, float windoffset_z)
{
        windx = windoffset_x;
        windz = windoffset_z;
}

void BACKDROP::SetCloudCover(int newcloudthresh)
{
        cloudthresh = newcloudthresh;
}

void BACKDROP::DrawRain(float day_time)
{
        glPushMatrix();
        glLoadIdentity();
        glPushAttrib(GL_ALL_ATTRIB_BITS);
        glDisable(GL_DEPTH_TEST);
        glEnable(GL_TEXTURE_2D);
        glEnable(GL_BLEND);
        glDisable(GL_FOG);
        glDisable(GL_LIGHTING);
        glTranslatef(0,0,-40.0f);
        //glBlendFunc(GL_ONE, GL_SRC_ALPHA)
        //glBindTexture(GL_TEXTURE_2D, rain_texture);
        rain_texture.Activate();
        glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
        glColor4f(1.0f,1.0f,1.0f,1.0f);
        glBegin(GL_TRIANGLES);
        
        VERTEX pos;
        float alpha;
        int numdrops = weathersystem.GetRainDrops();
        int i;
        
        VERTEX up, forward, right;
        up.y = 1.0f;
        up = cam.dir.RotateVec(up);
        up.y = sin(up.y);
        forward.z = 1.0f;
        forward = cam.dir.RotateVec(forward);
        if ((forward.y >= 0 && forward.z >= 0) || (forward.y < 0 && forward.z < 0))
                forward.y = 1.0f;
        else
                forward.y = -1.0f;
        
        float randperm;
        float lum;
        
        float dayout = day_time;
        float daythresh = 0.1f;
        if (dayout >= 0.5)
                dayout = 0.0f;
        if (dayout < 0.5f && dayout > 0.5f - daythresh)
                dayout = 0.5-dayout;
        dayout /= daythresh;
        if (dayout > 1.0f)
                dayout = 1.0f;
        dayout = dayout*0.75f+0.25f;
        
        for (i = 0; i < numdrops; i++)
        {
                pos.x = (rand()/(float)RAND_MAX-0.5f)*50.0f;
                pos.y = (rand()/(float)RAND_MAX-0.5f)*40.0f;
                pos.z = (rand()/(float)RAND_MAX);
                alpha = (rand()/(float)RAND_MAX)/4.0f + 0.2f;
                lum = (rand()/(float)RAND_MAX)/2.0f + 0.5f;
                lum *= dayout;
                glColor4f(lum,lum,lum,alpha);
                randperm = (rand()/(float)RAND_MAX-0.5f)*1.0f;
                DrawDrop(pos, randperm, up.y, forward.y);
        }
        
        glEnd();
        glPopAttrib();
        glPopMatrix();
}

void BACKDROP::DrawDrop(VERTEX pos, float rndperm, float yscale, float zheight)
{
        float dropwidth = 0.25f;
        bool negy;
        if (zheight >= 0)
                negy = false;
        else
                negy = true;
        
        float dropheight = 10.0f*pos.z*yscale;
        if (dropheight < 0.5f)
                dropheight = 0.5f;
        float xoffset;
        if (negy)
                xoffset = -(1.0f-yscale)*0.2f*pos.x*pos.z;
        else
                xoffset = (1.0f-yscale)*0.2f*pos.x*pos.z;
        
        glTexCoord2f(0,0);
        glVertex3f(pos.x-dropwidth, pos.y+dropheight, 0.0f);
        glTexCoord2f(0,1);
        glVertex3f(pos.x-dropwidth+rndperm+xoffset, pos.y-dropheight, 0.0f);
        glTexCoord2f(1,1);
        glVertex3f(pos.x+dropwidth+rndperm+xoffset, pos.y-dropheight, 0.0f);
}

void BACKDROP::DrawMoon(double daytime, float transparency, GLdouble *temp_matrix)
{
        int i;
        float hem_radius = 10.0f;
        float hem_height = hem_radius;
        
        //okay, now plop on the MOON
        glPushAttrib(GL_ALL_ATTRIB_BITS);
        glEnable(GL_TEXTURE_2D);
        //glEna