Hemisphere.cpp

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
//    Scorched3D (c) 2000-2009
//
//    This file is part of Scorched3D.
//
//    Scorched3D is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    Scorched3D is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with Scorched3D; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
////////////////////////////////////////////////////////////////////////////////

#include <image/Image.h>
#include <GLEXT/GLState.h>
#include <common/Vector.h>
#include <sky/Hemisphere.h>
#include <common/Defines.h>
#include <vector>
#include <math.h>

void Hemisphere::draw(float radius, float radius2, 
        int heightSlices, int rotationSlices,
        int startHeightSlice, int startRotationSlice,
        int endHeightSlice, int endRotationSlice,
        bool inverse, unsigned int flags)
{
        glBegin(GL_QUAD_STRIP);
        const float maxTexCoord = 1.0f;
        for (int j=startHeightSlice; j<endHeightSlice; j++) 
        {
                float theta1 = j * HALFPI / float(heightSlices);
                float theta2 = (j + 1) * HALFPI / float(heightSlices);

                for (int i=startRotationSlice;i<=endRotationSlice;i++) 
                {
                        float theta3 = i * TWOPI / float(rotationSlices);
                        float c = theta3 / TWOPI * maxTexCoord;

                        Vector e1, p1;
                        e1[0] = float(cos(theta1) * cos(theta3));
                        e1[2] = float(sin(theta1));
                        e1[1] = float(cos(theta1) * sin(theta3));
                        p1[0] = radius * e1[0];
                        p1[2] = radius2 * e1[2];
                        p1[1] = radius * e1[1];

                        Vector e2, p2;
                        e2[0] = float(cos(theta2) * cos(theta3));
                        e2[2] = float(sin(theta2));
                        e2[1] = float(cos(theta2) * sin(theta3));
                        p2[0] = radius * e2[0];
                        p2[2] = radius2 * e2[2];
                        p2[1] = radius * e2[1];
                        
                        if (!inverse)
                        {
                                if (flags & eWidthTexture) glTexCoord2f((p1[0] + radius) / (2 * radius),
                                        (p1[1] + radius) / (2 * radius));
                                else glTexCoord2f(c, float(j) / float(heightSlices));
                                glVertex3fv(p1);
                                if (flags & eWidthTexture) glTexCoord2f((p2[0] + radius) / (2 * radius),
                                        (p2[1] + radius) / (2 * radius));
                                else glTexCoord2f(c, float(j+1) / float(heightSlices));
                                glVertex3fv(p2);
                        }
                        else
                        {
                                if (flags & eWidthTexture) glTexCoord2f((p2[0] + radius) / (2 * radius),
                                        (p2[1] + radius) / (2 * radius));
                                else glTexCoord2f(c, float(j+1) / float(heightSlices));
                                glVertex3fv(p2);
                                if (flags & eWidthTexture) glTexCoord2f((p1[0] + radius) / (2 * radius),
                                        (p1[1] + radius) / (2 * radius));
                                else glTexCoord2f(c, float(j) / float(heightSlices));
                                glVertex3fv(p1);
                        }
                }
                glEnd();
                glBegin(GL_QUAD_STRIP);
        }
        glEnd();
}

void Hemisphere::drawColored(float radius, float radius2, 
        int heightSlices, int rotationSlices,
        int startHeightSlice, int startRotationSlice,
        int endHeightSlice, int endRotationSlice,
        bool inverse, Image &colors, Vector &sunDir, int daytime,
        bool horizonGlow)
{
        GLubyte *bits = colors.getBits();

        glBegin(GL_QUAD_STRIP);
        const float maxTexCoord = 1.0f;
        for (int j=startHeightSlice; j<endHeightSlice; j++) 
        {
                float theta1 = j * HALFPI / float(heightSlices);
                if (j<0) theta1 *= 0.75f;
                float theta2 = (j + 1) * HALFPI / float(heightSlices);

                int colorJ = MAX(j - 1, 0);
                int colorIndexA = int(float(colorJ) / float(heightSlices) * 15.0f);
                int colorIndexB = int(float(j) / float(heightSlices) * 15.0f);
                int bitmapIndexA = daytime * 3 + (16 * 3) * colorIndexA;
                int bitmapIndexB = daytime * 3 + (16 * 3) * colorIndexB;

                DIALOG_ASSERT(bitmapIndexA >= 0);
                DIALOG_ASSERT(bitmapIndexB + 2 < 
                        colors.getWidth() * colors.getHeight() * colors.getComponents());

                for (int i=startRotationSlice;i<=endRotationSlice;i++) 
                {
                        float theta3 = i * TWOPI / float(rotationSlices);
                        float c = theta3 / TWOPI * maxTexCoord;

                        Vector e1, p1, c1;
                        e1[0] = float(cos(theta1) * cos(theta3));
                        e1[2] = float(sin(theta1));
                        e1[1] = float(cos(theta1) * sin(theta3));
                        p1[0] = radius * e1[0];
                        p1[2] = radius2 * e1[2];
                        p1[1] = radius * e1[1];

                        {
                                float dotP = 0.0f;
                                if (horizonGlow)
                                {
                                        dotP = e1.Normalize().dotP(sunDir);
                                        dotP = (dotP + 1.0f) / 4.0f;
                                }

                                c1[0] = MIN(float(bits[bitmapIndexA]) / 255.0f + dotP, 1.0f);
                                c1[1] = MIN(float(bits[bitmapIndexA + 1]) / 255.0f + dotP, 1.0f);
                                c1[2] = MIN(float(bits[bitmapIndexA + 2]) / 255.0f + dotP, 1.0f);
                        }

                        Vector e2, p2, c2;
                        e2[0] = float(cos(theta2) * cos(theta3));
                        e2[2] = float(sin(theta2));
                        e2[1] = float(cos(theta2) * sin(theta3));
                        p2[0] = radius * e2[0];
                        p2[2] = radius2 * e2[2];
                        p2[1] = radius * e2[1];
                        
                        {
                                float dotP = 0.0f;
                                if (horizonGlow)
                                {
                                        dotP = e2.Normalize().dotP(sunDir);
                                        dotP = (dotP + 1.0f) / 4.0f;
                                }

                                c2[0] = MIN(float(bits[bitmapIndexB]) / 255.0f + dotP, 1.0f);
                                c2[1] = MIN(float(bits[bitmapIndexB + 1]) / 255.0f + dotP, 1.0f);
                                c2[2] = MIN(float(bits[bitmapIndexB + 2]) / 255.0f + dotP, 1.0f);
                        }

                        if (!inverse)
                        {
                                glColor3fv(c1);
                                glVertex3fv(p1);
                                glColor3fv(c2);
                                glVertex3fv(p2);
                        }
                        else
                        {
                                glColor3fv(c2);
                                glVertex3fv(p2);
                                glColor3fv(c1);
                                glVertex3fv(p1);
                        }
                }
                glEnd();
                glBegin(GL_QUAD_STRIP);
        }
        glEnd();
}

---