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); } }