demos/lights/Lights.cpp

Go to the documentation of this file.

#include "LightsConfig.h"
#include "glwxOpenGL.h"
#include "Lights.h"

#include <math.h>

Lights::Lights() {

        numLights = 3;
        height = 0.9528;
        distance = 1.0;
        isWireframe = false;
        cameraPosition[0] = 0;
        cameraPosition[1] = 0.2;
        cameraPosition[2] = 8;
        lookPosition[0] = 0;
        lookPosition[1] = 0.2;
        lookPosition[2] = 0;

        useDepthBuffer = true;

        p1Brightness = 0;
        p2Brightness = 0;
        percentDifference = 0;
}

bool Lights::Init() {


    glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
        glClearDepth( 1.0f );

    glEnable( GL_DEPTH_TEST );
    glDepthFunc( GL_LEQUAL );
    glShadeModel( GL_SMOOTH );


        glBlendFunc( GL_SRC_ALPHA, GL_ONE );
        glLineStipple(1, 0x3F07);


        std::string texturePath = LIGHTS_DATA_DIR;
        texturePath += "/Textures/light.tga";
        
        //load light texture
        lightTex.load2D(texturePath.c_str());
        lightTex.activate();


        GLfloat light_pos[] = {0.0, 1, 0, 1};
        GLfloat rgba_white[]  = { 1.0f, 1.0f, 1.0f, 1.0f };
        GLfloat rgba_black[]  = { 0.0f, 0.0f, 0.0f, 1.0f };
        //GLfloat rgba_gray[]  = { 0.2f, 0.2f, 0.2f, 1.0f };

        //make a new light
        glLightfv( GL_LIGHT1, GL_AMBIENT, rgba_black );
        glLightfv( GL_LIGHT1, GL_DIFFUSE, rgba_white );
        glLightfv( GL_LIGHT1, GL_POSITION, light_pos );
        //glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 90.0);
        glEnable(GL_LIGHT1);


        return true;
}


void Lights::Draw() {


    glClearColor( 0.1f, 0.1f, 0.15f, 1.0f );
    glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glLoadIdentity();


        //eyeX, eyeY, eyeZ, lookatX, lookatZ, lookatY, upVectorX, upVectorY, upVectorZ
        gluLookAt(cameraPosition[0], cameraPosition[1], cameraPosition[2],
                        lookPosition[0], lookPosition[1], lookPosition[2],  0, 1, 0);

        //reset light position
        GLfloat light_pos[] = {0.0, height + (numLights*distance)*0.1, 0.0, 1};
        glLightfv( GL_LIGHT1, GL_POSITION, light_pos );

        DrawFloor();
        if (drawLines) DrawLines();
        DrawLights();

        CalculateBrightness();

}

void Lights::DrawFloor() {


                float radius = 30;
                //patches is the number of grid segments makeup the plane
                int patches = 10;
                float step = (2*radius)/patches;

                glDisable(GL_BLEND);
                glEnable(GL_LIGHTING);
                glEnable(GL_DEPTH_TEST);

                glDisable(GL_TEXTURE_2D);

                if (isWireframe) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

                        //draw plane with patches
                        glBegin( GL_QUADS );  
                        float y = radius;
                        for (int j = 0; j < patches; ++j) {
                                float x = radius;
                                for (int k = 0; k < patches; ++k) {
                                        glNormal3f(0,1,0);
                                        glVertex3f(  x,  0.0f,  y );
                                        glNormal3f(0,1,0);
                                        glVertex3f(  x,  0.0f, y-step );
                                        glNormal3f(0,1,0);
                                        glVertex3f( x-step,  0.0f, y-step );
                                        glNormal3f(0,1,0);
                                        glVertex3f( x-step,  0.0f,  y );
                                        x -= step;
                                }
                                y -= step;
                        }
                        glEnd( );

                if (isWireframe) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

}

void Lights::DrawLines() {


        glDisable(GL_DEPTH_TEST);

        glLineWidth(1.0);
        glDisable(GL_LIGHTING);


        //Draw solid lines
        glBegin( GL_LINES );  
        double x = -(distance*(numLights-1))/2;
        for (int i = 0; i < numLights; ++i) {
                glVertex3f(x,height,0);
                glVertex3f(0,0,0);
                x += distance;
        }
        glEnd();

        //Draw dashed lines
        glEnable(GL_LINE_STIPPLE);
        glBegin( GL_LINES );  
        x = -(distance*(numLights-1))/2.0f;
        double offset = distance/2.0f;
        for (int i = 0; i < numLights; ++i) {
                glVertex3f(x,height,0);
                glVertex3f(offset,0,0);
                x += distance;
        }
        glEnd();
        glDisable(GL_LINE_STIPPLE);

}

void Lights::DrawLights() {

        float radius = 0.25;

        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, lightTex.getID() );

        glEnable(GL_BLEND);
        glBlendFunc( GL_SRC_ALPHA, GL_ONE );

        glDisable(GL_LIGHTING);
        if (useDepthBuffer) glEnable(GL_DEPTH_TEST);
        else glDisable(GL_DEPTH_TEST);
        glColor4f(1.0f,1.0f,1.0f,1.0f);

        //draw a light texture
        glBegin( GL_QUADS );

        double x = -(distance*(numLights-1))/2;
        for (int i = 0; i < numLights; ++i) {

                glTexCoord2f(1.0f, 1.0f); glNormal3f(0,0,1); glVertex3f(  radius+x,  radius+height,  0 ); 
                glTexCoord2f(0.0f, 1.0f); glNormal3f(0,0,1); glVertex3f( -radius+x,  radius+height,  0 ); 
                glTexCoord2f(0.0f, 0.0f); glNormal3f(0,0,1); glVertex3f( -radius+x, -radius+height,  0 ); 
                glTexCoord2f(1.0f, 0.0f); glNormal3f(0,0,1); glVertex3f(  radius+x, -radius+height,  0 ); 

                x += distance;
        }

        glEnd();

}

void Lights::SetDrawLines(bool flag) { this->drawLines = flag; }
void Lights::SetUseDepthBuffer(bool flag) { this->useDepthBuffer = flag; }

void Lights::SetNumberOfLights(int num) {

        if (num < 0) return;
        //enforce that we always have an odd number of lights
        //and we always have at least one light
        if (num%2) this->numLights = num;
        else this->numLights = num+1;

}

void Lights::Reset() {

        height = 0.9528;
        distance = 1.0;
        isWireframe = false;
        cameraPosition[0] = 0;
        cameraPosition[1] = 0.2;
        cameraPosition[2] = 8;
        lookPosition[0] = 0;
        lookPosition[1] = 0.2;
        lookPosition[2] = 0;

}




void Lights::CalculateBrightness() {

        //reset values
        p1Brightness = 0;
        p2Brightness = 0;
        percentDifference = 0;


        double x = -(distance*(numLights-1))/2;
        double offset = distance/2.0f;
        double dx = 0;
        double dy = 0;

        for (int i = 0; i < numLights; ++i) {

                // (x, height) ---> (0, 0)
                dx = x;
                dy = height;
                p1Brightness += 1.0 / ( dx*dx + dy*dy );

                // (x, height) ---> (offset, 0)
                dx = offset - x;
                dy = height;
                p2Brightness += 1.0 / ( dx*dx + dy*dy );

                x += distance;
        }

        p1Brightness /= (double)numLights;
        p2Brightness /= (double)numLights;

        if (p1Brightness + p2Brightness != 0) {   //dont divide by zero

                percentDifference = (2.0*abs(p1Brightness - p2Brightness))/(p1Brightness + p2Brightness);
                percentDifference *= 100.0;

        }

}


int Lights::GetNumberOfLights() { return numLights; }
double Lights::GetDistanceBetweenLights() { return distance; }
double Lights::GetHeightAboveGround() { return height; }
double Lights::GetP1Brightness() { return p1Brightness;}
double Lights::GetP2Brightness() { return p2Brightness; }
double Lights::GetPercentDifference() { return percentDifference; }


void Lights::SetDistanceBetweenLights(double distance) { this->distance = distance; }
void Lights::SetHeightAboveGround(double height) { this->height = height; }
void Lights::SetViewDistance(double distance) { this->cameraPosition[2] = -distance; }

void Lights::MouseDown() { mouseIsDown = true; }
void Lights::MouseUp() { mouseIsDown = false; }

void Lights::MouseMove(int x, int y) {

        if (mouseIsDown) {
                lookPosition[0] += x*cameraPosition[2]/200.0f;

                lookPosition[1] -= y*abs(cameraPosition[2])/200.0f;
        }

}

---