//============================================================================
//
// Terence Welsh Screensaver - Euphoria
// http://www.reallyslick.com/
//
// Ported to KDE by Karl Robillard
//
/*
 * Copyright (C) 2002  Terence M. Welsh
 *
 * Euphoria is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Euphoria 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
//============================================================================


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <tqtimer.h>
#include "Euphoria.h"
#include "Euphoria.moc"
#include "EuphoriaTexture.h"


#define NUMCONSTS 9
#define PIx2 6.28318530718f


//----------------------------------------------------------------------------


#include <sys/time.h>
#include <unistd.h>


// Returns the system time, in seconds.
double timeGetTime()
{
    struct timeval tp;
    gettimeofday( &tp, 0 );
    return (double)tp.tv_sec + (double)tp.tv_usec / 1000000;
}


//----------------------------------------------------------------------------


class rsVec
{
public:

    float v[3];

    rsVec() {}
    rsVec(float xx, float yy, float zz);

    void set(float xx, float yy, float zz);
    float normalize();
    float dot(rsVec);
    void cross(rsVec, rsVec);

    float & operator [] (int i) {return v[i];}
    const float & operator [] (int i) const {return v[i];}
    rsVec & operator = (const rsVec &vec)
        {v[0]=vec[0];v[1]=vec[1];v[2]=vec[2];return *this;};
    rsVec operator + (const rsVec &vec)
        {return(rsVec(v[0]+vec[0], v[1]+vec[1], v[2]+vec[2]));};
    rsVec operator - (const rsVec &vec)
        {return(rsVec(v[0]-vec[0], v[1]-vec[1], v[2]-vec[2]));};
    rsVec operator * (const float &mul)
        {return(rsVec(v[0]*mul, v[1]*mul, v[2]*mul));};
    rsVec operator / (const float &div)
        {float rec = 1.0f/div; return(rsVec(v[0]*rec, v[1]*rec, v[2]*rec));};
    rsVec & operator += (const rsVec &vec)
        {v[0]+=vec[0];v[1]+=vec[1];v[2]+=vec[2];return *this;};
    rsVec & operator -= (const rsVec &vec)
        {v[0]-=vec[0];v[1]-=vec[1];v[2]-=vec[2];return *this;};
    rsVec & operator *= (const rsVec &vec)
        {v[0]*=vec[0];v[1]*=vec[1];v[2]*=vec[2];return *this;};
    rsVec & operator *= (const float &mul)
        {v[0]*=mul;v[1]*=mul;v[2]*=mul;return *this;};
};


rsVec::rsVec(float xx, float yy, float zz){
    v[0] = xx;
    v[1] = yy;
    v[2] = zz;
}


void rsVec::set(float xx, float yy, float zz){
    v[0] = xx;
    v[1] = yy;
    v[2] = zz;
}


float rsVec::normalize(){
    float length = float(sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]));
    if(length == 0.0f){
        v[1] = 1.0f;
        return(0.0f);
    }
    float reciprocal = 1.0f / length;
    v[0] *= reciprocal;
    v[1] *= reciprocal;
    v[2] *= reciprocal;
    // Really freakin' stupid compiler bug fix for VC++ 5.0
    /*v[0] /= length;
    v[1] /= length;
    v[2] /= length;*/
    return(length);
}


float rsVec::dot(rsVec vec1){
    return(v[0] * vec1[0] + v[1] * vec1[1] + v[2] * vec1[2]);
}


void rsVec::cross(rsVec vec1, rsVec vec2){
    v[0] = vec1[1] * vec2[2] - vec2[1] * vec1[2];
    v[1] = vec1[2] * vec2[0] - vec2[2] * vec1[0];
    v[2] = vec1[0] * vec2[1] - vec2[0] * vec1[1];
}


//----------------------------------------------------------------------------


void hsl2rgb(float h, float s, float l, float &r, float &g, float &b)
{
    // hue influence
    if(h < 0.166667){  // full red, some green
        r = 1.0;
        g = h * 6.0f;
        b = 0.0;
    }
    else {
        if(h < 0.5){  // full green
            g = 1.0;
            if(h < 0.333333){  // some red
                r = 1.0f - ((h - 0.166667f) * 6.0f);
                b = 0.0;
            }
            else{  // some blue
                b = (h - 0.333333f) * 6.0f;
                r = 0.0;
            }
        }
        else{
            if(h < 0.833333){  // full blue
                b = 1.0;
                if(h < 0.666667){  // some green
                    g = 1.0f - ((h - 0.5f) * 6.0f);
                    r = 0.0;
                }
                else{  // some red
                    r = (h - 0.666667f) * 6.0f;
                    g = 0.0;
                }
            }
            else{  // full red, some blue
                r = 1.0;
                b = 1.0f - ((h - 0.833333f) * 6.0f);
                g = 0.0;
            }
        }
    }

    // saturation influence
    r = 1.0f - (s * (1.0f - r));
    g = 1.0f - (s * (1.0f - g));
    b = 1.0f - (s * (1.0f - b));

    // luminosity influence
    r *= l;
    g *= l;
    b *= l;
}


// Useful random number macros
// Don't forget to initialize with srand()
inline int myRandi(int x){
    return((rand() * x) / RAND_MAX);
}
inline float myRandf(float x){
    return(float(rand() * x) / float(RAND_MAX));
}


//----------------------------------------------------------------------------


// Context pointer to allow many instances.
static EuphoriaWidget* _ec = 0;


class wisp
{
public:

	wisp();
	~wisp();
	void update();
	void draw();
	void drawAsBackground();


    int density;
	float*** vertices;
	float c[NUMCONSTS];     // constants
	float cr[NUMCONSTS];    // constants' radial position
	float cv[NUMCONSTS];    // constants' change velocities
	float hsl[3];
	float rgb[3];
	float hueSpeed;
	float saturationSpeed;
};


wisp::wisp()
{
	int i, j;
	float recHalfDens = 1.0f / (float(_ec->dDensity) * 0.5f);

    density = _ec->dDensity;
	vertices = new float**[density+1];
	for(i=0; i<=density; i++)
    {
		vertices[i] = new float*[density+1];
		for(j=0; j<=density; j++)
        {
			vertices[i][j] = new float[7];
			vertices[i][j][3] = float(i) * recHalfDens - 1.0f;  // x position on grid
			vertices[i][j][4] = float(j) * recHalfDens - 1.0f;  // y position on grid
			// distance squared from the center
			vertices[i][j][5] = vertices[i][j][3] * vertices[i][j][3]
				+ vertices[i][j][4] * vertices[i][j][4];
			vertices[i][j][6] = 0.0f;  // intensity
		}
	}

	// initialize constants
	for(i=0; i<NUMCONSTS; i++)
    {
		c[i] = myRandf(2.0f) - 1.0f;
		cr[i] = myRandf(PIx2);
		cv[i] = myRandf(_ec->dSpeed * 0.03f) + (_ec->dSpeed * 0.001f);
	}

	// pick color
	hsl[0] = myRandf(1.0f);
	hsl[1] = 0.1f + myRandf(0.9f);
	hsl[2] = 1.0f;
	hueSpeed = myRandf(0.1f) - 0.05f;
	saturationSpeed = myRandf(0.04f) + 0.001f;
}


wisp::~wisp()
{
	int i, j;

	for(i=0; i<=density; i++)
    {
		for(j=0; j<=density; j++)
        {
			delete[] vertices[i][j];
		}
		delete[] vertices[i];
	}
	delete[] vertices;
}


void wisp::update()
{
	int i, j;
	rsVec up, right, crossvec;
	// visibility constants
	static float viscon1 = float(_ec->dVisibility) * 0.01f;
	static float viscon2 = 1.0f / viscon1;

	// update constants
	for(i=0; i<NUMCONSTS; i++){
		cr[i] += cv[i] * _ec->elapsedTime;
		if(cr[i] > PIx2)
			cr[i] -= PIx2;
		c[i] = cos(cr[i]);
	}

	// update vertex positions
	for(i=0; i<=density; i++){
		for(j=0; j<=density; j++){
			vertices[i][j][0] = vertices[i][j][3] * vertices[i][j][3] * vertices[i][j][4] * c[0]
				+ vertices[i][j][5] * c[1] + 0.5f * c[2];
			vertices[i][j][1] = vertices[i][j][4] * vertices[i][j][4] * vertices[i][j][5] * c[3]
				+ vertices[i][j][3] * c[4] + 0.5f * c[5];
			vertices[i][j][2] = vertices[i][j][5] * vertices[i][j][5] * vertices[i][j][3] * c[6]
				+ vertices[i][j][4] * c[7] + c[8];
		}
	}

	// update vertex normals for most of mesh
	for(i=1; i<density; i++){
		for(j=1; j<density; j++){
			up.set(vertices[i][j+1][0] - vertices[i][j-1][0],
				vertices[i][j+1][1] - vertices[i][j-1][1],
				vertices[i][j+1][2] - vertices[i][j-1][2]);
			right.set(vertices[i+1][j][0] - vertices[i-1][j][0],
				vertices[i+1][j][1] - vertices[i-1][j][1],
				vertices[i+1][j][2] - vertices[i-1][j][2]);
			up.normalize();
			right.normalize();
			crossvec.cross(right, up);
			// Use depth component of normal to compute intensity
			// This way only edges of wisp are bright
			if(crossvec[2] < 0.0f)
				crossvec[2] *= -1.0f;
			vertices[i][j][6] = viscon2 * (viscon1 - crossvec[2]);
			if(vertices[i][j][6] > 1.0f)
				vertices[i][j][6] = 1.0f;
			if(vertices[i][j][6] < 0.0f)
				vertices[i][j][6] = 0.0f;
		}
	}

	// update color
	hsl[0] += hueSpeed * _ec->elapsedTime;
	if(hsl[0] < 0.0f)
		hsl[0] += 1.0f;
	if(hsl[0] > 1.0f)
		hsl[0] -= 1.0f;
	hsl[1] += saturationSpeed * _ec->elapsedTime;
	if(hsl[1] <= 0.1f){
		hsl[1] = 0.1f;
		saturationSpeed = -saturationSpeed;
	}
	if(hsl[1] >= 1.0f){
		hsl[1] = 1.0f;
		saturationSpeed = -saturationSpeed;
	}
	hsl2rgb(hsl[0], hsl[1], hsl[2], rgb[0], rgb[1], rgb[2]);
}


void wisp::draw()
{
	int i, j;

	glPushMatrix();

	if(_ec->dWireframe)
    {
		for(i=1; i<density; i++){
			glBegin(GL_LINE_STRIP);
			for(j=0; j<=density; j++){
				glColor3f(rgb[0] + vertices[i][j][6] - 1.0f, rgb[1] + vertices[i][j][6] - 1.0f, rgb[2] + vertices[i][j][6] - 1.0f);
				glTexCoord2d(vertices[i][j][3] - vertices[i][j][0], vertices[i][j][4] - vertices[i][j][1]);
				glVertex3fv(vertices[i][j]);
			}
			glEnd();
		}
		for(j=1; j<density; j++){
			glBegin(GL_LINE_STRIP);
			for(i=0; i<=density; i++){
				glColor3f(rgb[0] + vertices[i][j][6] - 1.0f, rgb[1] + vertices[i][j][6] - 1.0f, rgb[2] + vertices[i][j][6] - 1.0f);
				glTexCoord2d(vertices[i][j][3] - vertices[i][j][0], vertices[i][j][4] - vertices[i][j][1]);
				glVertex3fv(vertices[i][j]);
			}
			glEnd();
		}
	}
	else
    {
		for(i=0; i<density; i++){
			glBegin(GL_TRIANGLE_STRIP);
				for(j=0; j<=density; j++){
					glColor3f(rgb[0] + vertices[i+1][j][6] - 1.0f, rgb[1] + vertices[i+1][j][6] - 1.0f, rgb[2] + vertices[i+1][j][6] - 1.0f);
					glTexCoord2d(vertices[i+1][j][3] - vertices[i+1][j][0], vertices[i+1][j][4] - vertices[i+1][j][1]);
					glVertex3fv(vertices[i+1][j]);
					glColor3f(rgb[0] + vertices[i][j][6] - 1.0f, rgb[1] + vertices[i][j][6] - 1.0f, rgb[2] + vertices[i][j][6] - 1.0f);
					glTexCoord2d(vertices[i][j][3] - vertices[i][j][0], vertices[i][j][4] - vertices[i][j][1]);
					glVertex3fv(vertices[i][j]);
				}
			glEnd();
		}
	}

	glPopMatrix();
}


void wisp::drawAsBackground()
{
	int i, j;

	glPushMatrix();
	glTranslatef(c[0] * 0.2f, c[1] * 0.2f, 1.6f);

	if(_ec->dWireframe)
    {
		for(i=1; i<density; i++){
			glBegin(GL_LINE_STRIP);
			for(j=0; j<=density; j++){
				glColor3f(rgb[0] + vertices[i][j][6] - 1.0f, rgb[1] + vertices[i][j][6] - 1.0f, rgb[2] + vertices[i][j][6] - 1.0f);
				glTexCoord2d(vertices[i][j][3] - vertices[i][j][0], vertices[i][j][4] - vertices[i][j][1]);
				glVertex3f(vertices[i][j][3], vertices[i][j][4], vertices[i][j][6]);
			}
			glEnd();
		}
		for(j=1; j<density; j++){
			glBegin(GL_LINE_STRIP);
			for(i=0; i<=density; i++){
				glColor3f(rgb[0] + vertices[i][j][6] - 1.0f, rgb[1] + vertices[i][j][6] - 1.0f, rgb[2] + vertices[i][j][6] - 1.0f);
				glTexCoord2d(vertices[i][j][3] - vertices[i][j][0], vertices[i][j][4] - vertices[i][j][1]);
				glVertex3f(vertices[i][j][3], vertices[i][j][4], vertices[i][j][6]);
			}
			glEnd();
		}
	}
	else
    {
		for(i=0; i<density; i++){
			glBegin(GL_TRIANGLE_STRIP);
				for(j=0; j<=density; j++){
					glColor3f(rgb[0] + vertices[i+1][j][6] - 1.0f, rgb[1] + vertices[i+1][j][6] - 1.0f, rgb[2] + vertices[i+1][j][6] - 1.0f);
					glTexCoord2d(vertices[i+1][j][3] - vertices[i+1][j][0], vertices[i+1][j][4] - vertices[i+1][j][1]);
					glVertex3f(vertices[i+1][j][3], vertices[i+1][j][4], vertices[i+1][j][6]);
					glColor3f(rgb[0] + vertices[i][j][6] - 1.0f, rgb[1] + vertices[i][j][6] - 1.0f, rgb[2] + vertices[i][j][6] - 1.0f);
					glTexCoord2d(vertices[i][j][3] - vertices[i][j][0], vertices[i][j][4] - vertices[i][j][1]);
					glVertex3f(vertices[i][j][3], vertices[i][j][4], vertices[i][j][6]);
				}
			glEnd();
		}
	}

	glPopMatrix();
}


//----------------------------------------------------------------------------


EuphoriaWidget::EuphoriaWidget( TQWidget* parent, const char* name )
              : TQGLWidget(parent, name), texName(0), _wisps(0), _backwisps(0),
	      feedbackmap(0), feedbacktex(0)
{
    setDefaults( Regular );

    _frameTime = 1000 / 60;
    _timer = new TQTimer( this );
    connect( _timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(nextFrame()) );
}


EuphoriaWidget::~EuphoriaWidget()
{
	// Free memory
	if ( texName )
		glDeleteTextures( 1, &texName );
	if ( feedbacktex )
		glDeleteTextures( 1, &feedbacktex );
	delete[] _wisps;
	delete[] _backwisps;
}


void EuphoriaWidget::paintGL()
{
	int i;
	static double lastTime = timeGetTime();

	// update time
	elapsedTime = timeGetTime() - lastTime;
	lastTime += elapsedTime;

    _ec = this;

	// Update wisps
	for(i=0; i<dWisps; i++)
		_wisps[i].update();
	for(i=0; i<dBackground; i++)
		_backwisps[i].update();


	if(dFeedback)
    {
		float feedbackIntensity = float(dFeedback) / 101.0f;

		// update feedback variables
		for(i=0; i<4; i++)
        {
			fr[i] += elapsedTime * fv[i];
			if(fr[i] > PIx2)
				fr[i] -= PIx2;
		}
		f[0] = 30.0f * cos(fr[0]);
		f[1] = 0.2f * cos(fr[1]);
		f[2] = 0.2f * cos(fr[2]);
		f[3] = 0.8f * cos(fr[3]);
		for(i=0; i<3; i++)
        {
			lr[i] += elapsedTime * lv[i];
			if(lr[i] > PIx2)
				lr[i] -= PIx2;
			l[i] = cos(lr[i]);
			l[i] = l[i] * l[i];
		}

		// Create drawing area for feedback texture
		glViewport(0, 0, feedbacktexsize, feedbacktexsize);
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		gluPerspective(30.0, aspectRatio, 0.01f, 20.0f);
		glMatrixMode(GL_MODELVIEW);

		// Draw
		glClear(GL_COLOR_BUFFER_BIT);
		glColor3f(feedbackIntensity, feedbackIntensity, feedbackIntensity);
		glBindTexture(GL_TEXTURE_2D, feedbacktex);
		glPushMatrix();
		glTranslatef(f[1] * l[1], f[2] * l[1], f[3] * l[2]);
		glRotatef(f[0] * l[0], 0, 0, 1);
		glBegin(GL_TRIANGLE_STRIP);
			glTexCoord2f(-0.5f, -0.5f);
			glVertex3f(-aspectRatio*2.0f, -2.0f, 1.25f);
			glTexCoord2f(1.5f, -0.5f);
			glVertex3f(aspectRatio*2.0f, -2.0f, 1.25f);
			glTexCoord2f(-0.5f, 1.5f);
			glVertex3f(-aspectRatio*2.0f, 2.0f, 1.25f);
			glTexCoord2f(1.5f, 1.5f);
			glVertex3f(aspectRatio*2.0f, 2.0f, 1.25f);
		glEnd();
		glPopMatrix();
		glBindTexture(GL_TEXTURE_2D, texName);
		for(i=0; i<dBackground; i++)
			_backwisps[i].drawAsBackground();
		for(i=0; i<dWisps; i++)
			_wisps[i].draw();

		// readback feedback texture
		glReadBuffer(GL_BACK);
		glPixelStorei(GL_UNPACK_ROW_LENGTH, feedbacktexsize);
		glBindTexture(GL_TEXTURE_2D, feedbacktex);
		glReadPixels(0, 0, feedbacktexsize, feedbacktexsize, GL_RGB, GL_UNSIGNED_BYTE, feedbackmap);
		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, feedbacktexsize, feedbacktexsize, GL_RGB, GL_UNSIGNED_BYTE, feedbackmap);

		// create regular drawing area
		glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		gluPerspective(20.0, aspectRatio, 0.01f, 20.0f);
		glMatrixMode(GL_MODELVIEW);

		// Draw again
		glClear(GL_COLOR_BUFFER_BIT);
		glColor3f(feedbackIntensity, feedbackIntensity, feedbackIntensity);
		glPushMatrix();
		glTranslatef(f[1] * l[1], f[2] * l[1], f[3] * l[2]);
		glRotatef(f[0] * l[0], 0, 0, 1);
		glBegin(GL_TRIANGLE_STRIP);
			glTexCoord2f(-0.5f, -0.5f);
			glVertex3f(-aspectRatio*2.0f, -2.0f, 1.25f);
			glTexCoord2f(1.5f, -0.5f);
			glVertex3f(aspectRatio*2.0f, -2.0f, 1.25f);
			glTexCoord2f(-0.5f, 1.5f);
			glVertex3f(-aspectRatio*2.0f, 2.0f, 1.25f);
			glTexCoord2f(1.5f, 1.5f);
			glVertex3f(aspectRatio*2.0f, 2.0f, 1.25f);
		glEnd();
		glPopMatrix();

		glBindTexture(GL_TEXTURE_2D, texName);
	}
	else
		glClear(GL_COLOR_BUFFER_BIT);

	//
	for(i=0; i<dBackground; i++)
		_backwisps[i].drawAsBackground();
	for(i=0; i<dWisps; i++)
		_wisps[i].draw();

	glFlush();
}


void EuphoriaWidget::resizeGL( int w, int h )
{
    glViewport(0, 0, w, h );

	viewport[0] = 0;
	viewport[1] = 0;
	viewport[2] = w;
	viewport[3] = h;

	aspectRatio = (float) w / (float) h;

	// setup regular drawing area just in case feedback isn't used
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
    gluPerspective(20.0, aspectRatio, 0.01, 20);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glTranslatef(0.0, 0.0, -5.0);
}


// Window initialization
void EuphoriaWidget::initializeGL()
{
    // Need to call this to setup viewport[] parameters used in
    // the next updateParameters() call
    resizeGL( width(), height() );

    updateParameters();

    _timer->start( _frameTime, true );
}


#ifdef UNIT_TEST
void EuphoriaWidget::keyPressEvent( TQKeyEvent* e )
{
    if( e->key() == TQt::Key_0 ) { setDefaults( 0 ); updateParameters(); }
    if( e->key() == TQt::Key_1 ) { setDefaults( 1 ); updateParameters(); }
    if( e->key() == TQt::Key_2 ) { setDefaults( 2 ); updateParameters(); }
    if( e->key() == TQt::Key_3 ) { setDefaults( 3 ); updateParameters(); }
    if( e->key() == TQt::Key_4 ) { setDefaults( 4 ); updateParameters(); }
    if( e->key() == TQt::Key_5 ) { setDefaults( 5 ); updateParameters(); }
    if( e->key() == TQt::Key_6 ) { setDefaults( 6 ); updateParameters(); }
    if( e->key() == TQt::Key_7 ) { setDefaults( 7 ); updateParameters(); }
    if( e->key() == TQt::Key_8 ) { setDefaults( 8 ); updateParameters(); }
}
#endif


void EuphoriaWidget::nextFrame()
{
    updateGL();
    _timer->start( _frameTime, true );
}


void EuphoriaWidget::updateParameters()
{
	srand((unsigned)time(NULL));
	rand(); rand(); rand(); rand(); rand();

    elapsedTime = 0.0f;

    fr[0] = 0.0f;
    fr[1] = 0.0f;
    fr[2] = 0.0f;
    fr[3] = 0.0f;

    lr[0] = 0.0f;
    lr[1] = 0.0f;
    lr[2] = 0.0f;

	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT);
	glEnable(GL_BLEND);
	glBlendFunc(GL_ONE, GL_ONE);
	glLineWidth(2.0f);

	// Commented out because smooth lines and textures don't mix on my TNT.
	// It's like it rendering in software mode
	glEnable(GL_LINE_SMOOTH);
	//glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);

	if(dTexture)
    {
		int whichtex = dTexture;
		if(whichtex == 4)  // random texture
			whichtex = myRandi(3) + 1;
		glEnable(GL_TEXTURE_2D);
		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
		// Initialize texture
		glGenTextures(1, &texName);
		glBindTexture(GL_TEXTURE_2D, texName);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
		switch(whichtex){
		case 1:
			gluBuild2DMipmaps(GL_TEXTURE_2D, 1, TEXSIZE, TEXSIZE, GL_LUMINANCE, GL_UNSIGNED_BYTE, plasmamap);
			break;
		case 2:
			gluBuild2DMipmaps(GL_TEXTURE_2D, 1, TEXSIZE, TEXSIZE, GL_LUMINANCE, GL_UNSIGNED_BYTE, stringymap);
			break;
		case 3:
			gluBuild2DMipmaps(GL_TEXTURE_2D, 1, TEXSIZE, TEXSIZE, GL_LUMINANCE, GL_UNSIGNED_BYTE, linesmap);
		}
	} else if ( texName ) {
		glDeleteTextures( 1, &texName );
		texName = 0;
	}

	if(dFeedback)
    {
		feedbacktexsize = int(pow(2.0, dFeedbacksize));
		while(feedbacktexsize > viewport[2] || feedbacktexsize > viewport[3]){
			dFeedbacksize -= 1;
			feedbacktexsize = int(pow(2.0, dFeedbacksize));
		}

		// feedback texture setup
		glEnable(GL_TEXTURE_2D);
		delete [] feedbackmap;
		feedbackmap = new unsigned char[feedbacktexsize*feedbacktexsize*3];
		glGenTextures(1, &feedbacktex);
		glBindTexture(GL_TEXTURE_2D, feedbacktex);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
		glTexImage2D(GL_TEXTURE_2D, 0, 3, feedbacktexsize, feedbacktexsize, 0, GL_RGB, GL_UNSIGNED_BYTE, feedbackmap);

		// feedback velocity variable setup
		fv[0] = float(dFeedbackspeed) * (myRandf(0.025f) + 0.025f);
		fv[1] = float(dFeedbackspeed) * (myRandf(0.05f) + 0.05f);
		fv[2] = float(dFeedbackspeed) * (myRandf(0.05f) + 0.05f);
		fv[3] = float(dFeedbackspeed) * (myRandf(0.1f) + 0.1f);
		lv[0] = float(dFeedbackspeed) * (myRandf(0.0025f) + 0.0025f);
		lv[1] = float(dFeedbackspeed) * (myRandf(0.0025f) + 0.0025f);
		lv[2] = float(dFeedbackspeed) * (myRandf(0.0025f) + 0.0025f);
	} else if ( feedbacktex ) {
		glDeleteTextures( 1, &feedbacktex );
		feedbacktex = 0;
	}

	// Initialize wisps
    _ec = this;
    delete[] _wisps;
    delete[] _backwisps;
	_wisps     = new wisp[dWisps];
	_backwisps = new wisp[dBackground];
}


/**
  May be called at any time - makes no OpenGL calls.
*/
void EuphoriaWidget::setDefaults(int which)
{
	switch(which)
    {
	case Grid:
		dWisps = 4;
		dBackground = 1;
		dDensity = 25;
		dVisibility = 70;
		dSpeed = 15;
		dFeedback = 0;
		dFeedbackspeed = 1;
		dFeedbacksize = 8;
		dWireframe = 1;
		dTexture = 0;
		break;

    case Cubism:
		dWisps = 15;
		dBackground = 0;
		dDensity = 4;
		dVisibility = 15;
		dSpeed = 10;
		dFeedback = 0;
		dFeedbackspeed = 1;
		dFeedbacksize = 8;
		dWireframe = 0;
		dTexture = 0;
		break;

    case BadMath:
		dWisps = 2;
		dBackground = 2;
		dDensity = 20;
		dVisibility = 40;
		dSpeed = 30;
		dFeedback = 40;
		dFeedbackspeed = 5;
		dFeedbacksize = 8;
		dWireframe = 1;
		dTexture = 2;
		break;

    case MTheory:
		dWisps = 3;
		dBackground = 0;
		dDensity = 25;
		dVisibility = 15;
		dSpeed = 20;
		dFeedback = 40;
		dFeedbackspeed = 20;
		dFeedbacksize = 8;
		dWireframe = 0;
		dTexture = 0;
		break;

	case UHFTEM:
		dWisps = 0;
		dBackground = 3;
		dDensity = 35;
		dVisibility = 5;
		dSpeed = 50;
		dFeedback = 0;
		dFeedbackspeed = 1;
		dFeedbacksize = 8;
		dWireframe = 0;
		dTexture = 0;
		break;

    case Nowhere:
		dWisps = 0;
		dBackground = 3;
		dDensity = 30;
		dVisibility = 40;
		dSpeed = 20;
		dFeedback = 80;
		dFeedbackspeed = 10;
		dFeedbacksize = 8;
		dWireframe = 1;
		dTexture = 3;
		break;

    case Echo:
		dWisps = 3;
		dBackground = 0;
		dDensity = 25;
		dVisibility = 30;
		dSpeed = 20;
		dFeedback = 85;
		dFeedbackspeed = 30;
		dFeedbacksize = 8;
		dWireframe = 0;
		dTexture = 1;
		break;

    case Kaleidoscope:
		dWisps = 3;
		dBackground = 0;
		dDensity = 25;
		dVisibility = 40;
		dSpeed = 15;
		dFeedback = 90;
		dFeedbackspeed = 3;
		dFeedbacksize = 8;
		dWireframe = 0;
		dTexture = 0;
		break;

    case Regular:
    default:
		dWisps = 5;
		dBackground = 0;
		dDensity = 25;
		dVisibility = 35;
		dSpeed = 15;
		dFeedback = 0;
		dFeedbackspeed = 1;
		dFeedbacksize = 8;
		dWireframe = 0;
		dTexture = 2;
		break;
	}
}


//----------------------------------------------------------------------------


#ifndef UNIT_TEST
#include <klocale.h>
#include <kglobal.h>
#include <kconfig.h>


// libkscreensaver interface
extern "C"
{
    KDE_EXPORT const char* kss_applicationName = "keuphoria.kss";
    KDE_EXPORT const char* kss_description = I18N_NOOP( "Euphoria" );
    KDE_EXPORT const char* kss_version = "1.0";

    KDE_EXPORT KScreenSaver* kss_create( WId id )
    {
        return new KEuphoriaScreenSaver( id );
    }

    KDE_EXPORT TQDialog* kss_setup()
    {
        return new KEuphoriaSetup;
    }
}


//----------------------------------------------------------------------------


KEuphoriaScreenSaver::KEuphoriaScreenSaver( WId id ) : KScreenSaver( id )
{
    _effect = new EuphoriaWidget;

    readSettings();

    embed( _effect );
    _effect->show();
}


KEuphoriaScreenSaver::~KEuphoriaScreenSaver()
{
}


static int filterRandom( int n )
{
    if( (n < 0) || (n >= EuphoriaWidget::DefaultModes) )
    {
        srand((unsigned)time(NULL));
        n = rand() % EuphoriaWidget::DefaultModes;
    }
    return n;
}


void KEuphoriaScreenSaver::readSettings()
{
    KConfig* config = KGlobal::config();
    config->setGroup("Settings");

    _mode = config->readNumEntry( "Mode", EuphoriaWidget::Regular );
    _effect->setDefaults( filterRandom(_mode) );
}


/**
  Any invalid mode will select one at random.
*/
void KEuphoriaScreenSaver::setMode( int id )
{
    _mode = id;
    _effect->setDefaults( filterRandom(id) );
    _effect->updateParameters();
}


//----------------------------------------------------------------------------


#include <tqlayout.h>
#include <tqlabel.h>
#include <tqcombobox.h>
#include <kmessagebox.h>


static const char* defaultText[] =
{
    I18N_NOOP( "Regular" ),
    I18N_NOOP( "Grid" ),
    I18N_NOOP( "Cubism" ),
    I18N_NOOP( "Bad Math" ),
    I18N_NOOP( "M-Theory" ),
    I18N_NOOP( "UHFTEM" ), //"ultra high frequency tunneling electron microscope",
    I18N_NOOP( "Nowhere" ),
    I18N_NOOP( "Echo" ),
    I18N_NOOP( "Kaleidoscope" ),
    I18N_NOOP( "(Random)" ),
    0
};


KEuphoriaSetup::KEuphoriaSetup( TQWidget* parent, const char* name )
        : KDialogBase( parent, name, true, i18n("Setup Euphoria Screen Saver"),
          Ok|Cancel|Help, Ok, true )
{
    setButtonText( Help, i18n( "A&bout" ) );

    TQWidget *main = makeMainWidget();

    TQHBoxLayout* top    = new TQHBoxLayout(main, 0, spacingHint());
    TQVBoxLayout* leftCol = new TQVBoxLayout;
    top->addLayout( leftCol );

    TQLabel* label = new TQLabel( i18n("Mode:"), main );
    leftCol->addWidget( label );

    modeW = new TQComboBox( main );
    int i = 0;
    while (defaultText[i])
        modeW->insertItem( i18n(defaultText[i++]) );
    leftCol->addWidget( modeW );

    leftCol->addStretch();

    // Preview
    TQWidget* preview;
    preview = new TQWidget( main );
    preview->setFixedSize( 220, 170 );
    preview->setBackgroundColor( black );
    preview->show();    // otherwise saver does not get correct size
    _saver = new KEuphoriaScreenSaver( preview->winId() );
    top->addWidget(preview);

    // Now that we have _saver...
    modeW->setCurrentItem( _saver->mode() );    // set before we connect
    connect( modeW, TQT_SIGNAL(activated(int)), _saver, TQT_SLOT(setMode(int)) );

    setMinimumSize( tqsizeHint() );
}


KEuphoriaSetup::~KEuphoriaSetup()
{
    delete _saver;
}


void KEuphoriaSetup::slotHelp()
{
    KMessageBox::about(this,
        i18n("<h3>Euphoria 1.0</h3>\n<p>Copyright (c) 2002 Terence M. Welsh<br>\n<a href=\"http://www.reallyslick.com/\">http://www.reallyslick.com/</a></p>\n\n<p>Ported to KDE by Karl Robillard</p>"),
        TQString(), KMessageBox::AllowLink);
}


/**
  Ok pressed - save settings and exit
*/
void KEuphoriaSetup::slotOk()
{
    KConfig* config = KGlobal::config();
    config->setGroup("Settings");

    TQString val;
    val.setNum( modeW->currentItem() );
    config->writeEntry("Mode", val );

    config->sync();
    accept();
}
#endif
//----------------------------------------------------------------------------


#ifdef UNIT_TEST
// tqmoc Euphoria.h -o Euphoria.tqmoc
// g++ -g -DUNIT_TEST Euphoria.cpp -I/usr/lib/qt3/include -lqt -L/usr/lib/qt3/lib -lGLU -lGL

#include <tqapplication.h>

int main( int argc, char** argv )
{
    TQApplication app( argc, argv );

    EuphoriaWidget w;
    w.setDefaults( EuphoriaWidget::UHFTEM );
    app.setMainWidget( &w );
    w.show();

    return app.exec();
}
#endif


//EOF