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

Include dependency graph for main.c:

Data Structures
struct	rgb

Functions
void	ckb_info ()

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	newtarget (rgb *data, unsigned count)

void	ckb_init (ckb_runctx *context)

void	ckb_start (ckb_runctx *context, int state)

void	ckb_time (ckb_runctx *context, double delta)

int	ckb_frame (ckb_runctx *context)

Variables
int	fadein = 0

int	useopacity = 0

rgb *	current = 0

rgb *	target = 0

double	phase = -1.

Data Structure Documentation

struct rgb

Definition at line 42 of file main.c.

Collaboration diagram for rgb:

Data Fields
unsigned char	a
unsigned char	b
unsigned char	g
unsigned char	r

Function Documentation

int ckb_frame ( ckb_runctx * context )

Definition at line 109 of file main.c.

References ckb_key::a, ckb_key::b, CKB_KEYCLEAR, ckb_key::g, ckb_runctx::keycount, ckb_runctx::keys, phase, and ckb_key::r.

                                   {
     if(phase < 0.){
         CKB_KEYCLEAR(context);
         return 0;
     }
     ckb_key* keys = context->keys;
     unsigned count = context->keycount;
     for(unsigned i = 0; i < count; i++){
         // Color each key according to the position between the last color set and the new color set
         ckb_key* key = keys + i;
         key->a = round(current[i].a * (1. - phase) + target[i].a * phase);
         key->r = round(current[i].r * (1. - phase) + target[i].r * phase);
         key->g = round(current[i].g * (1. - phase) + target[i].g * phase);
         key->b = round(current[i].b * (1. - phase) + target[i].b * phase);
     }
     return 0;
 }

void ckb_info ( )

Definition at line 6 of file main.c.

References CKB_COPYRIGHT, CKB_DESCRIPTION, CKB_GUID, CKB_KP_NONE, CKB_KPMODE, CKB_LICENSE, CKB_LIVEPARAMS, CKB_NAME, CKB_PARAM_BOOL, CKB_PRESET_END, CKB_PRESET_PARAM, CKB_PRESET_START, CKB_REPEAT, CKB_TIME_DURATION, CKB_TIMEMODE, CKB_VERSION, FALSE, and TRUE.

                {
     // Plugin info
     CKB_NAME("Random");
     CKB_VERSION("0.9");
     CKB_COPYRIGHT("2014-2016", "MSC");
     CKB_LICENSE("GPLv2");
     CKB_GUID("{22418DA4-A181-4B93-A4D3-03682BA283D2}");
     CKB_DESCRIPTION("An effect that changes key colors randomly.");
 
     // Effect parameters
     CKB_PARAM_BOOL("fade", "Fade in", 0);
     CKB_PARAM_BOOL("useopacity", "Randomize opacity", 0);
 
     // Timing/input parameters
     CKB_KPMODE(CKB_KP_NONE);
     CKB_TIMEMODE(CKB_TIME_DURATION);
     CKB_LIVEPARAMS(TRUE);
     CKB_REPEAT(FALSE);
 
     // Presets
     CKB_PRESET_START("Default");
     CKB_PRESET_PARAM("duration", "1.");
     CKB_PRESET_END;
 }

void ckb_init ( ckb_runctx * context )

Definition at line 61 of file main.c.

References ckb_runctx::keycount.

                                   {
     unsigned count = context->keycount;
     current = malloc(count * sizeof(rgb));
     target = malloc(count * sizeof(rgb));
     srand(time(NULL));
 }

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

Definition at line 38 of file main.c.

                                                                              {
     // Unused
 }

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

Definition at line 33 of file main.c.

References CKB_PARSE_BOOL, fadein, and useopacity.

                                                                             {
     CKB_PARSE_BOOL("fade", &fadein) {}
     CKB_PARSE_BOOL("useopacity", &useopacity) {}
 }

void ckb_start	(	ckb_runctx *	context,
		int	state
	)

Definition at line 68 of file main.c.

References rgb::a, ckb_key::a, rgb::b, ckb_key::b, fadein, rgb::g, ckb_key::g, ckb_runctx::keycount, ckb_runctx::keys, newtarget(), phase, rgb::r, and ckb_key::r.

                                               {
     if(state == 0){
         // Stop animation
         phase = -1.;
         return;
     }
     // Start animation
     phase = 0.;
     ckb_key* keys = context->keys;
     unsigned count = context->keycount;
     // Randomize starting colors and pick a random target
     newtarget(current, count);
     // Over the course of the animation, the keys fade between the current pattern and the target pattern
     newtarget(target, count);
     // Set all keys to current
     for(unsigned i = 0; i < count; i++){
         ckb_key* key = keys + i;
         if(fadein)
             current[i].a = 0;
         key->a = current[i].a;
         key->r = current[i].r;
         key->g = current[i].g;
         key->b = current[i].b;
     }
 }

Here is the call graph for this function:

void ckb_time	(	ckb_runctx *	context,
		double	delta
	)

Definition at line 94 of file main.c.

References current, ckb_runctx::keycount, newtarget(), phase, and target.

                                                 {
     if(phase < 0.)
         return;
     // Advance animation
     phase += delta;
     if(phase > 1.){
         // If the animation is complete, pick a new target pattern and start again
         phase -= 1.;
         rgb* temp = target;
         target = current;
         current = temp;
         newtarget(target, context->keycount);
     }
 }

Here is the call graph for this function:

void newtarget	(	rgb *	data,
		unsigned	count
	)

Definition at line 51 of file main.c.

References rgb::a, rgb::b, rgb::g, rgb::r, and useopacity.

Referenced by ckb_start(), and ckb_time().

                                          {
     for(unsigned i = 0; i < count; i++){
         rgb* key = data + i;
         key->a = useopacity ? rand() % 256 : 255;
         key->r = rand() % 256;
         key->g = rand() % 256;
         key->b = rand() % 256;
     }
 }