Lighting.cpp

Go to the documentation of this file.

/* Copyright © 2010 James Legg.
    This program 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 3 of the License, or
    (at your option) any later version.
*/

#include "Lighting.h"

#include <GL/gl.h>

#include "stream_loader.h"
#include "FormErrors.h"

namespace Track
{

const unsigned int lighting_newest_version = 1;
const unsigned int fog_settings_newest_version = 1;
const unsigned int light_settings_newest_version = 1;

FogSettings::FogSettings()
    :   density(0.004)
    ,   enabled(true)
{
    const float default_fog_colour[4] = {0.3, 0.0, 0.1, 1.0};
    for (int i = 0; i < 4; i++)
    {
        colour[i] = default_fog_colour[i];
    }
}

FogSettings::FogSettings(std::istream & in)
{
    unsigned int file_version;
    in >> file_version;
    if (file_version == 0) throw CorruptedError();
    if (file_version > fog_settings_newest_version) throw NewVersionError();
    in >> density >>
          colour[0] >> colour[1] >> colour[2] >> colour[3] >>
          enabled;
}

bool FogSettings::operator != (const FogSettings & other) const
{
    if (enabled != other.enabled) return true;
    if (density != other.density) return true;
    for (int i = 0; i < 4; i++)
    {
        if (colour[i] != other.colour[i]) return true;
    }
    return false;
}

std::ostream & operator<<(std::ostream & dest, const FogSettings & fog)
{
    dest << fog_settings_newest_version << ' ' <<
            fog.density << ' ' <<
            fog.colour[0] << ' ' << fog.colour[1] << ' ' <<
            fog.colour[2] << ' ' << fog.colour[3] << ' ' <<
            fog.enabled;
    return dest;
}

LightSettings::LightSettings()
{
}

LightSettings::LightSettings(std::istream & in)
{
    unsigned int file_version;
    in >> file_version;
    if (file_version == 0) throw CorruptedError();
    if (file_version > light_settings_newest_version) throw NewVersionError();
    in >> position[0] >> position[1] >> position[2] >> position[3] >>
          colour[0] >> colour[1] >> colour[2] >> colour[3];
}

bool LightSettings::operator == (const LightSettings & other) const
{
    for (int i = 0; i < 4; i++)
    {
        if (position[i] != other.position[i]) return false;
        if (colour[i] != other.colour[i]) return false;
    }
    return true;
}

std::ostream & operator<<(std::ostream & dest, const LightSettings & ls)
{
    dest << light_settings_newest_version << ' ' <<
            ls.position[0] << ' ' << ls.position[1] << ' ' <<
            ls.position[2] << ' ' << ls.position[3] << ' ' <<
            ls.colour[0]   << ' ' << ls.colour[1]   << ' ' <<
            ls.colour[2]   << ' ' << ls.colour[3];
    return dest;
}

Lighting::Lighting()
{
    m_lights.resize(2);
    const float l0p[4] = {0.0, 0.0, 1.0, 0.0};
    const float l0c[4] = {0.4, 0.4, 0.4, 1.0};
    const float l1p[4] = {1.0, 0.0, 0.0, 0.0};
    const float l1c[4] = {0.4, 0.2, 0.1, 1.0};
    const float amb[4] = {0.6, 0.6, 0.6, 1.0};
    for (int i = 0; i < 4; i++)
    {
        m_lights[0].position[i] = l0p[i];
        m_lights[0].colour[i] = l0c[i];
        m_lights[1].position[i] = l1p[i];
        m_lights[1].colour[i] = l1c[i];
        m_ambient_light[i] = amb[i];
    }
    
}

Lighting::Lighting(std::istream & in)
{
    unsigned int file_version;
    in >> file_version;
    if (file_version == 0) throw CorruptedError();
    if (file_version > lighting_newest_version) throw NewVersionError();
    m_fog = FogSettings(in);
    in >> m_ambient_light[0] >> m_ambient_light[1] >>
          m_ambient_light[2] >> m_ambient_light[3];
    unsigned int m_num_lights;
    in >> m_num_lights;
    if (m_num_lights > 8) throw CorruptedError();
    m_lights.resize(m_num_lights);
    for (int i = 0; i < m_num_lights; i++)
    {
        m_lights[i]= LightSettings(in);
    }
}

void Lighting::initalise() const
{
    // lights
    for (unsigned int i = 0; i < m_lights.size(); i++)
    {
        glEnable(GL_LIGHT0 + i);
        glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, m_lights[i].colour);
    }
    // disable unused lights that could have activated from a previous game.
    for (unsigned int i = m_lights.size(); i < 8; i++)
    {
        glDisable(GL_LIGHT0+i);
    }
    // ambient light
    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, m_ambient_light);
    // only reflects a fith of the ambient light and 4 fiths of diffuse light
    // by default. Use all light.
    GLfloat light_scale[4] = {1.0, 1.0, 1.0, 1.0};
    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, light_scale);
    
    // fog
    glFogf(GL_FOG_MODE, GL_EXP2);
    glFogf(GL_FOG_DENSITY, m_fog.density);
    glFogfv(GL_FOG_COLOR, m_fog.colour);
    if (m_fog.enabled) glEnable(GL_FOG); else
                     glDisable(GL_FOG);
}

void Lighting::prepare_render() const
{
    glEnable(GL_LIGHTING);
    if (m_fog.enabled) glEnable(GL_FOG); else
                     glDisable(GL_FOG);
    for (unsigned int i = 0; i < m_lights.size(); i++)
    {
        glLightfv(GL_LIGHT0 + i, GL_POSITION, m_lights[i].position);
    }
}

void Lighting::set_lights(const std::vector<LightSettings> & lights)
{
    m_lights = lights;
}

const std::vector<LightSettings> & Lighting::get_lights() const
{
    return m_lights;
}

void Lighting::set_ambient(float colour[4])
{
    for (int i = 0; i < 4; i++)
    {
        m_ambient_light[i] = colour[i];
    }
}

const float * Lighting::get_ambient_light() const
{
    return m_ambient_light;
}

void Lighting::set_fog(const FogSettings & fog)
{
    m_fog = fog;
}

const FogSettings & Lighting::get_fog() const
{
    return m_fog;
}

bool Lighting::operator!=(const Lighting & other) const
{
    if (m_lights != other.m_lights) return true;
    if (m_fog != other.m_fog) return true;
    for (int i = 0; i < 4; i++)
    {
        if (m_ambient_light[i] != other.m_ambient_light[i]) return true;
    }
    return false;
}

std::ostream & operator<<(std::ostream & dest, const Lighting & lighting)
{
    const float * amb = lighting.get_ambient_light();
    dest << lighting_newest_version << ' ' <<
            lighting.get_fog() << ' ' <<
            amb[0] << ' ' << amb[1] << ' ' << amb[2] << ' ' << amb[3] << ' ';
    const std::vector<LightSettings> & lights = lighting.get_lights();
    dest << lights.size();
    for (int i = 0; i < lights.size(); i++)
    {
        dest << ' ' << lights[i];
    }
    return dest;
}

} // namespace Track.

---

Generated at Mon Sep 6 00:41:11 2010 by Doxygen version 1.4.7 for Racer version svn335.