#include "../ckb/ckb-anim.h"
#include <math.h>
#include <stdlib.h>
#include <time.h>

Include dependency graph for main.c:

Macros
#define	DROP_MAX 1000

Functions
void	ckb_info ()

void	drop_add (float x, float y, int slow)

void	ckb_init (ckb_runctx *context)

void	ckb_parameter (ckb_runctx context, const char name, const char *value)

void	ckb_keypress (ckb_runctx context, ckb_key key, int x, int y, int state)

void	ckb_start (ckb_runctx *context, int state)

void	ckb_time (ckb_runctx *context, double delta)

int	ckb_frame (ckb_runctx *context)

Variables
int	spawn = 0

double	period = 0.1

double	maxsize = 100.

double	speed = 100.

unsigned char	ar = 255

unsigned char	ag = 255

unsigned char	ab = 255

float	aa = 1.

struct {
int	active

float	x

float	y

float	size

float	msize

}	drop [1000]

double	tick = -1.

Macro Definition Documentation

#define DROP_MAX 1000

Definition at line 34 of file main.c.

Referenced by ckb_frame(), ckb_time(), and drop_add().

Function Documentation

int ckb_frame ( ckb_runctx * context )

Definition at line 120 of file main.c.

References aa, ab, ag, ar, ckb_alpha_blend(), CKB_KEYCLEAR, drop, DROP_MAX, ckb_runctx::keycount, and ckb_runctx::keys.

                                   {
     CKB_KEYCLEAR(context);
     // Draw drops
     for(unsigned i = 0; i < DROP_MAX; i++){
         if(drop[i].active){
             unsigned count = context->keycount;
             ckb_key* keys = context->keys;
             for(ckb_key* key = keys; key < keys + count; key++){
                 // Calculate distance between key and drop, relative to the current drop size
                 float distance = drop[i].size - sqrt(pow(key->x - drop[i].x, 2.f) + pow(key->y - drop[i].y, 2.f));
                 // On the outside, cut the distance in half
                 if(distance < 0.)
                     distance = -distance / 2.;
                 // Scale according to drop size (fade-out radius expands as the drop becomes larger)
                 float scale = drop[i].size / 4.f;
                 if(scale < 10.)
                     scale = 10.;
                 distance /= scale;
                 if(distance <= 1.){
                     // Scale alpha according to size divided by maximum size (drops fade out as they expand)
                     float ascale = (1.f - drop[i].size / drop[i].msize);
                     if(ascale > 1.f)
                         ascale = 1.f;
                     // Apply color
                     ckb_alpha_blend(key, (1.f - distance) * ascale * aa * 255., ar, ag, ab);
                 }
             }
         }
     }
     return 0;
 }

Here is the call graph for this function:

void ckb_info ( )

Definition at line 6 of file main.c.

References CKB_COPYRIGHT, CKB_DESCRIPTION, CKB_GUID, CKB_KP_POSITION, CKB_KPMODE, CKB_LICENSE, CKB_LIVEPARAMS, CKB_NAME, CKB_PARAM_DOUBLE, CKB_PARAM_LONG, CKB_PARAM_RGB, CKB_PRESET_END, CKB_PRESET_PARAM, CKB_PRESET_START, CKB_REPEAT, CKB_TIME_ABSOLUTE, CKB_TIMEMODE, CKB_VERSION, FALSE, and TRUE.

                {
     // Plugin info
     CKB_NAME("Raindrop");
     CKB_VERSION("0.10");
     CKB_COPYRIGHT("2014-2016", "MSC");
     CKB_LICENSE("GPLv2");
     CKB_GUID("{5D6695AF-0496-41E2-BEE7-F7D0ABAA49E9}");
     CKB_DESCRIPTION("A rain-like effect.");
 
     // Effect parameters
     CKB_PARAM_RGB("color", "Drop color:", "", 255, 255, 255);
     CKB_PARAM_DOUBLE("intensity", "Intensity:", "%", 100, 0, 100);
     CKB_PARAM_DOUBLE("size", "Size:", "%", 25, 1, 100);
     CKB_PARAM_LONG("frequency", "Frequency:", "per second", 10, 1, 100);
 
     // Timing/input parameters
     CKB_KPMODE(CKB_KP_POSITION);
     CKB_TIMEMODE(CKB_TIME_ABSOLUTE);
     CKB_REPEAT(FALSE);
     CKB_LIVEPARAMS(TRUE);
 
     // Presets
     CKB_PRESET_START("Default");
     CKB_PRESET_PARAM("trigger", "1");
     CKB_PRESET_PARAM("kptrigger", "1");
     CKB_PRESET_END;
 }

void ckb_init ( ckb_runctx * context )

Definition at line 63 of file main.c.

                                   {
     srand(time(NULL));
 }

void ckb_keypress	(	ckb_runctx *	context,
		ckb_key *	key,
		int	x,
		int	y,
		int	state
	)

Definition at line 86 of file main.c.

References drop_add().

                                                                              {
     // Add a drop on keypress
     if(state)
         drop_add(x, y, 0);
 }

Here is the call graph for this function:

void ckb_parameter	(	ckb_runctx *	context,
		const char *	name,
		const char *	value
	)

Definition at line 67 of file main.c.

References aa, ab, ag, ar, CKB_PARSE_BOOL, CKB_PARSE_DOUBLE, CKB_PARSE_LONG, CKB_PARSE_RGB, ckb_runctx::height, maxsize, period, spawn, speed, and ckb_runctx::width.

                                                                             {
     CKB_PARSE_RGB("color", &ar, &ag, &ab){}
     double intensity, size;
     long frequency;
     CKB_PARSE_DOUBLE("intensity", &intensity){
         aa = intensity / 100.;
     }
     CKB_PARSE_DOUBLE("size", &size){
         double sizex = context->width / 2.;
         double sizey = context->height / 2.;
         maxsize = size / 100. * sqrt(sizex * sizex + sizey * sizey);
         speed = maxsize;
     }
     CKB_PARSE_LONG("frequency", &frequency){
         period = 1. / frequency;
     }
     CKB_PARSE_BOOL("trigger", &spawn){}
 }

void ckb_start	(	ckb_runctx *	context,
		int	state
	)

Definition at line 94 of file main.c.

References tick.

                                               {
     // Start or stop random spawning
     tick = state ? 0. : -1.;
 }

void ckb_time	(	ckb_runctx *	context,
		double	delta
	)

Definition at line 99 of file main.c.

References drop, drop_add(), DROP_MAX, ckb_runctx::height, period, spawn, speed, tick, and ckb_runctx::width.

                                                 {
     if(delta <= 0.)
         return;
     // Process existing drops
     for(unsigned i = 0; i < DROP_MAX; i++){
         if(drop[i].active){
             drop[i].size += delta * speed;
             if(drop[i].size > drop[i].msize)
                 drop[i].active = 0;
         }
     }
     if(tick >= 0.){
         // Spawn a new randomly-placed drop, if the spawn time has passed
         tick += delta;
         if(tick > period && spawn){
             drop_add(rand() / (double)RAND_MAX * context->width, rand() / (double)RAND_MAX * context->height, 1);
             tick -= period;
         }
     }
 }

Here is the call graph for this function:

void drop_add	(	float	x,
		float	y,
		int	slow
	)

Definition at line 49 of file main.c.

References drop, DROP_MAX, maxsize, x, and y.

Referenced by ckb_keypress(), and ckb_time().

                                          {
     for(int i = 0; i < DROP_MAX; i++){
         if(drop[i].active)
             continue;
         drop[i].active = 1;
         drop[i].x = x;
         drop[i].y = y;
         float msize = maxsize * (0.9 + (rand() / (double)RAND_MAX * 0.2));
         drop[i].size = -msize / 2. * slow;
         drop[i].msize = msize;
         return;
     }
 }