//
//  glgrav - OpenGL N-Body gravity simulator
//
//  Copyright (C) 2003  Ian Cowburn (ianc@noddybox.demon.co.uk)
//
//  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 2 of the License, or
//  (at your option) any later version.
//
//  This program 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 this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  -------------------------------------------------------------------------
//
//  Data file handling
//
static const char id[]="$Id$";

#include "config.h"

#include <cctype>
#include <GL/gl.h>

#define RAD(x)	((x)*(M_PI/180.0))

// ---------------------------------------- CONSTRUCTION/DESTRUCTION
//
Config::Config()
{
    int f;

    m_error="";

    for(f=0;f<num_flags;f++)
	m_flag[f]=false;

    m_collide=none;

    m_light="";
    m_lr=m_lg=m_lb=1.0f;

    m_const=0.0;

    m_x=0.0f;
    m_y=0.0f;
    m_z=0.0f;
    m_yaw=0.0f;

    m_glid=0;
    m_glid_no=0;
    m_glid_idx=0;

    m_scale=1.0;

    m_particles=false;

    m_plane=xy_plane;

    m_look_at=-1;
    m_travel_as=-1;

    m_s_no=10;
    m_s_delta=5.0;
    m_s_min=10.0;
    m_s_max=1000.0;
    m_s_shield=100;

    m_sparks=false;

    m_winw=640;
    m_winh=480;

    m_max_mass=1000000;

    m_fog_dist=0.0f;
    m_fog_r=0.0f;
    m_fog_g=0.0f;
    m_fog_b=0.0f;
    m_fog_light=false;
}

Config::~Config()
{
    if (m_glid)
    	delete[] m_glid;
}


// ---------------------------------------- PUBLIC MEMBERS
//
bool Config::read(const string& fname,vector<Mass>& mass)
{
    static struct
    	{
	Command	cmd;
	string	token;
	int	val;
	} enum_list[]=
		{
		    {enable_cmd,"solid",static_cast<int>(solid)},
		    {enable_cmd,"lighting",static_cast<int>(lighting)},
		    {enable_cmd,"texture",static_cast<int>(texture)},
		    {collide_cmd,"none",static_cast<int>(none)},
		    {collide_cmd,"merge",static_cast<int>(merge)},
		    {collide_cmd,"delta_merge",static_cast<int>(delta_merge)},
		    {collide_cmd,"shatter",static_cast<int>(shatter)},
		    {plane_cmd,"xy",static_cast<int>(xy_plane)},
		    {plane_cmd,"xz",static_cast<int>(xz_plane)},
		    {plane_cmd,"yz",static_cast<int>(yz_plane)},
		    {cmd_error,"",0}
		};

    Mass parent;
    Mass *nm;
    Command cmd;
    vector<string> arg;
    ifstream file(fname.c_str());
    bool found;
    int f;
    vector<Mass>::size_type idx;
    vector<string>::size_type sidx;

    if (!file)
    	{
	m_error="File not found : " + fname;
	return false;
	}

    try
    	{
	while(getCommand(file,cmd,arg))
	    {
	    switch(cmd)
		{
		case enable_cmd:
		    f=0;
		    found=false;
		    while(enum_list[f].token!="")
			{
			if (enum_list[f].cmd==enable_cmd &&
				CompareNoCase(enum_list[f].token,arg[0]))
			    {
			    found=true;
			    m_flag[static_cast<Flag>(enum_list[f].val)]=true;
			    break;
			    }
			f++;
			}

		    if (!found)
			{
			m_error="Illegal argument to enable : " + arg[0];
			throw m_error;
			}

		    break;

		case disable_cmd:
		    f=0;
		    found=false;
		    while(enum_list[f].token!="")
			{
			if (enum_list[f].cmd==enable_cmd &&
				CompareNoCase(enum_list[f].token,arg[0]))
			    {
			    found=true;
			    m_flag[static_cast<Flag>(enum_list[f].val)]=false;
			    break;
			    }
			f++;
			}

		    if (!found)
			{
			m_error="Illegal argument to disable : " + arg[0];
			throw m_error;
			}

		    break;

		case collide_cmd:
		    f=0;
		    found=false;
		    while(enum_list[f].token!="")
			{
			if (enum_list[f].cmd==collide_cmd &&
				CompareNoCase(enum_list[f].token,arg[0]))
			    {
			    found=true;
			    m_collide=static_cast<Collide>(enum_list[f].val);
			    break;
			    }
			f++;
			}

		    if (!found)
			{
			m_error="Illegal argument to collide : " + arg[0];
			throw m_error;
			}

		    break;

		case const_cmd:
		    m_const=toDouble(arg[0]);
		    break;

		case body_cmd:
		    nm=
		      new Mass
			(arg[0], toDouble(arg[1]), m_scale,
			 toDouble(arg[2]), toDouble(arg[3]), toDouble(arg[4]),
			 toDouble(arg[5]), toDouble(arg[6]), toDouble(arg[7]),
			 toGLfloat(arg[8]), toGLfloat(arg[9]),
			 toGLfloat(arg[10]), toDouble(arg[11]));

		    if (mass.size()<m_max_mass)
			mass.push_back(*nm);

		    delete nm;
		    break;

		case radial_cmd:
		    if (findMass(mass,arg[2],parent))
			{
			genRadial(&nm,parent,
				  arg[0],toDouble(arg[1]),
				  toDouble(arg[3]),RAD(toDouble(arg[4])),
				  	toDouble(arg[5]),
				  toGLfloat(arg[6]),toGLfloat(arg[7]),
				  	toGLfloat(arg[8]),
				  toDouble(arg[9]));

			if (mass.size()<m_max_mass)
			    mass.push_back(*nm);

			delete nm;
			}
		    else
			{
			m_error="Unknown parent in radial : " + arg[2];
			throw m_error;
			}
		    break;

		case multiple_cmd:
		    if (findMass(mass,arg[4],parent))
			{
			string name=arg[0];
			int num=toInt(arg[1]);
			double ms=toDouble(arg[2]);
			double ms_i=toDouble(arg[3]);
			double dist=toDouble(arg[5]);
			double dist_i=toDouble(arg[6]);
			double ang=toDouble(arg[7]);
			double ang_i=toDouble(arg[8]);
			double spd=toDouble(arg[9]);
			double spd_i=toDouble(arg[10]);
			GLfloat r=toGLfloat(arg[11]);
			GLfloat g=toGLfloat(arg[12]);
			GLfloat b=toGLfloat(arg[13]);
			double rot=toDouble(arg[14]);

			int f;

			for(f=0;f<num;f++)
			    {
			    genRadial(&nm,parent,
				      makeName(name,f+1),ms,
				      dist,ang,spd,
				      r,g,b,
				      rot);

			    ms+=ms_i;
			    dist+=dist_i;
			    ang+=ang_i;
			    spd+=spd_i;

			    if (mass.size()<m_max_mass)
				mass.push_back(*nm);

			    delete nm;
			    }
			}
		    else
			{
			m_error="Unknown parent in multiple : " + arg[4];
			throw m_error;
			}
		    break;

		case light_cmd:
		    m_light=arg[0];
		    m_lr=toGLfloat(arg[1]);
		    m_lg=toGLfloat(arg[2]);
		    m_lb=toGLfloat(arg[3]);
		    break;

		case camera_cmd:
		    m_x=toGLfloat(arg[0]);
		    m_y=toGLfloat(arg[1]);
		    m_z=toGLfloat(arg[2]);
		    m_yaw=toGLfloat(arg[3]);
		    break;

		case look_cmd:
		    if (findMass(mass,arg[0],parent))
			m_look.push_back(arg[0]);
		    else
			{
			m_error="Unknown object in look : " + arg[0];
			throw m_error;
			}
		    break;

		case mlook_cmd:
		    {
		    int num=toInt(arg[1]);
		    string name=arg[0];
		    int f;

		    for(f=0;f<num;f++)
			{
			string ss;

			ss=makeName(name,f+1);

			if (findMass(mass,ss,idx))
			    {
			    m_look.push_back(ss);
			    }
			else
			    {
			    m_error="Unknown object in mlook : " + ss;
			    throw m_error;
			    }
			}
		    }
		    break;

		case texture_cmd:
		    if (!m_glid)
			{
			m_error="texture used without preceeding num_texture";
			throw m_error;
			}

		    if (findMass(mass,arg[0],idx))
			{
			if (m_glid_no==m_glid_idx)
			    {
			    m_error="more textures than expected";
			    throw m_error;
			    }

			GLuint id=m_glid[m_glid_idx++];

			if (bindTexture(arg[1],toInt(arg[2]),toInt(arg[3]),id))
			    mass[idx].setTexture(id);
			else
			    {
			    m_error="Failed to bind texture : " + m_error;
			    throw m_error;
			    }
			}
		    else
			{
			m_error="Unknown object in texture : " + arg[0];
			throw m_error;
			}
		    break;

		case num_texture_cmd:
		    if (m_glid)
			{
			m_error="num_texture used more than once";
			throw m_error;
			}

		    m_glid_no=toInt(arg[0]);
		    m_glid=new GLuint[m_glid_no];
		    glGenTextures(m_glid_no,m_glid);

		    break;

		case reuse_cmd:
		    if (findMass(mass,arg[0],idx))
			{
			if (findMass(mass,arg[1],parent))
			    {
			    GLuint id;

			    if (parent.getTexture(id) ||
			    		parent.getRingTexture(id))
				mass[idx].setTexture(id);
			    else
				{
				m_error="reuse object has no texture : " +
									arg[1];
				throw m_error;
				}
			    }
			else
			    {
			    m_error="Unknown object in reuse : " + arg[1];
			    throw m_error;
			    }
			}
		    else
			{
			m_error="Unknown object in reuse : " + arg[0];
			throw m_error;
			}
		    break;

		case mreuse_cmd:
		    if (findMass(mass,arg[2],parent))
			{
			int num=toInt(arg[1]);
			string name=arg[0];
			int f;

			for(f=0;f<num;f++)
			    {
			    string ss=makeName(name,f+1);

			    if (findMass(mass,ss,idx))
				{
				GLuint id;

				if (parent.getTexture(id) ||
					    parent.getRingTexture(id))
				    mass[idx].setTexture(id);
				else
				    {
				    m_error="mreuse object has no texture : " +
									arg[2];
				    throw m_error;
				    }
				}
			    else
				{
				m_error="Unknown object in mreuse : " + ss;
				throw m_error;
				}
			    }
			}
		    else
			{
			m_error="Unknown object in mreuse : " + arg[2];
			throw m_error;
			}
		    break;

		case ring_cmd:
		    if (findMass(mass,arg[0],idx))
		    	{
			mass[idx].setRing(toDouble(arg[1]),toDouble(arg[2]),
					  toGLfloat(arg[3]),
					  toGLfloat(arg[4]),
					  toGLfloat(arg[5]),
					  toGLfloat(arg[6]),
					  toDouble(arg[7]),
					  toDouble(arg[8]));
			}
		    else
			{
			m_error="Unknown object in ring : " + arg[0];
			throw m_error;
			}
		    break;

		case mring_cmd:
		    {
		    int num=toInt(arg[1]);
		    string name=arg[0];
		    int f;

		    for(f=0;f<num;f++)
			{
			string ss=makeName(name,f+1);

			if (findMass(mass,ss,idx))
			    {
			    mass[idx].setRing(toDouble(arg[2]),toDouble(arg[3]),
					      toGLfloat(arg[4]),
					      toGLfloat(arg[5]),
					      toGLfloat(arg[6]),
					      toGLfloat(arg[7]),
					      toDouble(arg[8]),
					      toDouble(arg[9]));
			    }
			else
			    {
			    m_error="Unknown object in mring : " + ss;
			    throw m_error;
			    }
			}
		    }
		    break;

		case ring_texture_cmd:
		    if (!m_glid)
			{
			m_error="ring used without preceeding num_texture";
			throw m_error;
			}

		    if (findMass(mass,arg[0],idx))
			{
			if (m_glid_no==m_glid_idx)
			    {
			    m_error="more textures than expected";
			    throw m_error;
			    }

			GLuint id=m_glid[m_glid_idx++];

			if (bindTexture(arg[1],toInt(arg[2]),toInt(arg[3]),id))
			    mass[idx].setRingTexture(id);
			else
			    {
			    m_error="Failed to bind texture : " + m_error;
			    throw m_error;
			    }
			}
		    else
			{
			m_error="Unknown object in ring : " + arg[0];
			throw m_error;
			}
		    break;

		case ring_reuse_cmd:
		    if (findMass(mass,arg[0],idx))
			{
			if (findMass(mass,arg[1],parent))
			    {
			    GLuint id;

			    if (parent.getRingTexture(id) ||
			    		parent.getTexture(id))
				mass[idx].setRingTexture(id);
			    else
				{
				m_error="ring_reuse object has no texture : " +
									arg[1];
				throw m_error;
				}
			    }
			else
			    {
			    m_error="Unknown object in ring_reuse : " + arg[1];
			    throw m_error;
			    }
			}
		    else
			{
			m_error="Unknown object in ring_reuse : " + arg[0];
			throw m_error;
			}
		    break;

		case ring_mreuse_cmd:
		    if (findMass(mass,arg[2],parent))
			{
			int num=toInt(arg[1]);
			string name=arg[0];
			int f;

			for(f=0;f<num;f++)
			    {
			    string ss=makeName(name,f+1);

			    if (findMass(mass,ss,idx))
				{
				GLuint id;

				if (parent.getRingTexture(id) ||
					    parent.getTexture(id))
				    mass[idx].setRingTexture(id);
				else
				    {
				    m_error="ring_mreuse object has "
				    		"no texture : " + arg[2];
				    throw m_error;
				    }
				}
			    else
				{
				m_error="Unknown object in ring_mreuse : " + ss;
				throw m_error;
				}
			    }
			}
		    else
			{
			m_error="Unknown object in ring_mreuse : " + arg[2];
			throw m_error;
			}
		    break;

		case particles_cmd:
		    m_particles=true;
		    m_p_adec=toGLfloat(arg[0]);
		    m_p_amin=toGLfloat(arg[1]);
		    m_p_size=toGLfloat(arg[2]);
		    break;

		case plane_cmd:
		    f=0;
		    found=false;
		    while(enum_list[f].token!="")
			{
			if (enum_list[f].cmd==plane_cmd &&
				CompareNoCase(enum_list[f].token,arg[0]))
			    {
			    found=true;
			    m_plane=static_cast<Plane>(enum_list[f].val);
			    break;
			    }
			f++;
			}

		    if (!found)
			{
			m_error="Illegal argument to plane : " + arg[0];
			throw m_error;
			}

		    break;

		case shatter_cmd:
		    m_s_no=toInt(arg[0]);
		    m_s_delta=toDouble(arg[1]);
		    m_s_min=toDouble(arg[2]);
		    m_s_max=toDouble(arg[3]);
		    m_s_shield=toInt(arg[4]);
		    break;

		case scale_cmd:
		    m_scale=toDouble(arg[0]);
		    break;

		case look_at_cmd:
		    found=false;

		    for(sidx=0;sidx<m_look.size();sidx++)
		    	if (m_look[sidx]==arg[0])
			    {
			    m_look_at=sidx;
			    found=true;
			    }

		    if (!found)
			{
			m_error="Illegal argument to look_at : " + arg[0];
			throw m_error;
			}
		    break;

		case travel_as_cmd:
		    found=false;

		    for(sidx=0;sidx<m_look.size();sidx++)
		    	if (m_look[sidx]==arg[0])
			    {
			    m_travel_as=sidx;
			    found=true;
			    }

		    if (!found)
			{
			m_error="Illegal argument to travel_as : " + arg[0];
			throw m_error;
			}
		    break;

		case window_size_cmd:
		    m_winw=toInt(arg[0]);
		    m_winh=toInt(arg[1]);
		    break;

		case sparks_cmd:
		    m_sparks=true;
		    m_sp_no=toInt(arg[0]);
		    m_sp_adec=toGLfloat(arg[1]);
		    m_sp_amin=toGLfloat(arg[2]);
		    m_sp_length=toInt(arg[3]);
		    m_sp_delta=toGLfloat(arg[4]);
		    break;

		case max_mass_cmd:
		    m_max_mass=toInt(arg[0]);
		    break;

		case fog_cmd:
		    m_flag[fog]=true;
		    m_fog_dist=toGLfloat(arg[0]);
		    m_fog_r=toGLfloat(arg[1]);
		    m_fog_g=toGLfloat(arg[2]);
		    m_fog_b=toGLfloat(arg[3]);
		    m_fog_light=toYesNo(arg[4]);
		    break;

		default:
		    break;
		}
	    }
	}
    catch(...)
    	{
	file.close();
	return false;
	}

    if (cmd==cmd_eof)
	{
	file.close();
	return true;
	}
    else
	return false;
}

void Config::getCamera(GLfloat& x, GLfloat& y, GLfloat& z, GLfloat& yaw) const
{
    x=m_x;
    y=m_y;
    z=m_z;
    yaw=m_yaw;
}

bool Config::enabled(Config::Flag flag) const
{
    return m_flag[flag];
}

Config::Collide Config::collide() const
{
    return m_collide;
}

string Config::light(GLfloat v[4]) const
{
    v[0]=m_lr;
    v[1]=m_lg;
    v[2]=m_lb;
    v[3]=1.0f;
    return m_light;
}

double Config::gravConst() const
{
    return m_const;
}

double Config::scale() const
{
    return m_scale;
}

void Config::look(vector<string>& l) const
{
    l=m_look;
}

bool Config::particlesDefined() const
{
    return m_particles;
}

void Config::getParticles(GLfloat& alpha_dec, GLfloat& alpha_min,
			  GLfloat& size ) const
{
    alpha_dec=m_p_adec;
    alpha_min=m_p_amin;
    size=m_p_size;
}

void Config::getLookAndTravel(int& look, int &travel) const
{
    look=m_look_at;
    travel=m_travel_as;
}

void Config::getShatter(int& num, double& delta,
			double& min_mass, double& max_mass, int& shield) const
{
    num=m_s_no;
    delta=m_s_delta;
    min_mass=m_s_min;
    max_mass=m_s_max;
    shield=m_s_shield;
}


bool Config::sparksDefined() const
{
    return m_sparks;
}


void Config::getSparks(int& num, GLfloat& alpha_dec, GLfloat& alpha_min,
		       int& length, GLfloat& delta) const
{
    num=m_sp_no;
    alpha_dec=m_sp_adec;
    alpha_min=m_sp_amin;
    length=m_sp_length;
    delta=m_sp_delta;
}


size_t Config::maxMass() const
{
    return m_max_mass;
}


void Config::getFog(GLfloat& dist, GLfloat& r, GLfloat& g, GLfloat& b,
		    bool& fog_light)
{
    dist=m_fog_dist;
    r=m_fog_r;
    g=m_fog_g;
    b=m_fog_b;
    fog_light=m_fog_light;
}

void Config::windowSize(int& w, int& h) const
{
    w=m_winw;
    h=m_winh;
}


string Config::error() const
{
    return m_error;
}


// ---------------------------------------- PRIVATE MEMBERS
//
bool Config::CompareNoCase(const string& s1, const string& s2)
{
    const char *p1,*p2;

    p1=s1.c_str();
    p2=s2.c_str();

    while((*p1)&&(tolower(*p1)==tolower(*p2)))
    	{
	p1++;
	p2++;
	}

    if (tolower(*p1)-tolower(*p2))
    	return false;
    else
    	return true;
}


Config::GetWordStatus Config::getWord(ifstream& file, string& word,
				      const string& ignore, const string& term)
{
    bool done=false;
    bool in_word=false;
    bool in_comment=false;
    string not_allowed;
    char c;

    if (term==";")
    	not_allowed=",";
    else if (term==",")
    	not_allowed=";";
    else
    	not_allowed=",;";

    word="";

    while(!done)
    	{
	file.get(c);

	if (file.eof())
	    return GWEof;

	if (in_comment)
	    {
	    if (c=='\n')
	    	in_comment=false;
	    }
	else
	    {
	    if (c=='#')
	    	in_comment=true;
	    else
		if (in_word)
		    {
		    bool at_term=(term.find(c)!=string::npos);
		    bool in_error=(not_allowed.find(c)!=string::npos);

		    if (in_error)
		    	{
			if (term==",")
			    return GWTooFewArgs;
			else if (term==";")
			    return GWTooManyArgs;
			else
			    return GWSyntax;
			}

		    if (at_term)
		    	done=true;
		    else
		    	if (c!='\n')
			    word+=c;
		    }
		else
		    {
		    bool in_ignore=(ignore.find(c)!=string::npos);

		    if (!in_ignore)
		    	{
			word+=c;
			in_word=true;
			}
		    }
	    }
	}

    return GWOK;
}


bool Config::getCommand(ifstream& file, Config::Command& cmd,
			vector<string>& arg)
{
    static struct
    	{
	string	cmd;
	Command	token;
	int	args;
	} cmd_list[]=
		{
		    {"enable",enable_cmd,1},
		    {"disable",disable_cmd,1},
		    {"collide",collide_cmd,1},
		    {"const",const_cmd,1},
		    {"body",body_cmd,12},
		    {"radial",radial_cmd,10},
		    {"light",light_cmd,4},
		    {"camera",camera_cmd,4},
		    {"look",look_cmd,1},
		    {"texture",texture_cmd,4},
		    {"num_texture",num_texture_cmd,1},
		    {"reuse",reuse_cmd,2},
		    {"particles",particles_cmd,3},
		    {"shatter",shatter_cmd,5},
		    {"multiple",multiple_cmd,15},
		    {"mreuse",mreuse_cmd,3},
		    {"plane",plane_cmd,1},
		    {"scale",scale_cmd,1},
		    {"look_at",look_at_cmd,1},
		    {"travel_as",travel_as_cmd,1},
		    {"window_size",window_size_cmd,2},
		    {"sparks",sparks_cmd,5},
		    {"max_mass",max_mass_cmd,1},
		    {"mlook",mlook_cmd,2},
		    {"ring",ring_cmd,9},
		    {"mring",mring_cmd,10},
		    {"ring_texture",ring_texture_cmd,4},
		    {"ring_reuse",ring_reuse_cmd,2},
		    {"ring_mreuse",ring_mreuse_cmd,3},
		    {"fog",fog_cmd,5},
		    {"",cmd_error,1}
		};

    string word;
    string cmd_string;
    int expect;
    int f;

    switch (getWord(file,word," \t\n"," \t\n"))
	{
	case GWEof:
	    cmd=cmd_eof;
	    return false;
	case GWSyntax:
	    m_error="Syntax error in command " + word;
	    return false;
	default:
	    break;
	}

    f=0;
    cmd=cmd_error;

    while(cmd_list[f].cmd!="")
    	{
	if (CompareNoCase(cmd_list[f].cmd,word))
	    {
	    cmd_string=word;
	    cmd=cmd_list[f].token;
	    expect=cmd_list[f].args;
	    break;
	    }

	f++;
	}

    if (cmd==cmd_error)
	{
	m_error="Unrecognised command " + word;
    	return false;
	}

    arg.clear();

    for(f=0;f<expect;f++)
    	{
	string error;

	switch (getWord(file,word," \t\n",(f==expect-1) ? ";" : ","))
	    {
	    case GWOK:
	    	break;

	    case GWTooManyArgs:
		cmd=cmd_error;
		m_error="Too many arguments in " + cmd_string;
		return false;

	    case GWTooFewArgs:
		cmd=cmd_error;
		m_error="Too few arguments in " + cmd_string;
		return false;

	    case GWEof:
		cmd=cmd_error;
		m_error="Unexpected EOF in " + cmd_string;
		return false;

	    case GWSyntax:
		cmd=cmd_error;
		m_error="Syntax error in " + cmd_string;
		return false;
	    }

	arg.push_back(word);
	}

    return true;
}

double Config::toDouble(const string& s)
{
    double r;
    char *p;

    r=strtod(s.c_str(),&p);

    if (*p)
	{
	m_error="Invalid floating point number : " + s;
    	throw m_error;
	}

    return r;
}


GLfloat Config::toGLfloat(const string& s)
{
    return static_cast<GLfloat>(toDouble(s));
}


int Config::toInt(const string& s)
{
    int i;
    char *p;

    i=static_cast<int>(strtol(s.c_str(),&p,0));

    if (*p)
	{
	m_error="Invalid integer : " + s;
    	throw m_error;
	}

    return i;
}


size_t Config::toSize(const string& s)
{
    size_t i;
    char *p;

    i=static_cast<size_t>(strtol(s.c_str(),&p,0));

    if (*p)
	{
	m_error="Invalid integer : " + s;
    	throw m_error;
	}

    return i;
}


bool Config::toYesNo(const string& s)
{
    if (s!="yes" && s!="no")
	{
	m_error="Invalid yes/no : " + s;
    	throw m_error;
	}

    return s=="yes";
}


bool Config::bindTexture(const string& name, int w, int h, GLuint id)
{
    FILE *fp;
    ifstream file(name.c_str());
    GLubyte *mem;
    int x,y;

    if (!(fp=fopen(name.c_str(),"r")))
	{
	m_error="file " + name + " not found";
    	return false;
	}

    mem=new GLubyte[w*h*3];

    for(y=0;y<h;y++)
    	for(x=w-1;x>=0;x--)
	    {
	    mem[x*3+y*w*3]=fgetc(fp);
	    mem[x*3+y*w*3+1]=fgetc(fp);
	    mem[x*3+y*w*3+2]=fgetc(fp);

	    if (feof(fp))
		{
		fclose(fp);
		m_error="file " + name + " to short";
		delete[] mem;
		return false;
		}
	    }

    fclose(fp);

    glBindTexture(GL_TEXTURE_2D,id);
    glTexImage2D(GL_TEXTURE_2D,0,3,w,h,0,GL_RGB,GL_UNSIGNED_BYTE,mem);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);

    delete[] mem;

    return true;
}

void Config::genRadial(Mass **newMass, const Mass& parent,
		       const string& name, double mass,
		       double dist, double ang, double spd,
		       GLfloat r, GLfloat g, GLfloat b, double rot)
{
    double px,py,pz;
    double pdx,pdy,pdz;
    double ox,oy,oz;
    double dx,dy,dz;

    parent.getPosition(px,py,pz);
    parent.getDelta(pdx,pdy,pdz);

    switch(m_plane)
    	{
	case xy_plane:
	    ox=px+dist*sin(ang);
	    oy=py-dist*cos(ang);
	    oz=pz;
	    ang+=RAD(90);
	    dx=spd*sin(ang);
	    dy=-spd*cos(ang);
	    dz=0.0;
	    break;

	case xz_plane:
	    ox=px+dist*sin(ang);
	    oy=py;
	    oz=pz-dist*cos(ang);
	    ang+=RAD(90);
	    dx=spd*sin(ang);
	    dy=0.0;
	    dz=-spd*cos(ang);
	    break;

	case yz_plane:
	    ox=px;
	    oy=py+dist*sin(ang);
	    oz=pz-dist*cos(ang);
	    ang+=RAD(90);
	    dx=0.0;
	    dy=spd*sin(ang);
	    dz=-spd*cos(ang);
	    break;

	default:
	    m_error="INTERNAL ERROR: invalid plane defined";
	    throw m_error;
	}

    dx+=pdx;
    dy+=pdy;
    dz+=pdz;

    *newMass=new Mass(name, mass, m_scale, ox,oy,oz, dx,dy,dz, r,g,b,rot);
}


string Config::makeName(string& name, int no)
{
    char s[1024];
    string n;

    sprintf(s,"%s %d",name.c_str(),no);
    n=s;

    return n;
}


// END OF FILE //