void
Cloud::drawWithTexture () const
{
enableTexture();
draw();
disableTexture();
}
//!\brief Draw a frame contained in an IplTexture object on an OpenGL viewport.
void IplTexture::drawQuad(float x, float y, float _width, float _height)
{
if (!this || !getIm()) return;
IplImage *im = getIm();
int w = im->width-1;
int h = im->height-1;
float width = (_width==0 ? im->width : _width);
float height = (_height==0 ? im->height : _height);
loadTexture();
glBegin(GL_QUADS);
glTexCoord2f(u(0), v(0));
glVertex2f(x, y);
glTexCoord2f(u(w), v(0));
glVertex2f(x+width, y);
glTexCoord2f(u(w), v(h));
glVertex2f(x+width, y+height);
glTexCoord2f(u(0), v(h));
glVertex2f(x, y+height);
glEnd();
disableTexture();
}
void Surface::draw(GLfloat w, GLfloat h, GLint textureParam) {
GLint i, j;
GLfloat W, H; // numero de quadrados unitarios de 'dim'
material.apply();
enableTexture(textureParam);
i = j = 0;
W = w / dim;
H = h / dim;
glBegin(GL_QUADS);
for( i = 0; i < H; ++i ) {
for( j = 0; j < W; ++j ) {
glNormal3f(0, 0, 1);
// face visivel sempre a da frente (considerar coordenadas da textura de 0 a 1)
glTexCoord2f(j/W, i/H);
glVertex3f(j*dim-w/2, i*dim-h/2, 0.0);
glTexCoord2f((j+1)/W, i/H);
glVertex3f((j+1)*dim-w/2, i*dim-h/2, 0.0);
glTexCoord2f((j+1)/W, (i+1)/H);
glVertex3f((j+1)*dim-w/2, (i+1)*dim-h/2, 0.0);
glTexCoord2f(j/W, (i+1)/H);
glVertex3f(j*dim-w/2, (i+1)*dim-h/2, 0.0);
}
}
glEnd();
disableTexture();
}
static void
textDrawText (CompScreen *s,
const CompTextData *data,
float x,
float y,
float alpha)
{
GLboolean wasBlend;
GLint oldBlendSrc, oldBlendDst;
CompMatrix *m;
float width, height;
if (!data->texture)
return;
glGetIntegerv (GL_BLEND_SRC, &oldBlendSrc);
glGetIntegerv (GL_BLEND_DST, &oldBlendDst);
wasBlend = glIsEnabled (GL_BLEND);
if (!wasBlend)
glEnable (GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glColor4f (alpha, alpha, alpha, alpha);
enableTexture (s, data->texture, COMP_TEXTURE_FILTER_GOOD);
m = &data->texture->matrix;
width = data->width;
height = data->height;
glBegin (GL_QUADS);
glTexCoord2f (COMP_TEX_COORD_X (m, 0), COMP_TEX_COORD_Y (m, 0));
glVertex2f (x, y - height);
glTexCoord2f (COMP_TEX_COORD_X (m, 0), COMP_TEX_COORD_Y (m, height));
glVertex2f (x, y);
glTexCoord2f (COMP_TEX_COORD_X (m, width), COMP_TEX_COORD_Y (m, height));
glVertex2f (x + width, y);
glTexCoord2f (COMP_TEX_COORD_X (m, width), COMP_TEX_COORD_Y (m, 0));
glVertex2f (x + width, y - height);
glEnd ();
disableTexture (s, data->texture);
glColor4usv (defaultColor);
if (!wasBlend)
glDisable (GL_BLEND);
glBlendFunc (oldBlendSrc, oldBlendDst);
}
// draw line of specified color.
static void drawLine(struct SaslGraphicsCallbacks *canvas, double x1,
double y1, double x2, double y2, double r, double g, double b, double a)
{
OglCanvas *c = (OglCanvas*)canvas;
assert(canvas);
c->lines++;
disableTexture(c);
setMode(c, GL_LINES);
addVertex(c, x1, y1, r, g, b, a, 0, 0);
addVertex(c, x2, y2, r, g, b, a, 0, 0);
}
// draw untextured triangle.
static void drawTriangle(struct SaslGraphicsCallbacks *canvas,
double x1, double y1, double r1, double g1, double b1, double a1,
double x2, double y2, double r2, double g2, double b2, double a2,
double x3, double y3, double r3, double g3, double b3, double a3)
{
OglCanvas *c = (OglCanvas*)canvas;
assert(canvas);
c->triangles++;
disableTexture(c);
setMode(c, GL_TRIANGLES);
addVertex(c, x1, y1, r1, g1, b1, a1, 0, 0);
addVertex(c, x2, y2, r2, g2, b2, a2, 0, 0);
addVertex(c, x3, y3, r3, g3, b3, a3, 0, 0);
}
void
paintCursor (CompCursor *c,
const CompTransform *transform,
Region region,
unsigned int mask)
{
int x1, y1, x2, y2;
if (!c->image)
return;
x1 = c->x;
y1 = c->y;
x2 = c->x + c->image->width;
y2 = c->y + c->image->height;
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
glEnable (GL_BLEND);
enableTexture (c->screen, &c->image->texture, COMP_TEXTURE_FILTER_FAST);
glBegin (GL_QUADS);
glTexCoord2f (COMP_TEX_COORD_X (&c->matrix, x1),
COMP_TEX_COORD_Y (&c->matrix, y2));
glVertex2i (x1, y2);
glTexCoord2f (COMP_TEX_COORD_X (&c->matrix, x2),
COMP_TEX_COORD_Y (&c->matrix, y2));
glVertex2i (x2, y2);
glTexCoord2f (COMP_TEX_COORD_X (&c->matrix, x2),
COMP_TEX_COORD_Y (&c->matrix, y1));
glVertex2i (x2, y1);
glTexCoord2f (COMP_TEX_COORD_X (&c->matrix, x1),
COMP_TEX_COORD_Y (&c->matrix, y1));
glVertex2i (x1, y1);
glEnd ();
disableTexture (c->screen, &c->image->texture);
glDisable (GL_BLEND);
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
}
void DGLShader::disable( bool disableTextureUnits )
{
// disable the shader
glUseProgram(0);
// possibly disable the textures that were bound to this shader
if( disableTextureUnits ) {
// look at the texture units that were bound
for( int i = 0; i < (int)_boundTextures.size(); i++ ) {
// if the given texture was bound, disable it
if( _boundTextures[i].bound ) {
disableTexture( _boundTextures[i].target, _boundTextures[i].unit );
_boundTextures[i].bound = false;
}
}
}
}
void Canvas::flushGL()
{
switch( this->glOperation_ ) {
case None:
break;
case Lines: {
enableVertexArray();
disableTexture();
glVertexPointer(3, GL_FLOAT, 0, this->vertexs_.data());
glDrawArrays(GL_LINES, 0, this->vertexs_.size()/3);
#ifdef DEBUG
{
const GLenum err = glGetError();
if(err != GL_NO_ERROR){
CINAMO_EXCEPTION(Exception, "[BUG] Failed to draw arrays: 0x%08x", err);
}
}
#endif
break;
}
case LineStrip: {
enableVertexArray();
disableTexture();
glVertexPointer(3, GL_FLOAT, 0, this->vertexs_.data());
#ifdef DEBUG
{
const GLenum err = glGetError();
if(err != GL_NO_ERROR){
CINAMO_EXCEPTION(Exception, "[BUG] Failed to set vertex pointer: 0x%08x", err);
}
}
#endif
glDrawArrays(GL_LINE_STRIP, 0, this->vertexs_.size()/3);
#ifdef DEBUG
{
const GLenum err = glGetError();
if(err != GL_NO_ERROR){
CINAMO_EXCEPTION(Exception, "[BUG] Failed to draw arrays: 0x%08x", err);
}
}
#endif
break;
}
case Texture: {
enableVertexArray();
enableTexture();
glVertexPointer(3, GL_FLOAT, 0, this->vertexs_.data());
#ifdef DEBUG
{
const GLenum err = glGetError();
if(err != GL_NO_ERROR){
CINAMO_EXCEPTION(Exception, "[BUG] Failed to set vertex pointer: 0x%08x", err);
}
}
#endif
glTexCoordPointer(2, GL_FLOAT, 0, this->texCoords_.data());
#ifdef DEBUG
{
const GLenum err = glGetError();
if(err != GL_NO_ERROR){
CINAMO_EXCEPTION(Exception, "[BUG] Failed to set vertex pointer: 0x%08x", err);
}
}
#endif
glDrawArrays(GL_TRIANGLES, 0, this->vertexs_.size()/3);
#ifdef DEBUG
{
const GLenum err = glGetError();
if(err != GL_NO_ERROR){
CINAMO_EXCEPTION(Exception, "[BUG] Failed to draw arrays: 0x%08x", err);
}
}
#endif
break;
}
case Rect: {
enableVertexArray();
disableTexture();
glVertexPointer(3, GL_FLOAT, 0, this->vertexs_.data());
#ifdef DEBUG
{
const GLenum err = glGetError();
if(err != GL_NO_ERROR){
CINAMO_EXCEPTION(Exception, "[BUG] Failed to set vertex pointer: 0x%08x", err);
}
}
#endif
glDrawArrays(GL_TRIANGLES, 0, this->vertexs_.size()/3);
#ifdef DEBUG
{
const GLenum err = glGetError();
if(err != GL_NO_ERROR){
CINAMO_EXCEPTION(Exception, "[BUG] Failed to draw arrays: 0x%08x", err);
}
}
#endif
break;
}
default:
CINAMO_EXCEPTION(Exception, "Unknown Operation", this->glOperation_);
break;
}
vertexs_.clear();
texCoords_.clear();
this->glOperation_ = None;
}
void LLCubeMap::disable(void)
{
disableTexture();
disableTextureCoords();
}
static void
paintBackground (CompScreen *s,
Region region,
Bool transformed)
{
CompTexture *bg = &s->backgroundTexture;
BoxPtr pBox = region->rects;
int n, nBox = region->numRects;
GLfloat *d, *data;
if (!nBox)
return;
if (s->desktopWindowCount)
{
if (bg->name)
{
finiTexture (s, bg);
initTexture (s, bg);
}
s->backgroundLoaded = FALSE;
return;
}
else
{
if (!s->backgroundLoaded)
updateScreenBackground (s, bg);
s->backgroundLoaded = TRUE;
}
data = malloc (sizeof (GLfloat) * nBox * 16);
if (!data)
return;
d = data;
n = nBox;
while (n--)
{
*d++ = COMP_TEX_COORD_X (&bg->matrix, pBox->x1);
*d++ = COMP_TEX_COORD_Y (&bg->matrix, pBox->y2);
*d++ = pBox->x1;
*d++ = pBox->y2;
*d++ = COMP_TEX_COORD_X (&bg->matrix, pBox->x2);
*d++ = COMP_TEX_COORD_Y (&bg->matrix, pBox->y2);
*d++ = pBox->x2;
*d++ = pBox->y2;
*d++ = COMP_TEX_COORD_X (&bg->matrix, pBox->x2);
*d++ = COMP_TEX_COORD_Y (&bg->matrix, pBox->y1);
*d++ = pBox->x2;
*d++ = pBox->y1;
*d++ = COMP_TEX_COORD_X (&bg->matrix, pBox->x1);
*d++ = COMP_TEX_COORD_Y (&bg->matrix, pBox->y1);
*d++ = pBox->x1;
*d++ = pBox->y1;
pBox++;
}
glTexCoordPointer (2, GL_FLOAT, sizeof (GLfloat) * 4, data);
glVertexPointer (2, GL_FLOAT, sizeof (GLfloat) * 4, data + 2);
if (bg->name)
{
if (transformed)
enableTexture (s, bg, COMP_TEXTURE_FILTER_GOOD);
else
enableTexture (s, bg, COMP_TEXTURE_FILTER_FAST);
glDrawArrays (GL_QUADS, 0, nBox * 4);
disableTexture (s, bg);
}
else
{
glColor4us (0, 0, 0, 0);
glDrawArrays (GL_QUADS, 0, nBox * 4);
glColor4usv (defaultColor);
}
free (data);
}
static void
thumbPaintThumb (CompScreen *s,
Thumbnail *t,
const CompTransform *transform)
{
AddWindowGeometryProc oldAddWindowGeometry;
CompWindow *w = t->win;
int wx = t->x;
int wy = t->y;
float width = t->width;
float height = t->height;
WindowPaintAttrib sAttrib;
unsigned int mask = PAINT_WINDOW_TRANSFORMED_MASK |
PAINT_WINDOW_TRANSLUCENT_MASK;
THUMB_SCREEN (s);
if (!w)
return;
sAttrib = w->paint;
if (t->textData)
height += t->textData->height + TEXT_DISTANCE;
/* Wrap drawWindowGeometry to make sure the general
drawWindowGeometry function is used */
oldAddWindowGeometry = s->addWindowGeometry;
s->addWindowGeometry = addWindowGeometry;
if (w->texture->pixmap)
{
int off = t->offset;
GLenum filter = display.textureFilter;
FragmentAttrib fragment;
CompTransform wTransform = *transform;
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
const BananaValue *
option_window_like = bananaGetOption (bananaIndex,
"window_like",
s->screenNum);
if (option_window_like->b)
{
glColor4f (1.0, 1.0, 1.0, t->opacity);
enableTexture (s, &ts->windowTexture, COMP_TEXTURE_FILTER_GOOD);
}
else
{
unsigned short color[] = { 0, 0, 0, 0 };
const BananaValue *
option_thumb_color = bananaGetOption (bananaIndex,
"thumb_color",
s->screenNum);
stringToColor (option_thumb_color->s, color);
glColor4us (color[0],
color[1],
color[2],
color[3] * t->opacity);
enableTexture (s, &ts->glowTexture, COMP_TEXTURE_FILTER_GOOD);
}
glBegin (GL_QUADS);
glTexCoord2f (1, 0);
glVertex2f (wx, wy);
glVertex2f (wx, wy + height);
glVertex2f (wx + width, wy + height);
glVertex2f (wx + width, wy);
glTexCoord2f (0, 1);
glVertex2f (wx - off, wy - off);
glTexCoord2f (0, 0);
glVertex2f (wx - off, wy);
glTexCoord2f (1, 0);
glVertex2f (wx, wy);
glTexCoord2f (1, 1);
glVertex2f (wx, wy - off);
glTexCoord2f (1, 1);
glVertex2f (wx + width, wy - off);
glTexCoord2f (1, 0);
glVertex2f (wx + width, wy);
glTexCoord2f (0, 0);
glVertex2f (wx + width + off, wy);
glTexCoord2f (0, 1);
glVertex2f (wx + width + off, wy - off);
glTexCoord2f (0, 0);
glVertex2f (wx - off, wy + height);
glTexCoord2f (0, 1);
glVertex2f (wx - off, wy + height + off);
glTexCoord2f (1, 1);
glVertex2f (wx, wy + height + off);
glTexCoord2f (1, 0);
glVertex2f (wx, wy + height);
glTexCoord2f (1, 0);
glVertex2f (wx + width, wy + height);
glTexCoord2f (1, 1);
glVertex2f (wx + width, wy + height + off);
glTexCoord2f (0, 1);
glVertex2f (wx + width + off, wy + height + off);
glTexCoord2f (0, 0);
glVertex2f (wx + width + off, wy + height);
glTexCoord2f (1, 1);
glVertex2f (wx, wy - off);
glTexCoord2f (1, 0);
glVertex2f (wx, wy);
glTexCoord2f (1, 0);
glVertex2f (wx + width, wy);
glTexCoord2f (1, 1);
glVertex2f (wx + width, wy - off);
glTexCoord2f (1, 0);
glVertex2f (wx, wy + height);
glTexCoord2f (1, 1);
glVertex2f (wx, wy + height + off);
glTexCoord2f (1, 1);
glVertex2f (wx + width, wy + height + off);
glTexCoord2f (1, 0);
glVertex2f (wx + width, wy + height);
glTexCoord2f (0, 0);
glVertex2f (wx - off, wy);
glTexCoord2f (0, 0);
glVertex2f (wx - off, wy + height);
glTexCoord2f (1, 0);
glVertex2f (wx, wy + height);
glTexCoord2f (1, 0);
glVertex2f (wx, wy);
glTexCoord2f (1, 0);
glVertex2f (wx + width, wy);
glTexCoord2f (1, 0);
glVertex2f (wx + width, wy + height);
glTexCoord2f (0, 0);
glVertex2f (wx + width + off, wy + height);
glTexCoord2f (0, 0);
glVertex2f (wx + width + off, wy);
glEnd ();
if (option_window_like->b)
{
disableTexture (s, &ts->windowTexture);
}
else
{
disableTexture (s, &ts->glowTexture);
}
glColor4usv (defaultColor);
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
if (t->textData)
{
float ox = 0.0;
if (t->textData->width < width)
ox = (width - (int)t->textData->width) / 2.0;
textDrawText (s, t->textData, wx + ox, wy + height, t->opacity);
}
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
glDisable (GL_BLEND);
screenTexEnvMode (s, GL_REPLACE);
glColor4usv (defaultColor);
sAttrib.opacity *= t->opacity;
sAttrib.yScale = t->scale;
sAttrib.xScale = t->scale;
sAttrib.xTranslate = wx - w->attrib.x + w->input.left * sAttrib.xScale;
sAttrib.yTranslate = wy - w->attrib.y + w->input.top * sAttrib.yScale;
const BananaValue *
option_mipmap = bananaGetOption (bananaIndex,
"mipmap",
s->screenNum);
if (option_mipmap->b)
display.textureFilter = GL_LINEAR_MIPMAP_LINEAR;
initFragmentAttrib (&fragment, &sAttrib);
matrixTranslate (&wTransform, w->attrib.x, w->attrib.y, 0.0f);
matrixScale (&wTransform, sAttrib.xScale, sAttrib.yScale, 1.0f);
matrixTranslate (&wTransform,
sAttrib.xTranslate / sAttrib.xScale - w->attrib.x,
sAttrib.yTranslate / sAttrib.yScale - w->attrib.y,
0.0f);
glPushMatrix ();
glLoadMatrixf (wTransform.m);
(*s->drawWindow) (w, &wTransform, &fragment, &infiniteRegion, mask);
glPopMatrix ();
display.textureFilter = filter;
}
s->addWindowGeometry = oldAddWindowGeometry;
}
static void
magPaintImage (CompScreen *s)
{
float pw, ph;
int x1, x2, y1, y2;
float vc[4];
float tc[4];
int w, h, cw, ch, cx, cy;
float tmp, xOff, yOff;
MAG_SCREEN (s);
w = ms->overlay.width;
h = ms->overlay.height;
xOff = MIN (w, magGetXOffset (s));
yOff = MIN (h, magGetYOffset (s));
x1 = ms->posX - xOff;
x2 = x1 + w;
y1 = ms->posY - yOff;
y2 = y1 + h;
cw = ceil ((float)w / (ms->zoom * 2.0)) * 2.0;
ch = ceil ((float)h / (ms->zoom * 2.0)) * 2.0;
cw = MIN (w, cw + 2);
ch = MIN (h, ch + 2);
cx = floor (xOff - (xOff / ms->zoom));
cy = h - ch - floor (yOff - (yOff / ms->zoom));
cx = MAX (0, MIN (w - cw, cx));
cy = MAX (0, MIN (h - ch, cy));
glPushAttrib (GL_TEXTURE_BIT);
glEnable (ms->target);
glBindTexture (ms->target, ms->texture);
if (ms->width != w || ms->height != h)
{
glCopyTexImage2D(ms->target, 0, GL_RGB, x1, s->height - y2,
w, h, 0);
ms->width = w;
ms->height = h;
}
else
glCopyTexSubImage2D (ms->target, 0, cx, cy,
x1 + cx, s->height - y2 + cy, cw, ch);
if (ms->target == GL_TEXTURE_2D)
{
pw = 1.0 / ms->width;
ph = 1.0 / ms->height;
}
else
{
pw = 1.0;
ph = 1.0;
}
glMatrixMode (GL_PROJECTION);
glPushMatrix ();
glLoadIdentity ();
glMatrixMode (GL_MODELVIEW);
glPushMatrix ();
glLoadIdentity ();
vc[0] = ((x1 * 2.0) / s->width) - 1.0;
vc[1] = ((x2 * 2.0) / s->width) - 1.0;
vc[2] = ((y1 * -2.0) / s->height) + 1.0;
vc[3] = ((y2 * -2.0) / s->height) + 1.0;
tc[0] = xOff - (xOff / ms->zoom);
tc[1] = tc[0] + (w / ms->zoom);
tc[2] = h - (yOff - (yOff / ms->zoom));
tc[3] = tc[2] - (h / ms->zoom);
tc[0] *= pw;
tc[1] *= pw;
tc[2] *= ph;
tc[3] *= ph;
glEnable (GL_BLEND);
glColor4usv (defaultColor);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
(*s->activeTexture) (GL_TEXTURE1_ARB);
enableTexture (s, &ms->mask.tex, COMP_TEXTURE_FILTER_FAST);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glBegin (GL_QUADS);
(*s->multiTexCoord2f) (GL_TEXTURE0_ARB, tc[0], tc[2]);
(*s->multiTexCoord2f) (GL_TEXTURE1_ARB,
COMP_TEX_COORD_X (&ms->mask.tex.matrix, 0),
COMP_TEX_COORD_Y (&ms->mask.tex.matrix, 0));
glVertex2f (vc[0], vc[2]);
(*s->multiTexCoord2f) (GL_TEXTURE0_ARB, tc[0], tc[3]);
(*s->multiTexCoord2f) (GL_TEXTURE1_ARB,
COMP_TEX_COORD_X (&ms->mask.tex.matrix, 0),
COMP_TEX_COORD_Y (&ms->mask.tex.matrix, h));
glVertex2f (vc[0], vc[3]);
(*s->multiTexCoord2f) (GL_TEXTURE0_ARB, tc[1], tc[3]);
(*s->multiTexCoord2f) (GL_TEXTURE1_ARB,
COMP_TEX_COORD_X (&ms->mask.tex.matrix, w),
COMP_TEX_COORD_Y (&ms->mask.tex.matrix, h));
glVertex2f (vc[1], vc[3]);
(*s->multiTexCoord2f) (GL_TEXTURE0_ARB, tc[1], tc[2]);
(*s->multiTexCoord2f) (GL_TEXTURE1_ARB,
COMP_TEX_COORD_X (&ms->mask.tex.matrix, w),
COMP_TEX_COORD_Y (&ms->mask.tex.matrix, 0));
glVertex2f (vc[1], vc[2]);
glEnd ();
disableTexture (s, &ms->mask.tex);
(*s->activeTexture) (GL_TEXTURE0_ARB);
glBindTexture (ms->target, 0);
glDisable (ms->target);
tmp = MIN (1.0, (ms->zoom - 1) * 3.0);
glColor4f (tmp, tmp, tmp, tmp);
enableTexture (s, &ms->overlay.tex, COMP_TEXTURE_FILTER_FAST);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glBegin (GL_QUADS);
glTexCoord2f (COMP_TEX_COORD_X (&ms->overlay.tex.matrix, 0),
COMP_TEX_COORD_Y (&ms->overlay.tex.matrix, 0));
glVertex2f (vc[0], vc[2]);
glTexCoord2f (COMP_TEX_COORD_X (&ms->overlay.tex.matrix, 0),
COMP_TEX_COORD_Y (&ms->overlay.tex.matrix, h));
glVertex2f (vc[0], vc[3]);
glTexCoord2f (COMP_TEX_COORD_X (&ms->overlay.tex.matrix, w),
COMP_TEX_COORD_Y (&ms->overlay.tex.matrix, h));
glVertex2f (vc[1], vc[3]);
glTexCoord2f (COMP_TEX_COORD_X (&ms->overlay.tex.matrix, w),
COMP_TEX_COORD_Y (&ms->overlay.tex.matrix, 0));
glVertex2f (vc[1], vc[2]);
glEnd ();
disableTexture (s, &ms->overlay.tex);
glColor4usv (defaultColor);
glDisable (GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glPopMatrix();
glMatrixMode (GL_PROJECTION);
glPopMatrix ();
glMatrixMode (GL_MODELVIEW);
glPopAttrib ();
}
static void
NEGDrawWindowTexture (CompWindow *w,
CompTexture *texture,
const FragmentAttrib *attrib,
unsigned int mask)
{
int filter;
NEG_SCREEN (w->screen);
NEG_WINDOW (w);
/* only negate window contents; that's the only case
where w->texture->name == texture->name */
if (nw->isNeg && (texture->name == w->texture->name))
{
if (w->screen->fragmentProgram)
{
FragmentAttrib fa = *attrib;
int function;
function = getNegFragmentFunction (w->screen, texture, w->alpha);
if (function)
addFragmentFunction (&fa, function);
UNWRAP (ns, w->screen, drawWindowTexture);
(*w->screen->drawWindowTexture) (w, texture, &fa, mask);
WRAP (ns, w->screen, drawWindowTexture, NEGDrawWindowTexture);
}
else
{
/* this is for the most part taken from paint.c */
if (mask & PAINT_WINDOW_TRANSFORMED_MASK)
filter = w->screen->filter[WINDOW_TRANS_FILTER];
else if (mask & PAINT_WINDOW_ON_TRANSFORMED_SCREEN_MASK)
filter = w->screen->filter[SCREEN_TRANS_FILTER];
else
filter = w->screen->filter[NOTHING_TRANS_FILTER];
/* if we can addjust saturation, even if it's just on and off */
if (w->screen->canDoSaturated && attrib->saturation != COLOR)
{
GLfloat constant[4];
/* if the paint mask has this set we want to blend */
if (mask & PAINT_WINDOW_TRANSLUCENT_MASK)
glEnable (GL_BLEND);
/* enable the texture */
enableTexture (w->screen, texture, filter);
/* texture combiner */
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_PRIMARY_COLOR);
/* negate */
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_RGB,
GL_ONE_MINUS_SRC_COLOR);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA);
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
glColor4f (1.0f, 1.0f, 1.0f, 0.5f);
/* make another texture active */
(*w->screen->activeTexture) (GL_TEXTURE1_ARB);
/* enable that texture */
enableTexture (w->screen, texture, filter);
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_DOT3_RGB);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_CONSTANT);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
/* if we can do saturation that is in between min and max */
if (w->screen->canDoSlightlySaturated && attrib->saturation > 0)
{
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
constant[0] = 0.5f + 0.5f * RED_SATURATION_WEIGHT;
constant[1] = 0.5f + 0.5f * GREEN_SATURATION_WEIGHT;
constant[2] = 0.5f + 0.5f * BLUE_SATURATION_WEIGHT;
constant[3] = 1.0;
glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
/* mark another texture active */
(*w->screen->activeTexture) (GL_TEXTURE2_ARB);
/* enable that texture */
enableTexture (w->screen, texture, filter);
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE0);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_CONSTANT);
/* negate */
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_RGB,
GL_ONE_MINUS_SRC_COLOR);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA);
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
/* color constant */
constant[3] = attrib->saturation / 65535.0f;
glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
/* if we are not opaque or not fully bright */
if (attrib->opacity < OPAQUE ||
attrib->brightness != BRIGHT)
{
/* activate a new texture */
(*w->screen->activeTexture) (GL_TEXTURE3_ARB);
/* enable that texture */
enableTexture (w->screen, texture, filter);
/* color constant */
constant[3] = attrib->opacity / 65535.0f;
constant[0] = constant[1] = constant[2] =
constant[3] * attrib->brightness /
65535.0f;
glTexEnvfv(GL_TEXTURE_ENV,
GL_TEXTURE_ENV_COLOR, constant);
glTexEnvf(GL_TEXTURE_ENV,
GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_CONSTANT);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_RGB,
GL_SRC_COLOR);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_RGB,
GL_SRC_COLOR);
glTexEnvf (GL_TEXTURE_ENV,
GL_COMBINE_ALPHA, GL_MODULATE);
glTexEnvf(GL_TEXTURE_ENV,
GL_SOURCE0_ALPHA, GL_PREVIOUS);
glTexEnvf(GL_TEXTURE_ENV,
GL_SOURCE1_ALPHA, GL_CONSTANT);
glTexEnvf(GL_TEXTURE_ENV,
GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
glTexEnvf(GL_TEXTURE_ENV,
GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
/* draw the window geometry */
(*w->drawWindowGeometry) (w);
/* disable the current texture */
disableTexture (w->screen, texture);
/* set texture mode back to replace */
glTexEnvi (GL_TEXTURE_ENV,
GL_TEXTURE_ENV_MODE, GL_REPLACE);
/* re-activate last texture */
(*w->screen->activeTexture) (GL_TEXTURE2_ARB);
}
else
{
/* fully opaque and bright */
/* draw the window geometry */
(*w->drawWindowGeometry) (w);
}
/* disable the current texture */
disableTexture (w->screen, texture);
/* set the texture mode back to replace */
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
/* re-activate last texture */
(*w->screen->activeTexture) (GL_TEXTURE1_ARB);
}
else
{
/* fully saturated or fully unsaturated */
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_CONSTANT);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
/* color constant */
constant[3] = attrib->opacity / 65535.0f;
constant[0] = constant[1] = constant[2] =
constant[3] * attrib->brightness / 65535.0f;
constant[0] =
0.5f + 0.5f * RED_SATURATION_WEIGHT * constant[0];
constant[1] =
0.5f + 0.5f * GREEN_SATURATION_WEIGHT * constant[1];
constant[2] =
0.5f + 0.5f * BLUE_SATURATION_WEIGHT * constant[2];
glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
/* draw the window geometry */
(*w->drawWindowGeometry) (w);
}
/* disable the current texture */
disableTexture (w->screen, texture);
/* set the texture mode back to replace */
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
/* re-activate last texture */
(*w->screen->activeTexture) (GL_TEXTURE0_ARB);
/* disable that texture */
disableTexture (w->screen, texture);
/* set the default color */
glColor4usv (defaultColor);
/* set screens texture mode back to replace */
screenTexEnvMode (w->screen, GL_REPLACE);
/* if it's a translucent window, disable blending */
if (mask & PAINT_WINDOW_TRANSLUCENT_MASK)
glDisable (GL_BLEND);
}
else
{
/* no saturation adjustments */
/* enable the current texture */
enableTexture (w->screen, texture, filter);
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
/* negate */
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB,
GL_ONE_MINUS_SRC_COLOR);
/* we are not opaque or fully bright */
if ((mask & PAINT_WINDOW_TRANSLUCENT_MASK) ||
attrib->brightness != BRIGHT)
{
GLfloat constant[4];
/* enable blending */
glEnable (GL_BLEND);
/* color constant */
constant[3] = attrib->opacity / 65535.0f;
constant[0] = constant[3] * attrib->brightness / 65535.0f;
constant[1] = constant[3] * attrib->brightness / 65535.0f;
constant[2] = constant[3] * attrib->brightness / 65535.0f;
glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constant);
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_CONSTANT);
/* negate */
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_RGB,
GL_ONE_MINUS_SRC_COLOR);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
glTexEnvf (GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_CONSTANT);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
glTexEnvf (GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
/* draw the window geometry */
(*w->drawWindowGeometry) (w);
/* disable blending */
glDisable (GL_BLEND);
}
else
{
/* no adjustments to saturation, brightness or opacity */
/* draw the window geometry */
(*w->drawWindowGeometry) (w);
}
/* disable the current texture */
disableTexture (w->screen, texture);
/* set the screens texture mode back to replace */
screenTexEnvMode (w->screen, GL_REPLACE);
}
}
}
else
{
/* not negative */
UNWRAP (ns, w->screen, drawWindowTexture);
(*w->screen->drawWindowTexture) (w, texture, attrib, mask);
WRAP (ns, w->screen, drawWindowTexture, NEGDrawWindowTexture);
}
}
static void
beginRendering (SnowScreen *ss,
CompScreen *s)
{
if (starGetUseBlending (s->display))
glEnable (GL_BLEND);
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
if (ss->displayListNeedsUpdate)
{
setupDisplayList (ss);
ss->displayListNeedsUpdate = FALSE;
}
glColor4f (1.0, 1.0, 1.0, 1.0);
if (ss->snowTexturesLoaded && starGetUseTextures (s->display))
{
int j = 0;
for (j = 0; j < ss->snowTexturesLoaded; j++)
{
int i, numFlakes = starGetNumSnowflakes (s->display);
SnowFlake *snowFlake = ss->allSnowFlakes;
enableTexture (ss->s, &ss->snowTex[j].tex, COMP_TEXTURE_FILTER_GOOD);
for (i = 0; i < numFlakes; i++)
{
if (snowFlake->tex == &ss->snowTex[j])
{
glTranslatef(snowFlake->x, snowFlake->y, snowFlake->z);
glCallList(ss->snowTex[j].dList);
glTranslatef(-snowFlake->x, -snowFlake->y, -snowFlake->z);
}
snowFlake++;
}
disableTexture (ss->s, &ss->snowTex[j].tex);
}
/*int j;
for (j = 0; j < ss->snowTexturesLoaded; j++)
{
SnowFlake *snowFlake = ss->allSnowFlakes;
int i, numFlakes = snowGetNumSnowflakes (s->display);
Bool snowRotate = snowGetSnowRotation (s->display);
enableTexture (ss->s, &ss->snowTex[j].tex,
COMP_TEXTURE_FILTER_GOOD);
for (i = 0; i < numFlakes; i++)
{
if (snowFlake->tex == &ss->snowTex[j])
{
glTranslatef (snowFlake->x, snowFlake->y, snowFlake->z);
if (snowRotate)
glRotatef (snowFlake->ra, 0, 0, 1);
glCallList (ss->snowTex[j].dList);
if (snowRotate)
glRotatef (-snowFlake->ra, 0, 0, 1);
glTranslatef (-snowFlake->x, -snowFlake->y, -snowFlake->z);
}
snowFlake++;
}
disableTexture (ss->s, &ss->snowTex[j].tex);
}*/
}
else
{
SnowFlake *snowFlake = ss->allSnowFlakes;
int i, numFlakes = starGetNumSnowflakes (s->display);
for (i = 0; i < numFlakes; i++)
{
glTranslatef (snowFlake->x, snowFlake->y, snowFlake->z);
glRotatef (snowFlake->ra, 0, 0, 1);
glCallList (ss->displayList);
glRotatef (-snowFlake->ra, 0, 0, 1);
glTranslatef (-snowFlake->x, -snowFlake->y, -snowFlake->z);
snowFlake++;
}
}
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
if (starGetUseBlending (s->display))
{
glDisable (GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
}
}
static void
beginRendering (CompScreen *s)
{
int j;
E_SCREEN (s);
glEnable (GL_BLEND);
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
if (eScreen->needUpdate)
{
setupDisplayList (eScreen);
eScreen->needUpdate = FALSE;
}
glColor4f (1.0, 1.0, 1.0, 1.0);
for (j = 0; j < eScreen->numElements; j++)
{
element *ele = eScreen->allElements;
int i, numAutumn, numFf, numSnow, numStars, numBubbles;
if (eScreen->isActive[0])
numAutumn = elementsGetNumLeaves (s->display);
else
numAutumn = 0;
if (eScreen->isActive[1])
numFf = elementsGetNumFireflies (s->display);
else
numFf = 0;
if (eScreen->isActive[2])
numSnow = elementsGetNumSnowflakes (s->display);
else
numSnow = 0;
if (eScreen->isActive[3])
numStars = elementsGetNumStars (s->display);
else
numStars = 0;
if (eScreen->isActive[4])
numBubbles = elementsGetNumBubbles (s->display);
else
numBubbles = 0;
int numTmp = numAutumn + numFf + numSnow + numStars + numBubbles;
Bool autumnRotate = elementsGetAutumnRotate (s->display);
Bool snowRotate = elementsGetSnowRotate (s->display);
Bool ffRotate = elementsGetFirefliesRotate (s->display);
Bool starsRotate = elementsGetStarsRotate (s->display);
Bool bubblesRotate = elementsGetBubblesRotate (s->display);
enableTexture (eScreen->cScreen, &eScreen->textu[j].tex,
COMP_TEXTURE_FILTER_GOOD);
for (i = 0; i < numTmp; i++)
{
if (ele->eTex == &eScreen->textu[j])
{
glTranslatef (ele->x, ele->y, ele->z);
if (autumnRotate && ele->type == 0)
glRotatef (ele->rAngle, 0, 0, 1);
if (ffRotate && ele->type == 1)
glRotatef (ele->rAngle, 0, 0, 1);
if (snowRotate && ele->type == 2)
glRotatef (ele->rAngle, 0, 0, 1);
if (starsRotate && ele->type == 3)
glRotatef (ele->rAngle, 0, 0, 1);
if (bubblesRotate && ele->type == 4)
glRotatef (ele->rAngle, 0, 0, 1);
glCallList (eScreen->textu[j].dList);
if (autumnRotate && ele->type == 0)
glRotatef (-ele->rAngle, 0, 0, 1);
if (ffRotate && ele->type == 1)
glRotatef (-ele->rAngle, 0, 0, 1);
if (snowRotate && ele->type == 2)
glRotatef (-ele->rAngle, 0, 0, 1);
if (starsRotate && ele->type == 3)
glRotatef (-ele->rAngle, 0, 0, 1);
if (bubblesRotate && ele->type == 4)
glRotatef (-ele->rAngle, 0, 0, 1);
glTranslatef (-ele->x, -ele->y, -ele->z);
}
ele++;
}
disableTexture (eScreen->cScreen, &eScreen->textu[j].tex);
}
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glDisable (GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
}
static void
scalefilterDrawFilterText (CompScreen *s,
CompOutput *output)
{
FILTER_SCREEN (s);
GLboolean wasBlend;
GLint oldBlendSrc, oldBlendDst;
int ox1, ox2, oy1, oy2;
float width = fs->filterInfo->textWidth;
float height = fs->filterInfo->textHeight;
float border = scalefilterGetBorderSize (s);
ox1 = output->region.extents.x1;
ox2 = output->region.extents.x2;
oy1 = output->region.extents.y1;
oy2 = output->region.extents.y2;
float x = ox1 + ((ox2 - ox1) / 2) - (width / 2);
float y = oy1 + ((oy2 - oy1) / 2) + (height / 2);
x = floor (x);
y = floor (y);
wasBlend = glIsEnabled (GL_BLEND);
glGetIntegerv (GL_BLEND_SRC, &oldBlendSrc);
glGetIntegerv (GL_BLEND_DST, &oldBlendDst);
if (!wasBlend)
glEnable (GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glColor4us (scalefilterGetBackColorRed (s),
scalefilterGetBackColorGreen (s),
scalefilterGetBackColorBlue (s),
scalefilterGetBackColorAlpha (s));
glPushMatrix ();
glTranslatef (x, y - height, 0.0f);
glRectf (0.0f, height, width, 0.0f);
glRectf (0.0f, 0.0f, width, -border);
glRectf (0.0f, height + border, width, height);
glRectf (-border, height, 0.0f, 0.0f);
glRectf (width, height, width + border, 0.0f);
glTranslatef (-border, -border, 0.0f);
#define CORNER(a,b) \
for (k = a; k < b; k++) \
{\
float rad = k* (3.14159 / 180.0f);\
glVertex2f (0.0f, 0.0f);\
glVertex2f (cos (rad) * border, sin (rad) * border);\
glVertex2f (cos ((k - 1) * (3.14159 / 180.0f)) * border, \
sin ((k - 1) * (3.14159 / 180.0f)) * border);\
}
/* Rounded corners */
int k;
glTranslatef (border, border, 0.0f);
glBegin (GL_TRIANGLES);
CORNER (180, 270) glEnd();
glTranslatef (-border, -border, 0.0f);
glTranslatef (width + border, border, 0.0f);
glBegin (GL_TRIANGLES);
CORNER (270, 360) glEnd();
glTranslatef (-(width + border), -border, 0.0f);
glTranslatef (border, height + border, 0.0f);
glBegin (GL_TRIANGLES);
CORNER (90, 180) glEnd();
glTranslatef (-border, -(height + border), 0.0f);
glTranslatef (width + border, height + border, 0.0f);
glBegin (GL_TRIANGLES);
CORNER (0, 90) glEnd();
glTranslatef (-(width + border), -(height + border), 0.0f);
glPopMatrix ();
#undef CORNER
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glColor4f (1.0, 1.0, 1.0, 1.0);
enableTexture (s, &fs->filterInfo->textTexture, COMP_TEXTURE_FILTER_GOOD);
CompMatrix *m = &fs->filterInfo->textTexture.matrix;
glBegin (GL_QUADS);
glTexCoord2f (COMP_TEX_COORD_X(m, 0),COMP_TEX_COORD_Y(m ,0));
glVertex2f (x, y - height);
glTexCoord2f (COMP_TEX_COORD_X(m, 0),COMP_TEX_COORD_Y(m, height));
glVertex2f (x, y);
glTexCoord2f (COMP_TEX_COORD_X(m, width),COMP_TEX_COORD_Y(m, height));
glVertex2f (x + width, y);
glTexCoord2f (COMP_TEX_COORD_X(m, width),COMP_TEX_COORD_Y(m, 0));
glVertex2f (x + width, y - height);
glEnd ();
disableTexture (s, &fs->filterInfo->textTexture);
glColor4usv (defaultColor);
if (!wasBlend)
glDisable (GL_BLEND);
glBlendFunc (oldBlendSrc, oldBlendDst);
}
static void
beginRendering (SnowScreen *ss,
CompScreen *s)
{
const BananaValue *
option_use_blending = bananaGetOption (bananaIndex,
"use_blending",
-1);
const BananaValue *
option_use_textures = bananaGetOption (bananaIndex,
"use_textures",
-1);
const BananaValue *
option_num_snowflakes = bananaGetOption (bananaIndex,
"num_snowflakes",
-1);
const BananaValue *
option_snow_rotation = bananaGetOption (bananaIndex,
"snow_rotation",
-1);
if (option_use_blending->b)
glEnable (GL_BLEND);
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
if (ss->displayListNeedsUpdate)
{
setupDisplayList (ss);
ss->displayListNeedsUpdate = FALSE;
}
glColor4f (1.0, 1.0, 1.0, 1.0);
if (ss->snowTexturesLoaded && option_use_textures->b)
{
int j;
for (j = 0; j < ss->snowTexturesLoaded; j++)
{
SnowFlake *snowFlake = ss->allSnowFlakes;
int i, numFlakes = option_num_snowflakes->i;
Bool snowRotate = option_snow_rotation->b;
enableTexture (ss->s, &ss->snowTex[j].tex,
COMP_TEXTURE_FILTER_GOOD);
for (i = 0; i < numFlakes; i++)
{
if (snowFlake->tex == &ss->snowTex[j])
{
glTranslatef (snowFlake->x, snowFlake->y, snowFlake->z);
if (snowRotate)
glRotatef (snowFlake->ra, 0, 0, 1);
glCallList (ss->snowTex[j].dList);
if (snowRotate)
glRotatef (-snowFlake->ra, 0, 0, 1);
glTranslatef (-snowFlake->x, -snowFlake->y, -snowFlake->z);
}
snowFlake++;
}
disableTexture (ss->s, &ss->snowTex[j].tex);
}
}
else
{
SnowFlake *snowFlake = ss->allSnowFlakes;
int i, numFlakes = option_num_snowflakes->i;
for (i = 0; i < numFlakes; i++)
{
glTranslatef (snowFlake->x, snowFlake->y, snowFlake->z);
glRotatef (snowFlake->ra, 0, 0, 1);
glCallList (ss->displayList);
glRotatef (-snowFlake->ra, 0, 0, 1);
glTranslatef (-snowFlake->x, -snowFlake->y, -snowFlake->z);
snowFlake++;
}
}
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
if (option_use_blending->b)
{
glDisable (GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
}
}
