e16/src/fx.c

/*
 * Copyright (C) 2000-2007 Carsten Haitzler, Geoff Harrison and various contributors
 * Copyright (C) 2004-2021 Kim Woelders
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies of the Software, its documentation and marketing & publicity
 * materials, and acknowledgment shall be given in the documentation, materials
 * and software packages that this Software was used.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#include "config.h"

#include <math.h>
#include <X11/Xlib.h>
#if USE_XRENDER
#define FX_USE_RENDER 1
#include <X11/extensions/Xrender.h>
#endif

#include "E.h"
#include "animation.h"
#include "desktops.h"
#include "dialog.h"
#include "ecompmgr.h"
#include "eimage.h"
#include "emodule.h"
#include "settings.h"
#include "util.h"
#include "xwin.h"

#define M_2PI_F ((float)(2 * M_PI))

#define FX_OP_ENABLE  1		/* Enable, start */
#define FX_OP_DISABLE 2		/* Disable, stop */
#define FX_OP_START   3		/* Start (if enabled) */
#define FX_OP_PAUSE   4
#define FX_OP_DESK    5

typedef struct {
   const char         *name;
   void                (*init_func)(const char *name);
   void                (*ops_func)(int op);
   char                enabled;
   char                active;
} FXHandler;

typedef struct {
   Win                 win;
   EX_Window           root;
   EX_Pixmap           above;
   int                 count;
   float               incv, inch, incx;
#if FX_USE_RENDER
   EX_Picture          pict_buf;
   EX_Picture          pict_win;
#if USE_COMPOSITE
   EX_Picture          pict_win_clip;
#endif
#else
   GC                  gc1;
#endif
} FXData;

static void
_FxSetup(FXData * d, unsigned int height)
{
   EObj               *bgeo;

   if (!d->above)
     {
	bgeo = DeskGetBackgroundObj(DesksGetCurrent());

	d->win = EobjGetWin(bgeo);
#if USE_COMPOSITE
	if (ECompMgrIsActive() && !Mode.wm.window)
	   d->root = ECompMgrRootWin();
	else
#endif
	   d->root = EobjGetXwin(bgeo);
	d->above = ECreatePixmap(d->win, WinGetW(VROOT), height, 0);

#if FX_USE_RENDER
	XRenderPictureAttributes pa;

	d->pict_buf = EPictureCreate(NULL, d->above);
	d->pict_win = EPictureCreate(NULL, d->root);
#if USE_COMPOSITE
	d->pict_win_clip = EPictureCreate(NULL, d->root);
#endif
	pa.subwindow_mode = ClipByChildren;
	XRenderChangePicture(disp, d->pict_win, CPSubwindowMode, &pa);
#else
	XGCValues           xgcv;

	xgcv.subwindow_mode = ClipByChildren;
	if (!d->gc1)
	   d->gc1 = EXCreateGC(d->root, GCSubwindowMode, &xgcv);
#endif
     }

#if USE_COMPOSITE
#if FX_USE_RENDER
   EPictureSetClip(d->pict_win_clip, ECompMgrChildClipRegion());
#else
   /* As of composite 0.4 we need to set the clip region */
   EGCSetClip(d->gc1, ECompMgrChildClipRegion());
#endif
#endif
}

static void
_FxCleanup(FXData * d, int h)
{
   if (h == 0)
     {
	EFreePixmap(d->above);
	d->above = NoXID;
	d->count = 0;
     }
   else
     {
#if FX_USE_RENDER
	EPictureDestroy(d->pict_buf);
	EPictureDestroy(d->pict_win);
#if USE_COMPOSITE
	EPictureDestroy(d->pict_win_clip);
#endif
#else
	EXFreeGC(d->gc1);
#endif

	EClearArea(d->win, 0, WinGetH(VROOT) - h, WinGetW(VROOT), h);
#if USE_COMPOSITE
	ECompMgrDamageArea(0, WinGetH(VROOT) - h, WinGetW(VROOT), h);
#endif
     }
}

static void
_FxCopyArea(FXData * d, int out, int src_x, int src_y, int dst_x, int dst_y,
	    unsigned int width, unsigned int height)
{
   EX_ID               src, dst;

#if FX_USE_RENDER
   if (out)
     {
	src = d->pict_buf;
#if USE_COMPOSITE
	dst = d->pict_win_clip;
#else
	dst = d->pict_win;
#endif
     }
   else
     {
	src = d->pict_win;
	dst = d->pict_buf;
     }

   XRenderComposite(disp, PictOpSrc, src, NoXID, dst,
		    src_x, src_y, 0, 0, dst_x, dst_y, width, height);
#else
   if (out)
     {
	src = d->above;
	dst = d->root;

	EXCopyAreaGC(src, dst, d->gc1, src_x, src_y, width, height,
		     dst_x, dst_y);
     }
   else
     {
	src = d->root;
	dst = d->above;

	EXCopyArea(src, dst, src_x, src_y, width, height, dst_x, dst_y);
     }
#endif
}

/****************************** RIPPLES *************************************/

#define FX_RIPPLE_WATERH 64

static Animator    *fx_ripple = NULL;

static int
FX_ripple_timeout(EObj * eo __UNUSED__, int run __UNUSED__, void *state)
{
   FXData             *d = (FXData *) state;
   int                 y;

   _FxSetup(d, FX_RIPPLE_WATERH * 2);

   if (d->count == 0)
      _FxCopyArea(d, 0, 0, WinGetH(VROOT) - (FX_RIPPLE_WATERH * 3), 0, 0,
		  WinGetW(VROOT), FX_RIPPLE_WATERH * 2);

   d->count++;
   if (d->count > 32)
      d->count = 0;

   d->incv += 0.40f;
   if (d->incv > M_2PI_F)
      d->incv = 0;
   d->inch += 0.32f;
   if (d->inch > M_2PI_F)
      d->inch = 0;

   for (y = 0; y < FX_RIPPLE_WATERH; y++)
     {
	float               a, p;
	int                 xoff, yoff, yy;

	p = (float)(FX_RIPPLE_WATERH - y) / (float)FX_RIPPLE_WATERH;

	a = p * p * 48 + d->incv;
	yoff = y + (int)(sinf(a) * 7) + 8;	/* 0:63 + -7:7 + 8 = 1:78 */
	yy = (FX_RIPPLE_WATERH * 2) - yoff;	/* 128 - 1:78 = 127:50    */

	a = p * p * 64 + d->inch;
	xoff = (int)(sinf(a) * 10 * (1 - p));

	_FxCopyArea(d, 1, 0, yy, xoff, WinGetH(VROOT) - FX_RIPPLE_WATERH + y,
		    WinGetW(VROOT), 1);
     }

   return 4;
}

static void
FX_Ripple_Init(const char *name __UNUSED__)
{
   FXData              fxd;

   memset(&fxd, 0, sizeof(fxd));

   fx_ripple = AnimatorAdd(NULL, ANIM_FX_RIPPLES, FX_ripple_timeout, -1, 0,
			   sizeof(fxd), &fxd);
}

static void
FX_Ripple_Ops(int op)
{
   FXData             *d;

   d = (FXData *) AnimatorGetData(fx_ripple);
   if (!d)
      return;

   _FxCleanup(d, 0);

   if (op != FX_OP_DISABLE)
      return;

   _FxCleanup(d, FX_RIPPLE_WATERH);

   AnimatorDel(NULL, fx_ripple);
   fx_ripple = NULL;
}

/****************************** WAVES ***************************************/
/* by tsade :)                                                              */
/****************************************************************************/

#define FX_WAVE_WATERH 64
#define FX_WAVE_WATERW 64
#define FX_WAVE_DEPTH  10
#define FX_WAVE_CROSSPERIOD 0.42f

static Animator    *fx_waves = NULL;

static int
FX_Wave_timeout(EObj * eo __UNUSED__, int run __UNUSED__, void *state)
{
   FXData             *d = (FXData *) state;
   float               incx2;
   int                 y;

   _FxSetup(d, FX_WAVE_WATERH * 2);

   /* On the zero, grab the desktop again. */
   if (d->count == 0)
      _FxCopyArea(d, 0, 0, WinGetH(VROOT) - (FX_WAVE_WATERH * 3), 0, 0,
		  WinGetW(VROOT), FX_WAVE_WATERH * 2);

   /* Increment and roll the counter */
   d->count++;
   if (d->count > 32)
      d->count = 0;

   /* Increment and roll some other variables */
   d->incv += 0.40f;
   if (d->incv > M_2PI_F)
      d->incv = 0;

   d->inch += 0.32f;
   if (d->inch > M_2PI_F)
      d->inch = 0;

   d->incx += 0.32f;
   if (d->incx > M_2PI_F)
      d->incx = 0;

   /* Go through the bottom couple (FX_WAVE_WATERH) lines of the window */
   for (y = 0; y < FX_WAVE_WATERH; y++)
     {
	/* Variables */
	float               a, p;
	int                 xoff, yoff, yy;
	int                 x;

	/* Figure out the side-to-side movement */
	p = (float)(FX_WAVE_WATERH - y) / (float)FX_WAVE_WATERH;

	a = p * p * 48 + d->incv;
	yoff = y + (int)(sinf(a) * 7) + 8;	/* 0:63 + -7:7 + 8 = 1:78 */
	yy = (FX_WAVE_WATERH * 2) - yoff;	/* 128 - 1:78 = 127:50    */

	a = p * p * 64 + d->inch;
	xoff = (int)(sinf(a) * 10 * (1 - p));

	/* Set up the next part */
	incx2 = d->incx;

	/* Go through the width of the screen, in block sizes */
	for (x = 0; x < WinGetW(VROOT); x += FX_WAVE_WATERW)
	  {
	     /* Variables */
	     int                 sx;

	     /* Add something to incx2 and roll it */
	     incx2 += FX_WAVE_CROSSPERIOD;

	     if (incx2 > M_2PI_F)
		incx2 = 0;

	     /* Figure it out */
	     sx = (int)(sinf(incx2) * FX_WAVE_DEPTH);

	     /* Display this block */
	     _FxCopyArea(d, 1, x, yy, xoff + x,
			 WinGetH(VROOT) - FX_WAVE_WATERH + y + sx,
			 FX_WAVE_WATERW, 1);
	  }
     }

   return 4;
}

static void
FX_Waves_Init(const char *name __UNUSED__)
{
   FXData              fxd;

   memset(&fxd, 0, sizeof(fxd));

   fx_waves = AnimatorAdd(NULL, ANIM_FX_WAVES, FX_Wave_timeout, -1, 0,
			  sizeof(fxd), &fxd);
}

static void
FX_Waves_Ops(int op)
{
   FXData             *d;

   d = (FXData *) AnimatorGetData(fx_waves);
   if (!d)
      return;

   _FxCleanup(d, 0);

   if (op != FX_OP_DISABLE)
      return;

   _FxCleanup(d, 2 * FX_WAVE_WATERH + FX_WAVE_DEPTH);

   AnimatorDel(NULL, fx_waves);
   fx_waves = NULL;
}

/****************************************************************************/

#define fx_rip fx_handlers[0]
#define fx_wav fx_handlers[1]

static FXHandler    fx_handlers[] = {
   {"ripples", FX_Ripple_Init, FX_Ripple_Ops, 0, 0},
   {"waves", FX_Waves_Init, FX_Waves_Ops, 0, 0},
};

/****************************** Effect handlers *****************************/

static void
FX_Op(FXHandler * fxh, int op)
{
   switch (op)
     {
     case FX_OP_ENABLE:
	if (fxh->enabled)
	   break;
	fxh->enabled = 1;
	goto do_start;

     case FX_OP_DISABLE:
	if (!fxh->enabled)
	   break;
	fxh->enabled = 0;
	goto do_stop;

     case FX_OP_START:
	if (!fxh->enabled)
	   break;
      do_start:
	if (fxh->active)
	   break;
	fxh->init_func(fxh->name);
	fxh->active = 1;
	break;

     case FX_OP_PAUSE:
	if (!fxh->enabled)
	   break;
      do_stop:
	if (!fxh->active)
	   break;
	fxh->ops_func(FX_OP_DISABLE);
	fxh->active = 0;
	break;

     case FX_OP_DESK:
	if (!fxh->enabled)
	   break;
	fxh->ops_func(FX_OP_DESK);
	break;
     }
}

static void
FX_OpForEach(int op)
{
   unsigned int        i;

   for (i = 0; i < E_ARRAY_SIZE(fx_handlers); i++)
      FX_Op(&fx_handlers[i], op);
}

static void
FxCfgFunc(void *item __UNUSED__, const char *value)
{
   FXHandler          *fxh = NULL;

   if (item == &fx_rip.enabled)
      fxh = &fx_rip;
   else if (item == &fx_wav.enabled)
      fxh = &fx_wav;
   if (!fxh)
      return;

   FX_Op(fxh, atoi(value) ? FX_OP_ENABLE : FX_OP_DISABLE);
}

/****************************************************************************/

/*
 * Fx Module
 */

static void
FxSighan(int sig, void *prm __UNUSED__)
{
   switch (sig)
     {
     case ESIGNAL_START:
	FX_OpForEach(FX_OP_START);
	break;
     case ESIGNAL_DESK_SWITCH_START:
	break;
     case ESIGNAL_DESK_SWITCH_DONE:
	FX_OpForEach(FX_OP_DESK);
	break;
     case ESIGNAL_ANIMATION_SUSPEND:
	FX_OpForEach(FX_OP_PAUSE);
	break;
     case ESIGNAL_ANIMATION_RESUME:
	FX_OpForEach(FX_OP_START);
	break;
     }
}

#if ENABLE_DIALOGS
static char         tmp_effect_ripples;
static char         tmp_effect_waves;

static void
_DlgApplyFx(Dialog * d __UNUSED__, int val __UNUSED__, void *data __UNUSED__)
{
   FX_Op(&fx_rip, tmp_effect_ripples ? FX_OP_ENABLE : FX_OP_DISABLE);
   FX_Op(&fx_wav, tmp_effect_waves ? FX_OP_ENABLE : FX_OP_DISABLE);

   autosave();
}

static void
_DlgFillFx(Dialog * d __UNUSED__, DItem * table, void *data __UNUSED__)
{
   DItem              *di;

   tmp_effect_ripples = fx_rip.enabled;
   tmp_effect_waves = fx_wav.enabled;

   DialogItemTableSetOptions(table, 1, 0, 0, 0);

   /* Effects */
   di = DialogAddItem(table, DITEM_TEXT);
   DialogItemSetText(di, _("Effects"));
   di = DialogAddItem(table, DITEM_CHECKBUTTON);
   DialogItemSetText(di, _("Ripples"));
   DialogItemCheckButtonSetPtr(di, &tmp_effect_ripples);
   di = DialogAddItem(table, DITEM_CHECKBUTTON);
   DialogItemSetText(di, _("Waves"));
   DialogItemCheckButtonSetPtr(di, &tmp_effect_waves);
}

const DialogDef     DlgFx = {
   "CONFIGURE_FX",
   N_("FX"), N_("Special FX Settings"),
   0,
   SOUND_SETTINGS_FX,
   "pix/fx.png",
   N_("Enlightenment Special Effects\n" "Settings Dialog"),
   _DlgFillFx,
   DLG_OAC, _DlgApplyFx, NULL
};
#endif /* ENABLE_DIALOGS */

#define CFR_FUNC_BOOL(conf, name, dflt, func) \
    { #name, &conf, ITEM_TYPE_BOOL, dflt, func }

static const CfgItem FxCfgItems[] = {
   CFR_FUNC_BOOL(fx_handlers[0].enabled, ripples.enabled, 0, FxCfgFunc),
   CFR_FUNC_BOOL(fx_handlers[1].enabled, waves.enabled, 0, FxCfgFunc),
};

/*
 * Module descriptor
 */
extern const EModule ModEffects;

const EModule       ModEffects = {
   "effects", "fx",
   FxSighan,
   {0, NULL},
   MOD_ITEMS(FxCfgItems)
};