166 lines
3.9 KiB
C++
166 lines
3.9 KiB
C++
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
#include <math.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
|
|
#include <GL/gl.h>
|
|
#include <GL/glu.h>
|
|
|
|
#include "Tunnel.h"
|
|
|
|
using namespace std;
|
|
|
|
#define N_INITIAL_LAYERS 8
|
|
#define N_LOGOS_PER_RING 12
|
|
#define RING_RADIUS 18
|
|
#define BREAKOFF_DIST 80
|
|
#define RING_LAYER_DIST 10
|
|
#define XLATE_RATE 0.02
|
|
#define REVOLUTION_TIME 15000
|
|
#define DESTROY_DIST 260
|
|
#define BREAK_RATE 0.03
|
|
|
|
Tunnel::Tunnel()
|
|
{
|
|
m_last_ticks = 0;
|
|
srand(time(NULL) + getpid());
|
|
}
|
|
|
|
Tunnel::~Tunnel()
|
|
{
|
|
}
|
|
|
|
void Tunnel::getRandomBreakAxis(float (*axis)[3])
|
|
{
|
|
double alpha = rand() / (double)RAND_MAX * 2.0 * M_PI;
|
|
double beta = rand() / (double)RAND_MAX * M_PI_2;
|
|
(*axis)[0] = cos(alpha) * sin(beta);
|
|
(*axis)[2] = sin(alpha) * sin(beta);
|
|
(*axis)[1] = 0.5 + cos(beta);
|
|
}
|
|
|
|
float Tunnel::getRandomBreakSpinSpeed()
|
|
{
|
|
return 0.01 + rand() / (double)RAND_MAX * 0.01;
|
|
}
|
|
|
|
bool Tunnel::expose (GnomeScreensaver & gs)
|
|
{
|
|
if (m_last_ticks == 0)
|
|
{
|
|
m_last_ticks = gs.getTicks();
|
|
m_start_ticks = m_last_ticks;
|
|
}
|
|
uint64_t ticks = gs.getTicks();
|
|
int elapsed = ticks - m_last_ticks;
|
|
m_offset += XLATE_RATE * elapsed;
|
|
while (m_offset - m_last_ring_offset > RING_LAYER_DIST)
|
|
{
|
|
m_last_ring_offset += RING_LAYER_DIST;
|
|
addRing(m_last_ring_offset);
|
|
}
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
glPushMatrix();
|
|
glRotatef(360.0 *
|
|
((ticks - m_start_ticks) % REVOLUTION_TIME) / REVOLUTION_TIME,
|
|
0, 1, 0);
|
|
for (list<LBStruct>::iterator it = m_logos.begin();
|
|
it != m_logos.end();
|
|
it++)
|
|
{
|
|
double diff_offset = m_offset - it->offset;
|
|
if (diff_offset > DESTROY_DIST)
|
|
{
|
|
m_logos.erase(it++);
|
|
continue;
|
|
}
|
|
|
|
if (it->break_ticks == 0 && diff_offset > BREAKOFF_DIST)
|
|
{
|
|
it->break_ticks = ticks;
|
|
getRandomAxis(&it->spin_axis);
|
|
getRandomBreakAxis(&it->break_axis);
|
|
it->spin_rate = getRandomBreakSpinSpeed();
|
|
}
|
|
glPushMatrix();
|
|
if (it->break_ticks)
|
|
{
|
|
int break_ticks = ticks - it->break_ticks;
|
|
glTranslatef(BREAK_RATE * break_ticks * it->break_axis[0],
|
|
BREAK_RATE * break_ticks * it->break_axis[1],
|
|
BREAK_RATE * break_ticks * it->break_axis[2]);
|
|
}
|
|
glTranslatef(0, diff_offset, 0);
|
|
glRotatef(it->trot, 0, 1, 0);
|
|
glTranslatef(RING_RADIUS, 0, 0);
|
|
glRotatef(-90.0, 0, 0, 1);
|
|
glRotatef(90.0, 1, 0, 0);
|
|
glRotatef(it->zrot, 0, 0, 1);
|
|
if (it->break_ticks)
|
|
{
|
|
glRotatef(it->spin_rate * (ticks - it->break_ticks),
|
|
it->spin_axis[0],
|
|
it->spin_axis[1],
|
|
it->spin_axis[2]);
|
|
}
|
|
m_logobox.draw();
|
|
glPopMatrix();
|
|
}
|
|
glPopMatrix();
|
|
|
|
m_last_ticks = ticks;
|
|
|
|
return true;
|
|
}
|
|
|
|
void Tunnel::addRing(double offset)
|
|
{
|
|
for (int j = 0; j < N_LOGOS_PER_RING; j++)
|
|
{
|
|
float zrot = ((j + m_ring_rot_idx) & 0x3) * 90.0;
|
|
float trot = j * 360.0 / N_LOGOS_PER_RING;
|
|
LBStruct lbs = {
|
|
offset,
|
|
zrot,
|
|
trot,
|
|
0
|
|
};
|
|
m_logos.push_back(lbs);
|
|
}
|
|
m_ring_rot_idx++;
|
|
}
|
|
|
|
bool Tunnel::configure (GnomeScreensaver & gs)
|
|
{
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
gluPerspective(60.0, gs.getAspectRatio() / gs.getNumMonitors(),
|
|
0.01, 1000.0);
|
|
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
gluLookAt(0, 0, 0, 0, 1, 0, 0, 0, 1);
|
|
|
|
glViewport(0, 0, gs.getWidth(), gs.getHeight());
|
|
|
|
m_logos.clear();
|
|
for (int i = 0; i <= N_INITIAL_LAYERS; i++)
|
|
{
|
|
addRing((i - N_INITIAL_LAYERS) * RING_LAYER_DIST);
|
|
}
|
|
|
|
m_offset = 0.0;
|
|
m_last_ring_offset = 0.0;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Tunnel::update (GnomeScreensaver & gs)
|
|
{
|
|
return true;
|
|
}
|