static Bool
waterToggleRain(CompDisplay * d,
CompAction * action,
CompActionState state, CompOption * option, int nOption)
{
CompScreen *s;
WATER_DISPLAY(d);
s = findScreenAtDisplay(d,
getIntOptionNamed(option, nOption, "root", 0));
if (s) {
WATER_SCREEN(s);
if (!ws->rainHandle) {
int delay;
delay =
wd->opt[WATER_DISPLAY_OPTION_RAIN_DELAY].value.i;
ws->rainHandle =
compAddTimeout(delay, (float)delay * 1.2,
waterRainTimeout, s);
} else {
compRemoveTimeout(ws->rainHandle);
ws->rainHandle = 0;
}
}
return FALSE;
}
static CompOption *waterGetDisplayOptions(CompPlugin * plugin,
CompDisplay * display, int *count)
{
WATER_DISPLAY(display);
*count = NUM_OPTIONS(wd);
return wd->opt;
}
static void waterFiniDisplay(CompPlugin * p, CompDisplay * d)
{
WATER_DISPLAY(d);
freeScreenPrivateIndex(d, wd->screenPrivateIndex);
UNWRAP(wd, d, handleEvent);
compFiniDisplayOptions(d, wd->opt, WATER_DISPLAY_OPTION_NUM);
free(wd);
}
static Bool
waterSetDisplayOption (CompPlugin *plugin,
CompDisplay *display,
const char *name,
CompOptionValue *value)
{
CompOption *o;
int index;
WATER_DISPLAY (display);
o = compFindOption (wd->opt, NUM_OPTIONS (wd), name, &index);
if (!o)
return FALSE;
switch (index) {
case WATER_DISPLAY_OPTION_OFFSET_SCALE:
if (compSetFloatOption (o, value))
{
wd->offsetScale = o->value.f * 50.0f;
return TRUE;
}
break;
case WATER_DISPLAY_OPTION_RAIN_DELAY:
if (compSetIntOption (o, value))
{
CompScreen *s;
for (s = display->screens; s; s = s->next)
{
WATER_SCREEN (s);
if (!ws->rainHandle)
continue;
compRemoveTimeout (ws->rainHandle);
ws->rainHandle = compAddTimeout (value->i,
(float)value->i * 1.2,
waterRainTimeout, s);
}
return TRUE;
}
break;
default:
return compSetDisplayOption (display, o, value);
}
return FALSE;
}
static void
waterHandleEvent (CompDisplay *d,
XEvent *event)
{
CompScreen *s;
WATER_DISPLAY (d);
switch (event->type) {
case ButtonPress:
s = findScreenAtDisplay (d, event->xbutton.root);
if (s)
{
WATER_SCREEN (s);
if (ws->grabIndex)
{
XPoint p;
p.x = pointerX;
p.y = pointerY;
waterVertices (s, GL_POINTS, &p, 1, 0.8f);
damageScreen (s);
}
}
break;
case EnterNotify:
case LeaveNotify:
waterHandleMotionEvent (d, event->xcrossing.root);
break;
case MotionNotify:
waterHandleMotionEvent (d, event->xmotion.root);
default:
break;
}
UNWRAP (wd, d, handleEvent);
(*d->handleEvent) (d, event);
WRAP (wd, d, handleEvent, waterHandleEvent);
}
static Bool waterInitScreen(CompPlugin * p, CompScreen * s)
{
WaterScreen *ws;
WATER_DISPLAY(s->display);
ws = calloc(1, sizeof(WaterScreen));
if (!ws)
return FALSE;
ws->grabIndex = 0;
WRAP(ws, s, preparePaintScreen, waterPreparePaintScreen);
WRAP(ws, s, donePaintScreen, waterDonePaintScreen);
WRAP(ws, s, drawWindowTexture, waterDrawWindowTexture);
s->base.privates[wd->screenPrivateIndex].ptr = ws;
waterReset(s);
return TRUE;
}
static void
waterDrawWindowTexture(CompWindow * w,
CompTexture * texture,
const FragmentAttrib * attrib, unsigned int mask)
{
WATER_SCREEN(w->screen);
if (ws->count) {
FragmentAttrib fa = *attrib;
Bool lighting = w->screen->lighting;
int param, function, unit;
GLfloat plane[4];
WATER_DISPLAY(w->screen->display);
param = allocFragmentParameters(&fa, 1);
unit = allocFragmentTextureUnits(&fa, 1);
function =
getBumpMapFragmentFunction(w->screen, texture, unit, param);
if (function) {
addFragmentFunction(&fa, function);
screenLighting(w->screen, TRUE);
(*w->screen->activeTexture) (GL_TEXTURE0_ARB + unit);
glBindTexture(ws->target, ws->texture[TINDEX(ws, 0)]);
plane[1] = plane[2] = 0.0f;
plane[0] = ws->tx / (GLfloat) w->screen->width;
plane[3] = 0.0f;
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_S, GL_EYE_PLANE, plane);
glEnable(GL_TEXTURE_GEN_S);
plane[0] = plane[2] = 0.0f;
plane[1] = ws->ty / (GLfloat) w->screen->height;
plane[3] = 0.0f;
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv(GL_T, GL_EYE_PLANE, plane);
glEnable(GL_TEXTURE_GEN_T);
(*w->screen->activeTexture) (GL_TEXTURE0_ARB);
(*w->screen->
programEnvParameter4f) (GL_FRAGMENT_PROGRAM_ARB, param,
texture->matrix.yy *
wd->offsetScale,
-texture->matrix.xx *
wd->offsetScale, 0.0f, 0.0f);
}
/* to get appropriate filtering of texture */
mask |= PAINT_WINDOW_ON_TRANSFORMED_SCREEN_MASK;
UNWRAP(ws, w->screen, drawWindowTexture);
(*w->screen->drawWindowTexture) (w, texture, &fa, mask);
WRAP(ws, w->screen, drawWindowTexture, waterDrawWindowTexture);
if (function) {
(*w->screen->activeTexture) (GL_TEXTURE0_ARB + unit);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_S);
glBindTexture(ws->target, 0);
(*w->screen->activeTexture) (GL_TEXTURE0_ARB);
screenLighting(w->screen, lighting);
}
} else {
UNWRAP(ws, w->screen, drawWindowTexture);
(*w->screen->drawWindowTexture) (w, texture, attrib, mask);
WRAP(ws, w->screen, drawWindowTexture, waterDrawWindowTexture);
}
}
