blackbeard420/notcurses
1
0
Fork 0
mirror of https://github.com/dankamongmen/notcurses synced 2025-03-09 09:09:03 -04:00
Code Issues Projects Releases Wiki Activity

channel_* functions -> ncchannel_* #1570

Browse Source
This commit is contained in:
nick black 2021-04-27 14:10:41 -04:00
parent 25afcbe49d
commit e43a9955cd
No known key found for this signature in database
GPG Key ID: 5F43400C21CBFACC
17 changed files with 298 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
NEWS.md
View File

@ -8,6 +8,9 @@ rearrangements of Notcurses.
prefixed with `palette256_` have been deprecated in favor of versions
prefixed with `ncpalette_`, which the former now wrap. The old versions
will be removed in ABI3.
* All functions prefixed with `channel_` have been deprecated in favor of
versions prefixed with `ncchannel_`, which the former now wrap. The old
versions will be removed in ABI3.
* 2.2.8 (2021-04-18)
* All remaining functions prefixed with `cell_` or `cells_` have been

24
doc/man/man3/notcurses_channels.3.md
View File

@ -19,29 +19,29 @@ notcurses_channels - operations on notcurses channels
(((uint32_t)r << 16u) + ((uint32_t)g << 8u) + (b) + CELL_BGDEFAULT_MASK)
```
**uint32_t channel_r(uint32_t ***channel***);**
**uint32_t ncchannel_r(uint32_t ***channel***);**
**uint32_t channel_g(uint32_t ***channel***);**
**uint32_t ncchannel_g(uint32_t ***channel***);**
**uint32_t channel_b(uint32_t ***channel***);**
**uint32_t ncchannel_b(uint32_t ***channel***);**
**uint32_t channel_rgb8(uint32_t ***channel***, uint32_t* restrict ***r***, uint32_t* restrict ***g***, uint32_t* restrict ***b***);**
**uint32_t ncchannel_rgb8(uint32_t ***channel***, uint32_t* restrict ***r***, uint32_t* restrict ***g***, uint32_t* restrict ***b***);**
**int channel_set_rgb8(uint32_t* ***channel***, int ***r***, int ***g***, int ***b***);**
**int ncchannel_set_rgb8(uint32_t* ***channel***, int ***r***, int ***g***, int ***b***);**
**int channel_set(uint32_t* ***channel***, uint32_t ***rgb***);**
**int ncchannel_set(uint32_t* ***channel***, uint32_t ***rgb***);**
**unsigned channel_palindex(uint32_t ***channel***);**
**unsigned ncchannel_palindex(uint32_t ***channel***);**
**int channel_set_palindex(uint32_t* ***channel***, int ***idx***);**
**int ncchannel_set_palindex(uint32_t* ***channel***, int ***idx***);**
**uint32_t channel_alpha(uint32_t ***channel***);**
**uint32_t ncchannel_alpha(uint32_t ***channel***);**
**int channel_set_alpha(uint32_t* ***channel***, unsigned ***alpha***);**
**int ncchannel_set_alpha(uint32_t* ***channel***, unsigned ***alpha***);**
**bool channel_default_p(uint32_t ***channel***);**
**bool ncchannel_default_p(uint32_t ***channel***);**
**uint32_t channel_set_default(uint32_t* ***channel***);**
**uint32_t ncchannel_set_default(uint32_t* ***channel***);**
**unsigned channels_fg_rgb(uint64_t ***channels***);**

191
include/notcurses/notcurses.h
View File

@ -145,41 +145,47 @@ API int notcurses_ucs32_to_utf8(const char32_t* ucs32, unsigned ucs32count,
(((uint32_t)r << 16u) + ((uint32_t)g << 8u) + (b) + CELL_BGDEFAULT_MASK)
// These lowest-level functions manipulate a 64-bit channel encoding directly.
// Users will typically manipulate ncplane and cell channels through those APIs,
// rather than calling these directly.
// Users will typically manipulate ncplane and nccell channels through those
// APIs, rather than calling these explicitly.
// Extract the 8-bit red component from a 32-bit channel.
static inline unsigned
channel_r(uint32_t channel){
ncchannel_r(uint32_t channel){
return (channel & 0xff0000u) >> 16u;
}
// Extract the 8-bit green component from a 32-bit channel.
static inline unsigned
channel_g(uint32_t channel){
ncchannel_g(uint32_t channel){
return (channel & 0x00ff00u) >> 8u;
}
// Extract the 8-bit blue component from a 32-bit channel.
static inline unsigned
channel_b(uint32_t channel){
ncchannel_b(uint32_t channel){
return (channel & 0x0000ffu);
}
// Extract the 2-bit alpha component from a 32-bit channel.
static inline unsigned
ncchannel_alpha(unsigned channel){
return channel & CELL_BG_ALPHA_MASK;
}
// Extract the three 8-bit R/G/B components from a 32-bit channel.
static inline unsigned
channel_rgb8(uint32_t channel, unsigned* RESTRICT r, unsigned* RESTRICT g,
unsigned* RESTRICT b){
*r = channel_r(channel);
*g = channel_g(channel);
*b = channel_b(channel);
ncchannel_rgb8(uint32_t channel, unsigned* RESTRICT r, unsigned* RESTRICT g,
unsigned* RESTRICT b){
*r = ncchannel_r(channel);
*g = ncchannel_g(channel);
*b = ncchannel_b(channel);
return channel;
}
// Set the three 8-bit components of a 32-bit channel, and mark it as not using
// the default color. Retain the other bits unchanged.
static inline int
channel_set_rgb8(uint32_t* channel, int r, int g, int b){
ncchannel_set_rgb8(uint32_t* channel, int r, int g, int b){
if(r >= 256 || g >= 256 || b >= 256){
return -1;
}
@ -195,7 +201,7 @@ channel_set_rgb8(uint32_t* channel, int r, int g, int b){
// the default color. Retain the other bits unchanged. r, g, and b will be
// clipped to the range [0..255].
static inline void
channel_set_rgb8_clipped(unsigned* channel, int r, int g, int b){
ncchannel_set_rgb8_clipped(unsigned* channel, int r, int g, int b){
if(r >= 256){
r = 255;
}
@ -220,7 +226,7 @@ channel_set_rgb8_clipped(unsigned* channel, int r, int g, int b){
// Same, but provide an assembled, packed 24 bits of rgb.
static inline int
channel_set(unsigned* channel, unsigned rgb){
ncchannel_set(unsigned* channel, unsigned rgb){
if(rgb > 0xffffffu){
return -1;
}
@ -228,20 +234,14 @@ channel_set(unsigned* channel, unsigned rgb){
return 0;
}
// Extract the 2-bit alpha component from a 32-bit channel.
static inline unsigned
channel_alpha(unsigned channel){
return channel & CELL_BG_ALPHA_MASK;
}
static inline unsigned
channel_palindex(uint32_t channel){
ncchannel_palindex(uint32_t channel){
return channel & 0xff;
}
// Set the 2-bit alpha component of the 32-bit channel.
static inline int
channel_set_alpha(unsigned* channel, unsigned alpha){
ncchannel_set_alpha(unsigned* channel, unsigned alpha){
if(alpha & ~CELL_BG_ALPHA_MASK){
return -1;
}
@ -253,33 +253,33 @@ channel_set_alpha(unsigned* channel, unsigned alpha){
}
static inline int
channel_set_palindex(uint32_t* channel, int idx){
ncchannel_set_palindex(uint32_t* channel, int idx){
if(idx < 0 || idx >= NCPALETTESIZE){
return -1;
}
*channel |= CELL_BGDEFAULT_MASK;
*channel |= CELL_BG_PALETTE;
channel_set_alpha(channel, CELL_ALPHA_OPAQUE);
ncchannel_set_alpha(channel, CELL_ALPHA_OPAQUE);
*channel &= 0xff000000ull;
*channel |= idx;
return 0;
}
// Is this channel using the "default color" rather than RGB/palette-indexed?
// Is this ncchannel using the "default color" rather than RGB/palette-indexed?
static inline bool
channel_default_p(unsigned channel){
ncchannel_default_p(unsigned channel){
return !(channel & CELL_BGDEFAULT_MASK);
}
// Is this channel using palette-indexed color rather than RGB?
static inline bool
channel_palindex_p(unsigned channel){
return !channel_default_p(channel) && (channel & CELL_BG_PALETTE);
ncchannel_palindex_p(unsigned channel){
return !ncchannel_default_p(channel) && (channel & CELL_BG_PALETTE);
}
// Mark the channel as using its default color, which also marks it opaque.
static inline unsigned
channel_set_default(unsigned* channel){
ncchannel_set_default(unsigned* channel){
return *channel &= ~(CELL_BGDEFAULT_MASK | CELL_ALPHA_HIGHCONTRAST);
}
@ -317,12 +317,12 @@ channels_combine(uint32_t fchan, uint32_t bchan){
static inline unsigned
channels_fg_palindex(uint64_t channels){
return channel_palindex(channels_fchannel(channels));
return ncchannel_palindex(channels_fchannel(channels));
}
static inline unsigned
channels_bg_palindex(uint64_t channels){
return channel_palindex(channels_bchannel(channels));
return ncchannel_palindex(channels_bchannel(channels));
}
// Extract 24 bits of foreground RGB from 'channels', shifted to LSBs.
@ -340,25 +340,25 @@ channels_bg_rgb(uint64_t channels){
// Extract 2 bits of foreground alpha from 'channels', shifted to LSBs.
static inline unsigned
channels_fg_alpha(uint64_t channels){
return channel_alpha(channels_fchannel(channels));
return ncchannel_alpha(channels_fchannel(channels));
}
// Extract 2 bits of background alpha from 'channels', shifted to LSBs.
static inline unsigned
channels_bg_alpha(uint64_t channels){
return channel_alpha(channels_bchannel(channels));
return ncchannel_alpha(channels_bchannel(channels));
}
// Extract 24 bits of foreground RGB from 'channels', split into subchannels.
static inline unsigned
channels_fg_rgb8(uint64_t channels, unsigned* r, unsigned* g, unsigned* b){
return channel_rgb8(channels_fchannel(channels), r, g, b);
return ncchannel_rgb8(channels_fchannel(channels), r, g, b);
}
// Extract 24 bits of background RGB from 'channels', split into subchannels.
static inline unsigned
channels_bg_rgb8(uint64_t channels, unsigned* r, unsigned* g, unsigned* b){
return channel_rgb8(channels_bchannel(channels), r, g, b);
return ncchannel_rgb8(channels_bchannel(channels), r, g, b);
}
// Set the r, g, and b channels for the foreground component of this 64-bit
@ -366,7 +366,7 @@ channels_bg_rgb8(uint64_t channels, unsigned* r, unsigned* g, unsigned* b){
static inline int
channels_set_fg_rgb8(uint64_t* channels, int r, int g, int b){
uint32_t channel = channels_fchannel(*channels);
if(channel_set_rgb8(&channel, r, g, b) < 0){
if(ncchannel_set_rgb8(&channel, r, g, b) < 0){
return -1;
}
*channels = ((uint64_t)channel << 32llu) | (*channels & 0xffffffffllu);
@ -377,7 +377,7 @@ channels_set_fg_rgb8(uint64_t* channels, int r, int g, int b){
static inline void
channels_set_fg_rgb8_clipped(uint64_t* channels, int r, int g, int b){
uint32_t channel = channels_fchannel(*channels);
channel_set_rgb8_clipped(&channel, r, g, b);
ncchannel_set_rgb8_clipped(&channel, r, g, b);
*channels = ((uint64_t)channel << 32llu) | (*channels & 0xffffffffllu);
}
@ -385,7 +385,7 @@ channels_set_fg_rgb8_clipped(uint64_t* channels, int r, int g, int b){
static inline int
channels_set_fg_alpha(uint64_t* channels, unsigned alpha){
uint32_t channel = channels_fchannel(*channels);
if(channel_set_alpha(&channel, alpha) < 0){
if(ncchannel_set_alpha(&channel, alpha) < 0){
return -1;
}
*channels = ((uint64_t)channel << 32llu) | (*channels & 0xffffffffllu);
@ -395,7 +395,7 @@ channels_set_fg_alpha(uint64_t* channels, unsigned alpha){
static inline int
channels_set_fg_palindex(uint64_t* channels, int idx){
uint32_t channel = channels_fchannel(*channels);
if(channel_set_palindex(&channel, idx) < 0){
if(ncchannel_set_palindex(&channel, idx) < 0){
return -1;
}
*channels = ((uint64_t)channel << 32llu) | (*channels & 0xffffffffllu);
@ -406,7 +406,7 @@ channels_set_fg_palindex(uint64_t* channels, int idx){
static inline int
channels_set_fg_rgb(uint64_t* channels, unsigned rgb){
uint32_t channel = channels_fchannel(*channels);
if(channel_set(&channel, rgb) < 0){
if(ncchannel_set(&channel, rgb) < 0){
return -1;
}
*channels = ((uint64_t)channel << 32llu) | (*channels & 0xffffffffllu);
@ -418,7 +418,7 @@ channels_set_fg_rgb(uint64_t* channels, unsigned rgb){
static inline int
channels_set_bg_rgb8(uint64_t* channels, int r, int g, int b){
uint32_t channel = channels_bchannel(*channels);
if(channel_set_rgb8(&channel, r, g, b) < 0){
if(ncchannel_set_rgb8(&channel, r, g, b) < 0){
return -1;
}
channels_set_bchannel(channels, channel);
@ -429,7 +429,7 @@ channels_set_bg_rgb8(uint64_t* channels, int r, int g, int b){
static inline void
channels_set_bg_rgb8_clipped(uint64_t* channels, int r, int g, int b){
uint32_t channel = channels_bchannel(*channels);
channel_set_rgb8_clipped(&channel, r, g, b);
ncchannel_set_rgb8_clipped(&channel, r, g, b);
channels_set_bchannel(channels, channel);
}
@ -440,7 +440,7 @@ channels_set_bg_alpha(uint64_t* channels, unsigned alpha){
return -1;
}
uint32_t channel = channels_bchannel(*channels);
if(channel_set_alpha(&channel, alpha) < 0){
if(ncchannel_set_alpha(&channel, alpha) < 0){
return -1;
}
channels_set_bchannel(channels, channel);
@ -452,7 +452,7 @@ channels_set_bg_alpha(uint64_t* channels, unsigned alpha){
static inline int
channels_set_bg_palindex(uint64_t* channels, int idx){
uint32_t channel = channels_bchannel(*channels);
if(channel_set_palindex(&channel, idx) < 0){
if(ncchannel_set_palindex(&channel, idx) < 0){
return -1;
}
channels_set_bchannel(channels, channel);
@ -463,7 +463,7 @@ channels_set_bg_palindex(uint64_t* channels, int idx){
static inline int
channels_set_bg_rgb(uint64_t* channels, unsigned rgb){
uint32_t channel = channels_bchannel(*channels);
if(channel_set(&channel, rgb) < 0){
if(ncchannel_set(&channel, rgb) < 0){
return -1;
}
channels_set_bchannel(channels, channel);
@ -473,13 +473,13 @@ channels_set_bg_rgb(uint64_t* channels, unsigned rgb){
// Is the foreground using the "default foreground color"?
static inline bool
channels_fg_default_p(uint64_t channels){
return channel_default_p(channels_fchannel(channels));
return ncchannel_default_p(channels_fchannel(channels));
}
// Is the foreground using indexed palette color?
static inline bool
channels_fg_palindex_p(uint64_t channels){
return channel_palindex_p(channels_fchannel(channels));
return ncchannel_palindex_p(channels_fchannel(channels));
}
// Is the background using the "default background color"? The "default
@ -487,20 +487,20 @@ channels_fg_palindex_p(uint64_t channels){
// terminal-effected transparency.
static inline bool
channels_bg_default_p(uint64_t channels){
return channel_default_p(channels_bchannel(channels));
return ncchannel_default_p(channels_bchannel(channels));
}
// Is the background using indexed palette color?
static inline bool
channels_bg_palindex_p(uint64_t channels){
return channel_palindex_p(channels_bchannel(channels));
return ncchannel_palindex_p(channels_bchannel(channels));
}
// Mark the foreground channel as using its default color.
static inline uint64_t
channels_set_fg_default(uint64_t* channels){
uint32_t channel = channels_fchannel(*channels);
channel_set_default(&channel);
ncchannel_set_default(&channel);
*channels = ((uint64_t)channel << 32llu) | (*channels & 0xffffffffllu);
return *channels;
}
@ -509,7 +509,7 @@ channels_set_fg_default(uint64_t* channels){
static inline uint64_t
channels_set_bg_default(uint64_t* channels){
uint32_t channel = channels_bchannel(*channels);
channel_set_default(&channel);
ncchannel_set_default(&channel);
channels_set_bchannel(channels, channel);
return *channels;
}
@ -2881,7 +2881,7 @@ ncpalette_set_rgb8(ncpalette* p, int idx, int r, int g, int b){
if(idx < 0 || (size_t)idx > sizeof(p->chans) / sizeof(*p->chans)){
return -1;
}
return channel_set_rgb8(&p->chans[idx], r, g, b);
return ncchannel_set_rgb8(&p->chans[idx], r, g, b);
}
static inline int
@ -2889,7 +2889,7 @@ ncpalette_set(ncpalette* p, int idx, unsigned rgb){
if(idx < 0 || (size_t)idx > sizeof(p->chans) / sizeof(*p->chans)){
return -1;
}
return channel_set(&p->chans[idx], rgb);
return ncchannel_set(&p->chans[idx], rgb);
}
static inline int
@ -2897,7 +2897,7 @@ ncpalette_get_rgb8(const ncpalette* p, int idx, unsigned* RESTRICT r, unsigned*
if(idx < 0 || (size_t)idx > sizeof(p->chans) / sizeof(*p->chans)){
return -1;
}
return channel_rgb8(p->chans[idx], r, g, b);
return ncchannel_rgb8(p->chans[idx], r, g, b);
}
// Free the palette store 'p'.
@ -3971,6 +3971,91 @@ palette256_get_rgb8(const ncpalette* p, int idx, unsigned* RESTRICT r, unsigned*
API void palette256_free(ncpalette* p) __attribute__ ((deprecated));
__attribute__ ((deprecated)) static inline unsigned
channel_r(uint32_t channel){
return ncchannel_r(channel);
}
// Extract the 8-bit green component from a 32-bit channel.
__attribute__ ((deprecated)) static inline unsigned
channel_g(uint32_t channel){
return ncchannel_g(channel);
}
// Extract the 8-bit blue component from a 32-bit channel.
__attribute__ ((deprecated)) static inline unsigned
channel_b(uint32_t channel){
return ncchannel_b(channel);
}
// Extract the three 8-bit R/G/B components from a 32-bit channel.
__attribute__ ((deprecated)) static inline unsigned
channel_rgb8(uint32_t channel, unsigned* RESTRICT r, unsigned* RESTRICT g,
unsigned* RESTRICT b){
return ncchannel_rgb8(channel, r, g, b);
}
// Set the three 8-bit components of a 32-bit channel, and mark it as not using
// the default color. Retain the other bits unchanged.
__attribute__ ((deprecated)) static inline int
channel_set_rgb8(uint32_t* channel, int r, int g, int b){
return ncchannel_set_rgb8(channel, r, g, b);
}
// Set the three 8-bit components of a 32-bit channel, and mark it as not using
// the default color. Retain the other bits unchanged. r, g, and b will be
// clipped to the range [0..255].
__attribute__ ((deprecated)) static inline void
channel_set_rgb8_clipped(unsigned* channel, int r, int g, int b){
return ncchannel_set_rgb8_clipped(channel, r, g, b);
}
// Same, but provide an assembled, packed 24 bits of rgb.
__attribute__ ((deprecated)) static inline int
channel_set(unsigned* channel, unsigned rgb){
return ncchannel_set(channel, rgb);
}
// Extract the 2-bit alpha component from a 32-bit channel.
__attribute__ ((deprecated)) static inline unsigned
channel_alpha(unsigned channel){
return ncchannel_alpha(channel);
}
__attribute__ ((deprecated)) static inline unsigned
channel_palindex(uint32_t channel){
return ncchannel_palindex(channel);
}
// Set the 2-bit alpha component of the 32-bit channel.
__attribute__ ((deprecated)) static inline int
channel_set_alpha(unsigned* channel, unsigned alpha){
return ncchannel_set_alpha(channel, alpha);
}
__attribute__ ((deprecated)) static inline int
channel_set_palindex(uint32_t* channel, int idx){
return ncchannel_set_palindex(channel, idx);
}
// Is this channel using the "default color" rather than RGB/palette-indexed?
__attribute__ ((deprecated)) static inline bool
channel_default_p(unsigned channel){
return ncchannel_default_p(channel);
}
// Is this channel using palette-indexed color rather than RGB?
__attribute__ ((deprecated)) static inline bool
channel_palindex_p(unsigned channel){
return ncchannel_palindex_p(channel);
}
// Mark the channel as using its default color, which also marks it opaque.
__attribute__ ((deprecated)) static inline unsigned
channel_set_default(unsigned* channel){
return ncchannel_set_default(channel);
}
typedef ncpalette palette256;
typedef nccell cell; // FIXME backwards-compat, remove in ABI3

16
src/demo/animate.c
View File

@ -268,10 +268,10 @@ make_pbars(struct ncplane* column, struct ncprogbar** left, struct ncprogbar** r
}
ncplane_set_base(leftp, " ", 0, CHANNELS_RGB_INITIALIZER(0xdd, 0xdd, 0xdd, 0x1b, 0x1b, 0x1b));
ncprogbar_options popts = { };
channel_set_rgb8(&popts.brchannel, 0, 0, 0);
channel_set_rgb8(&popts.blchannel, 0, 0xff, 0);
channel_set_rgb8(&popts.urchannel, 0, 0, 0xff);
channel_set_rgb8(&popts.ulchannel, 0, 0xff, 0xff);
ncchannel_set_rgb8(&popts.brchannel, 0, 0, 0);
ncchannel_set_rgb8(&popts.blchannel, 0, 0xff, 0);
ncchannel_set_rgb8(&popts.urchannel, 0, 0, 0xff);
ncchannel_set_rgb8(&popts.ulchannel, 0, 0xff, 0xff);
*left = ncprogbar_create(leftp, &popts);
if(*left == NULL){
return -1;
@ -300,10 +300,10 @@ int animate_demo(struct notcurses* nc){
ncplane_erase(n);
ncplane_home(n);
uint32_t tl = 0, tr = 0, bl = 0, br = 0;
channel_set_rgb8(&tl, 0, 0, 0);
channel_set_rgb8(&tr, 0, 0xff, 0);
channel_set_rgb8(&bl, 0, 0, 0xff);
channel_set_rgb8(&br, 0, 0xff, 0xff);
ncchannel_set_rgb8(&tl, 0, 0, 0);
ncchannel_set_rgb8(&tr, 0, 0xff, 0);
ncchannel_set_rgb8(&bl, 0, 0, 0xff);
ncchannel_set_rgb8(&br, 0, 0xff, 0xff);
if(ncplane_highgradient(n, tl, tr, bl, br, dimy - 1, dimx - 1) < 0){
return -1;
}

8
src/demo/intro.c
View File

@ -114,10 +114,10 @@ int intro(struct notcurses* nc){
struct ncplane* ncp = notcurses_stddim_yx(nc, &rows, &cols);
uint32_t ccul, ccur, ccll, cclr;
ccul = ccur = ccll = cclr = 0;
channel_set_rgb8(&ccul, 0, 0xff, 0xff);
channel_set_rgb8(&ccur, 0xff, 0xff, 0);
channel_set_rgb8(&ccll, 0xff, 0, 0);
channel_set_rgb8(&cclr, 0, 0, 0xff);
ncchannel_set_rgb8(&ccul, 0, 0xff, 0xff);
ncchannel_set_rgb8(&ccur, 0xff, 0xff, 0);
ncchannel_set_rgb8(&ccll, 0xff, 0, 0);
ncchannel_set_rgb8(&cclr, 0, 0, 0xff);
// we use full block rather+fg than space+bg to conflict less with the menu
ncplane_home(ncp);
if(ncplane_highgradient_sized(ncp, ccul, ccur, ccll, cclr, rows, cols) <= 0){

8
src/demo/sliding.c
View File

@ -102,10 +102,10 @@ fill_chunk(struct ncplane* n, int idx){
int g = 225 - ((hidx + vidx) * 12);
channels_set_fg_rgb8(&channels, r, g, b);
uint32_t ul = 0, ur = 0, ll = 0, lr = 0;
channel_set_rgb8(&ul, r, g, b);
channel_set_rgb8(&lr, r, g, b);
channel_set_rgb8(&ur, g, b, r);
channel_set_rgb8(&ll, b, r, g);
ncchannel_set_rgb8(&ul, r, g, b);
ncchannel_set_rgb8(&lr, r, g, b);
ncchannel_set_rgb8(&ur, g, b, r);
ncchannel_set_rgb8(&ll, b, r, g);
int ret = 0;
if(ncplane_highgradient_sized(n, ul, ur, ll, lr, maxy, maxx) <= 0){
ret = -1;

6
src/demo/trans.c
View File

@ -3,9 +3,9 @@
static void
grow_rgb8(uint32_t* rgb){
int r = channel_r(*rgb);
int g = channel_g(*rgb);
int b = channel_b(*rgb);
int r = ncchannel_r(*rgb);
int g = ncchannel_g(*rgb);
int b = ncchannel_b(*rgb);
int delta = (*rgb & 0x80000000ul) ? -1 : 1;
if(b == r){
b += delta;

8
src/demo/unicodeblocks.c
View File

@ -53,10 +53,10 @@ pbar_make(struct notcurses* nc, int row){
return NULL;
}
struct ncprogbar_options popts = {0};
channel_set_rgb8(&popts.ulchannel, 0x22, 0x22, 0x80);
channel_set_rgb8(&popts.urchannel, 0x22, 0x22, 0x80);
channel_set_rgb8(&popts.blchannel, 0x80, 0x80, 0x22);
channel_set_rgb8(&popts.brchannel, 0x80, 0x80, 0x22);
ncchannel_set_rgb8(&popts.ulchannel, 0x22, 0x22, 0x80);
ncchannel_set_rgb8(&popts.urchannel, 0x22, 0x22, 0x80);
ncchannel_set_rgb8(&popts.blchannel, 0x80, 0x80, 0x22);
ncchannel_set_rgb8(&popts.brchannel, 0x80, 0x80, 0x22);
struct ncprogbar* ncp = ncprogbar_create(pbar, &popts);
if(ncp == NULL){
return NULL;

2
src/demo/whiteout.c
View File

@ -484,7 +484,7 @@ int witherworm_demo(struct notcurses* nc){
size_t idx = 0;
ncplane_cursor_yx(n, &y, &x);
while((*s)[idx]){ // each multibyte char of string
if(ncplane_set_fg_rgb8(n, channel_r(rgb), channel_g(rgb), channel_b(rgb))){
if(ncplane_set_fg_rgb8(n, ncchannel_r(rgb), ncchannel_g(rgb), ncchannel_b(rgb))){
return -1;
}
if(x >= maxx){

62
src/lib/blit.c
View File

@ -9,9 +9,9 @@ static inline uint32_t
lerp(uint32_t c0, uint32_t c1){
uint32_t ret = 0;
unsigned r0, g0, b0, r1, g1, b1;
channel_rgb8(c0, &r0, &g0, &b0);
channel_rgb8(c1, &r1, &g1, &b1);
channel_set_rgb8(&ret, (r0 + r1 + 1) / 2,
ncchannel_rgb8(c0, &r0, &g0, &b0);
ncchannel_rgb8(c1, &r1, &g1, &b1);
ncchannel_set_rgb8(&ret, (r0 + r1 + 1) / 2,
(g0 + g1 + 1) / 2,
(b0 + b1 + 1) / 2);
return ret;
@ -22,10 +22,10 @@ static inline uint32_t
trilerp(uint32_t c0, uint32_t c1, uint32_t c2){
uint32_t ret = 0;
unsigned r0, g0, b0, r1, g1, b1, r2, g2, b2;
channel_rgb8(c0, &r0, &g0, &b0);
channel_rgb8(c1, &r1, &g1, &b1);
channel_rgb8(c2, &r2, &g2, &b2);
channel_set_rgb8(&ret, (r0 + r1 + r2 + 2) / 3,
ncchannel_rgb8(c0, &r0, &g0, &b0);
ncchannel_rgb8(c1, &r1, &g1, &b1);
ncchannel_rgb8(c2, &r2, &g2, &b2);
ncchannel_set_rgb8(&ret, (r0 + r1 + r2 + 2) / 3,
(g0 + g1 + g2 + 2) / 3,
(b0 + b1 + b2 + 2) / 3);
return ret;
@ -199,10 +199,10 @@ rgb_4diff(uint32_t* diffs, uint32_t tl, uint32_t tr, uint32_t bl, uint32_t br){
struct rgb {
unsigned r, g, b;
} colors[4];
channel_rgb8(tl, &colors[0].r, &colors[0].g, &colors[0].b);
channel_rgb8(tr, &colors[1].r, &colors[1].g, &colors[1].b);
channel_rgb8(bl, &colors[2].r, &colors[2].g, &colors[2].b);
channel_rgb8(br, &colors[3].r, &colors[3].g, &colors[3].b);
ncchannel_rgb8(tl, &colors[0].r, &colors[0].g, &colors[0].b);
ncchannel_rgb8(tr, &colors[1].r, &colors[1].g, &colors[1].b);
ncchannel_rgb8(bl, &colors[2].r, &colors[2].g, &colors[2].b);
ncchannel_rgb8(br, &colors[3].r, &colors[3].g, &colors[3].b);
for(size_t idx = 0 ; idx < sizeof(quadrant_drivers) / sizeof(*quadrant_drivers) ; ++idx){
const struct qdriver* qd = quadrant_drivers + idx;
const struct rgb* rgb0 = colors + qd->pair[0];
@ -255,19 +255,19 @@ quadrant_solver(uint32_t tl, uint32_t tr, uint32_t bl, uint32_t br,
// break down the excluded pair and lerp
unsigned r0, r1, r2, g0, g1, g2, b0, b1, b2;
unsigned roth, goth, both, rlerp, glerp, blerp;
channel_rgb8(*back, &roth, &goth, &both);
channel_rgb8(*fore, &rlerp, &glerp, &blerp);
ncchannel_rgb8(*back, &roth, &goth, &both);
ncchannel_rgb8(*fore, &rlerp, &glerp, &blerp);
//fprintf(stderr, "rgbs: %02x %02x %02x / %02x %02x %02x\n", r0, g0, b0, r1, g1, b1);
// get diffs of the excluded two from both lerps
channel_rgb8(colors[qd->others[0]], &r0, &g0, &b0);
channel_rgb8(colors[qd->others[1]], &r1, &g1, &b1);
ncchannel_rgb8(colors[qd->others[0]], &r0, &g0, &b0);
ncchannel_rgb8(colors[qd->others[1]], &r1, &g1, &b1);
diffs[0] = rgb_diff(r0, g0, b0, roth, goth, both);
diffs[1] = rgb_diff(r1, g1, b1, roth, goth, both);
diffs[2] = rgb_diff(r0, g0, b0, rlerp, glerp, blerp);
diffs[3] = rgb_diff(r1, g1, b1, rlerp, glerp, blerp);
// get diffs of the included two from their lerp
channel_rgb8(colors[qd->pair[0]], &r0, &g0, &b0);
channel_rgb8(colors[qd->pair[1]], &r1, &g1, &b1);
ncchannel_rgb8(colors[qd->pair[0]], &r0, &g0, &b0);
ncchannel_rgb8(colors[qd->pair[1]], &r1, &g1, &b1);
diffs[4] = rgb_diff(r0, g0, b0, rlerp, glerp, blerp);
diffs[5] = rgb_diff(r1, g1, b1, rlerp, glerp, blerp);
unsigned curdiff = diffs[0] + diffs[1] + diffs[4] + diffs[5];
@ -276,8 +276,8 @@ quadrant_solver(uint32_t tl, uint32_t tr, uint32_t bl, uint32_t br,
// closer to the primary lerp. recalculate total diff; merge if lower.
if(diffs[2] < diffs[3]){
unsigned tri = trilerp(colors[qd->pair[0]], colors[qd->pair[1]], colors[qd->others[0]]);
channel_rgb8(colors[qd->others[0]], &r2, &g2, &b2);
channel_rgb8(tri, &roth, &goth, &both);
ncchannel_rgb8(colors[qd->others[0]], &r2, &g2, &b2);
ncchannel_rgb8(tri, &roth, &goth, &both);
if(rgb_diff(r0, g0, b0, roth, goth, both) +
rgb_diff(r1, g1, b1, roth, goth, both) +
rgb_diff(r2, g2, b2, roth, goth, both) < curdiff){
@ -288,8 +288,8 @@ quadrant_solver(uint32_t tl, uint32_t tr, uint32_t bl, uint32_t br,
//fprintf(stderr, "quadblitter swap type 1\n");
}else{
unsigned tri = trilerp(colors[qd->pair[0]], colors[qd->pair[1]], colors[qd->others[1]]);
channel_rgb8(colors[qd->others[1]], &r2, &g2, &b2);
channel_rgb8(tri, &roth, &goth, &both);
ncchannel_rgb8(colors[qd->others[1]], &r2, &g2, &b2);
ncchannel_rgb8(tri, &roth, &goth, &both);
if(rgb_diff(r0, g0, b0, roth, goth, both) +
rgb_diff(r1, g1, b1, roth, goth, both) +
rgb_diff(r2, g2, b2, roth, goth, both) < curdiff){
@ -316,10 +316,10 @@ qtrans_check(nccell* c, unsigned blendcolors,
const unsigned char* rgbbase_bl, const unsigned char* rgbbase_br,
uint32_t transcolor){
uint32_t tl = 0, tr = 0, bl = 0, br = 0;
channel_set_rgb8(&tl, rgbbase_tl[0], rgbbase_tl[1], rgbbase_tl[2]);
channel_set_rgb8(&tr, rgbbase_tr[0], rgbbase_tr[1], rgbbase_tr[2]);
channel_set_rgb8(&bl, rgbbase_bl[0], rgbbase_bl[1], rgbbase_bl[2]);
channel_set_rgb8(&br, rgbbase_br[0], rgbbase_br[1], rgbbase_br[2]);
ncchannel_set_rgb8(&tl, rgbbase_tl[0], rgbbase_tl[1], rgbbase_tl[2]);
ncchannel_set_rgb8(&tr, rgbbase_tr[0], rgbbase_tr[1], rgbbase_tr[2]);
ncchannel_set_rgb8(&bl, rgbbase_bl[0], rgbbase_bl[1], rgbbase_bl[2]);
ncchannel_set_rgb8(&br, rgbbase_br[0], rgbbase_br[1], rgbbase_br[2]);
const char* egc = NULL;
if(rgba_trans_q(rgbbase_tl, transcolor)){
// top left is transparent
@ -464,10 +464,10 @@ quadrant_blit(ncplane* nc, int linesize, const void* data,
const char* egc = qtrans_check(c, bargs->u.cell.blendcolors, rgbbase_tl, rgbbase_tr, rgbbase_bl, rgbbase_br, bargs->transcolor);
if(egc == NULL){
uint32_t tl = 0, tr = 0, bl = 0, br = 0;
channel_set_rgb8(&tl, rgbbase_tl[0], rgbbase_tl[1], rgbbase_tl[2]);
channel_set_rgb8(&tr, rgbbase_tr[0], rgbbase_tr[1], rgbbase_tr[2]);
channel_set_rgb8(&bl, rgbbase_bl[0], rgbbase_bl[1], rgbbase_bl[2]);
channel_set_rgb8(&br, rgbbase_br[0], rgbbase_br[1], rgbbase_br[2]);
ncchannel_set_rgb8(&tl, rgbbase_tl[0], rgbbase_tl[1], rgbbase_tl[2]);
ncchannel_set_rgb8(&tr, rgbbase_tr[0], rgbbase_tr[1], rgbbase_tr[2]);
ncchannel_set_rgb8(&bl, rgbbase_bl[0], rgbbase_bl[1], rgbbase_bl[2]);
ncchannel_set_rgb8(&br, rgbbase_br[0], rgbbase_br[1], rgbbase_br[2]);
uint32_t bg, fg;
//fprintf(stderr, "qtrans check: %d/%d\n%08x %08x\n%08x %08x\n", y, x, *(const uint32_t*)rgbbase_tl, *(const uint32_t*)rgbbase_tr, *(const uint32_t*)rgbbase_bl, *(const uint32_t*)rgbbase_br);
egc = quadrant_solver(tl, tr, bl, br, &fg, &bg);
@ -564,9 +564,9 @@ sex_solver(const uint32_t rgbas[6], uint64_t* channels, unsigned blendcolors){
for(unsigned mask = 0 ; mask < 6 ; ++mask){
unsigned r, g, b;
if(partitions[glyph] & (1u << mask)){
channel_rgb8(l0, &r, &g, &b);
ncchannel_rgb8(l0, &r, &g, &b);
}else{
channel_rgb8(l1, &r, &g, &b);
ncchannel_rgb8(l1, &r, &g, &b);
}
uint32_t rdiff = rgb_diff(ncpixel_r(rgbas[mask]), ncpixel_g(rgbas[mask]),
ncpixel_b(rgbas[mask]), r, g, b);

24
src/lib/fill.c
View File

@ -94,20 +94,20 @@ int ncplane_polyfill_yx(ncplane* n, int y, int x, const nccell* c){
static bool
check_gradient_channel_args(uint32_t ul, uint32_t ur, uint32_t bl, uint32_t br){
if(channel_default_p(ul) || channel_default_p(ur) ||
channel_default_p(bl) || channel_default_p(br)){
if(!(channel_default_p(ul) && channel_default_p(ur) &&
channel_default_p(bl) && channel_default_p(br))){
if(ncchannel_default_p(ul) || ncchannel_default_p(ur) ||
ncchannel_default_p(bl) || ncchannel_default_p(br)){
if(!(ncchannel_default_p(ul) && ncchannel_default_p(ur) &&
ncchannel_default_p(bl) && ncchannel_default_p(br))){
return true;
}
}
if(channel_alpha(ul) != channel_alpha(ur) ||
channel_alpha(ur) != channel_alpha(bl) ||
channel_alpha(bl) != channel_alpha(br)){
if(ncchannel_alpha(ul) != ncchannel_alpha(ur) ||
ncchannel_alpha(ur) != ncchannel_alpha(bl) ||
ncchannel_alpha(bl) != ncchannel_alpha(br)){
return true;
}
if(channel_palindex_p(ul) || channel_palindex_p(bl) ||
channel_palindex_p(br) || channel_palindex_p(ur)){
if(ncchannel_palindex_p(ul) || ncchannel_palindex_p(bl) ||
ncchannel_palindex_p(br) || ncchannel_palindex_p(ur)){
return true;
}
return false;
@ -137,7 +137,7 @@ bool check_gradient_args(uint64_t ul, uint64_t ur, uint64_t bl, uint64_t br){
static inline void
calc_highgradient(nccell* c, uint32_t ul, uint32_t ur, uint32_t ll,
uint32_t lr, int y, int x, int ylen, int xlen){
if(!channel_default_p(ul)){
if(!ncchannel_default_p(ul)){
cell_set_fchannel(c, calc_gradient_channel(ul, ur, ll, lr,
y * 2, x, ylen, xlen));
cell_set_bchannel(c, calc_gradient_channel(ul, ur, ll, lr,
@ -361,9 +361,9 @@ rotate_output(ncplane* dst, uint32_t tchan, uint32_t bchan){
if(tchan != bchan){
return ncplane_putegc(dst, "▀", NULL);
}
if(channel_default_p(tchan) && channel_default_p(bchan)){
if(ncchannel_default_p(tchan) && ncchannel_default_p(bchan)){
return ncplane_putegc(dst, "", NULL);
}else if(channel_default_p(tchan)){
}else if(ncchannel_default_p(tchan)){
return ncplane_putegc(dst, " ", NULL);
}
return ncplane_putegc(dst, "█", NULL);

42
src/lib/internal.h
View File

@ -1177,17 +1177,17 @@ static inline uint32_t
calc_gradient_channel(uint32_t ul, uint32_t ur, uint32_t ll, uint32_t lr,
int y, int x, int ylen, int xlen){
uint32_t chan = 0;
channel_set_rgb8_clipped(&chan,
calc_gradient_component(channel_r(ul), channel_r(ur),
channel_r(ll), channel_r(lr),
ncchannel_set_rgb8_clipped(&chan,
calc_gradient_component(ncchannel_r(ul), ncchannel_r(ur),
ncchannel_r(ll), ncchannel_r(lr),
y, x, ylen, xlen),
calc_gradient_component(channel_g(ul), channel_g(ur),
channel_g(ll), channel_g(lr),
calc_gradient_component(ncchannel_g(ul), ncchannel_g(ur),
ncchannel_g(ll), ncchannel_g(lr),
y, x, ylen, xlen),
calc_gradient_component(channel_b(ul), channel_b(ur),
channel_b(ll), channel_b(lr),
calc_gradient_component(ncchannel_b(ul), ncchannel_b(ur),
ncchannel_b(ll), ncchannel_b(lr),
y, x, ylen, xlen));
channel_set_alpha(&chan, channel_alpha(ul)); // precondition: all αs are equal
ncchannel_set_alpha(&chan, ncchannel_alpha(ul)); // precondition: all αs are equal
return chan;
}
@ -1374,26 +1374,26 @@ cell_set_fchannel(nccell* cl, uint32_t channel){
// Palette-indexed colors do not blend. Do not pass me palette-indexed channels!
static inline unsigned
channels_blend(unsigned c1, unsigned c2, unsigned* blends){
if(channel_alpha(c2) == CELL_ALPHA_TRANSPARENT){
if(ncchannel_alpha(c2) == CELL_ALPHA_TRANSPARENT){
return c1; // do *not* increment *blends
}
bool c2default = channel_default_p(c2);
bool c2default = ncchannel_default_p(c2);
if(*blends == 0){
// don't just return c2, or you set wide status and all kinds of crap
if(channel_default_p(c2)){
channel_set_default(&c1);
if(ncchannel_default_p(c2)){
ncchannel_set_default(&c1);
}else{
channel_set(&c1, c2 & CELL_BG_RGB_MASK);
ncchannel_set(&c1, c2 & CELL_BG_RGB_MASK);
}
channel_set_alpha(&c1, channel_alpha(c2));
}else if(!c2default && !channel_default_p(c1)){
ncchannel_set_alpha(&c1, ncchannel_alpha(c2));
}else if(!c2default && !ncchannel_default_p(c1)){
unsigned rsum, gsum, bsum;
channel_rgb8(c2, &rsum, &gsum, &bsum);
rsum = (channel_r(c1) * *blends + rsum) / (*blends + 1);
gsum = (channel_g(c1) * *blends + gsum) / (*blends + 1);
bsum = (channel_b(c1) * *blends + bsum) / (*blends + 1);
channel_set_rgb8(&c1, rsum, gsum, bsum);
channel_set_alpha(&c1, channel_alpha(c2));
ncchannel_rgb8(c2, &rsum, &gsum, &bsum);
rsum = (ncchannel_r(c1) * *blends + rsum) / (*blends + 1);
gsum = (ncchannel_g(c1) * *blends + gsum) / (*blends + 1);
bsum = (ncchannel_b(c1) * *blends + bsum) / (*blends + 1);
ncchannel_set_rgb8(&c1, rsum, gsum, bsum);
ncchannel_set_alpha(&c1, ncchannel_alpha(c2));
}
++*blends;
return c1;

12
src/lib/render.c
View File

@ -127,14 +127,14 @@ int cell_duplicate(struct ncplane* n, nccell* targ, const nccell* c){
// Emit fchannel with RGB changed to contrast effectively against bchannel.
static uint32_t
highcontrast(uint32_t bchannel){
unsigned r = channel_r(bchannel);
unsigned g = channel_g(bchannel);
unsigned b = channel_b(bchannel);
unsigned r = ncchannel_r(bchannel);
unsigned g = ncchannel_g(bchannel);
unsigned b = ncchannel_b(bchannel);
uint32_t conrgb = 0;
if(r + g + b < 320){
channel_set(&conrgb, 0xffffff);
ncchannel_set(&conrgb, 0xffffff);
}else{
channel_set(&conrgb, 0);
ncchannel_set(&conrgb, 0);
}
return conrgb;
}
@ -779,7 +779,7 @@ update_palette(notcurses* nc, FILE* out){
for(size_t damageidx = 0 ; damageidx < sizeof(nc->palette.chans) / sizeof(*nc->palette.chans) ; ++damageidx){
unsigned r, g, b;
if(nc->palette_damage[damageidx]){
channel_rgb8(nc->palette.chans[damageidx], &r, &g, &b);
ncchannel_rgb8(nc->palette.chans[damageidx], &r, &g, &b);
// Need convert RGB values [0..256) to [0..1000], ugh
// FIXME need handle HSL case also
r = r * 1000 / 255;

16
src/poc/progbar.c
View File

@ -58,10 +58,10 @@ hbar_make(struct notcurses* nc, uint64_t flags){
struct ncprogbar_options popts = {
.flags = flags,
};
channel_set_rgb8(&popts.ulchannel, 0x80, 0x22, 0x22);
channel_set_rgb8(&popts.urchannel, 0x22, 0x22, 0x80);
channel_set_rgb8(&popts.blchannel, 0x22, 0x80, 0x22);
channel_set_rgb8(&popts.brchannel, 0x80, 0x22, 0x22);
ncchannel_set_rgb8(&popts.ulchannel, 0x80, 0x22, 0x22);
ncchannel_set_rgb8(&popts.urchannel, 0x22, 0x22, 0x80);
ncchannel_set_rgb8(&popts.blchannel, 0x22, 0x80, 0x22);
ncchannel_set_rgb8(&popts.brchannel, 0x80, 0x22, 0x22);
struct ncprogbar* ncp = ncprogbar_create(pbar, &popts);
if(ncp == NULL){
return NULL;
@ -98,10 +98,10 @@ pbar_make(struct notcurses* nc, uint64_t flags){
struct ncprogbar_options popts = {
.flags = flags,
};
channel_set_rgb8(&popts.ulchannel, 0x80, 0xcc, 0xcc);
channel_set_rgb8(&popts.urchannel, 0xcc, 0xcc, 0x80);
channel_set_rgb8(&popts.blchannel, 0xcc, 0x80, 0xcc);
channel_set_rgb8(&popts.brchannel, 0x80, 0xcc, 0xcc);
ncchannel_set_rgb8(&popts.ulchannel, 0x80, 0xcc, 0xcc);
ncchannel_set_rgb8(&popts.urchannel, 0xcc, 0xcc, 0x80);
ncchannel_set_rgb8(&popts.blchannel, 0xcc, 0x80, 0xcc);
ncchannel_set_rgb8(&popts.brchannel, 0x80, 0xcc, 0xcc);
struct ncprogbar* ncp = ncprogbar_create(pbar, &popts);
if(ncp == NULL){
return NULL;

8
src/poc/rotator.c
View File

@ -15,10 +15,10 @@ rotate_grad(struct notcurses* nc){
struct ncplane* n = notcurses_stddim_yx(nc, &dimy, &dimx);
ncplane_home(n);
uint32_t tl = 0, tr = 0, bl = 0, br = 0;
channel_set_rgb8(&tl, 0xff, 0, 0);
channel_set_rgb8(&tr, 0, 0, 0xff);
channel_set_rgb8(&bl, 0, 0xff, 0);
channel_set_rgb8(&br, 0, 0xff, 0xff);
ncchannel_set_rgb8(&tl, 0xff, 0, 0);
ncchannel_set_rgb8(&tr, 0, 0, 0xff);
ncchannel_set_rgb8(&bl, 0, 0xff, 0);
ncchannel_set_rgb8(&br, 0, 0xff, 0xff);
if(ncplane_highgradient(n, tl, tr, bl, br, dimy - 1, dimx - 1) <= 0){
return -1;
}

62
src/tests/channel.cpp
View File

@ -15,7 +15,7 @@ TEST_CASE("ChannelGetRGB") {
};
for(auto i = 0u ; i < sizeof(test) / sizeof(*test) ; ++i){
unsigned r, g, b;
CHECK(test[i].channel == channel_rgb8(test[i].channel, &r, &g, &b));
CHECK(test[i].channel == ncchannel_rgb8(test[i].channel, &r, &g, &b));
CHECK(test[i].r == r);
CHECK(test[i].g == g);
CHECK(test[i].b == b);
@ -35,7 +35,7 @@ TEST_CASE("ChannelGetAlpha") {
{ .channel = 0xffffffff, .a = CELL_ALPHA_HIGHCONTRAST, },
};
for(auto i = 0u ; i < sizeof(test) / sizeof(*test) ; ++i){
CHECK(test[i].a == channel_alpha(test[i].channel));
CHECK(test[i].a == ncchannel_alpha(test[i].channel));
}
}
@ -52,7 +52,7 @@ TEST_CASE("ChannelGetDefault") {
{ .channel = 0xffffffff, .def = false, },
};
for(auto i = 0u ; i < sizeof(test) / sizeof(*test) ; ++i){
CHECK(test[i].def == channel_default_p(test[i].channel));
CHECK(test[i].def == ncchannel_default_p(test[i].channel));
}
}
@ -63,9 +63,9 @@ TEST_CASE("ChannelSetDefault") {
};
for(auto i = 0u ; i < sizeof(channels) / sizeof(*channels) ; ++i){
uint32_t channel = channels[i];
CHECK(!channel_default_p(channel));
channel_set_default(&channel);
CHECK(channel_default_p(channel));
CHECK(!ncchannel_default_p(channel));
ncchannel_set_default(&channel);
CHECK(ncchannel_default_p(channel));
}
}
@ -73,13 +73,13 @@ TEST_CASE("ChannelSetDefault") {
TEST_CASE("ChannelBlend0") {
uint32_t c1 = 0;
uint32_t c2 = 0;
channel_set_rgb8(&c1, 0x80, 0x40, 0x20);
channel_set_rgb8(&c2, 0x88, 0x44, 0x22);
ncchannel_set_rgb8(&c1, 0x80, 0x40, 0x20);
ncchannel_set_rgb8(&c2, 0x88, 0x44, 0x22);
unsigned blends = 0;
uint32_t c = channels_blend(c1, c2, &blends);
CHECK(!channel_default_p(c));
CHECK(!ncchannel_default_p(c));
unsigned r, g, b;
channel_rgb8(c, &r, &g, &b);
ncchannel_rgb8(c, &r, &g, &b);
CHECK(0x88 == r);
CHECK(0x44 == g);
CHECK(0x22 == b);
@ -90,13 +90,13 @@ TEST_CASE("ChannelBlend0") {
TEST_CASE("ChannelBlend1") {
uint32_t c1 = 0;
uint32_t c2 = 0;
channel_set_rgb8(&c1, 0x80, 0x40, 0x20);
channel_set_rgb8(&c2, 0x0, 0x0, 0x0);
ncchannel_set_rgb8(&c1, 0x80, 0x40, 0x20);
ncchannel_set_rgb8(&c2, 0x0, 0x0, 0x0);
unsigned blends = 1;
uint32_t c = channels_blend(c1, c2, &blends);
CHECK(!channel_default_p(c));
CHECK(!ncchannel_default_p(c));
unsigned r, g, b;
channel_rgb8(c, &r, &g, &b);
ncchannel_rgb8(c, &r, &g, &b);
CHECK(0x40 == r);
CHECK(0x20 == g);
CHECK(0x10 == b);
@ -107,13 +107,13 @@ TEST_CASE("ChannelBlend1") {
TEST_CASE("ChannelBlend2") {
uint32_t c1 = 0;
uint32_t c2 = 0;
channel_set_rgb8(&c1, 0x60, 0x30, 0x0f);
channel_set_rgb8(&c2, 0x0, 0x0, 0x0);
ncchannel_set_rgb8(&c1, 0x60, 0x30, 0x0f);
ncchannel_set_rgb8(&c2, 0x0, 0x0, 0x0);
unsigned blends = 2;
uint32_t c = channels_blend(c1, c2, &blends);
CHECK(!channel_default_p(c));
CHECK(!ncchannel_default_p(c));
unsigned r, g, b;
channel_rgb8(c, &r, &g, &b);
ncchannel_rgb8(c, &r, &g, &b);
CHECK(0x40 == r);
CHECK(0x20 == g);
CHECK(0x0a == b);
@ -124,26 +124,26 @@ TEST_CASE("ChannelBlend2") {
TEST_CASE("ChannelBlendDefaultLeft") {
uint32_t c1 = 0;
uint32_t c2 = 0;
channel_set_rgb8(&c2, 0x80, 0x40, 0x20);
ncchannel_set_rgb8(&c2, 0x80, 0x40, 0x20);
unsigned blends = 0;
uint32_t c = channels_blend(c1, c2, &blends); // will replace
CHECK(!channel_default_p(c));
CHECK(!ncchannel_default_p(c));
unsigned r, g, b;
channel_rgb8(c, &r, &g, &b);
ncchannel_rgb8(c, &r, &g, &b);
CHECK(0x80 == r);
CHECK(0x40 == g);
CHECK(0x20 == b);
CHECK(1 == blends);
c = channels_blend(c1, c2, &blends); // will not replace
CHECK(channel_default_p(c));
channel_rgb8(c, &r, &g, &b);
CHECK(ncchannel_default_p(c));
ncchannel_rgb8(c, &r, &g, &b);
CHECK(0 == r);
CHECK(0 == g);
CHECK(0 == b);
CHECK(2 == blends);
c = channels_blend(c1, c2, &blends); // will not replace
CHECK(channel_default_p(c));
channel_rgb8(c, &r, &g, &b);
CHECK(ncchannel_default_p(c));
ncchannel_rgb8(c, &r, &g, &b);
CHECK(0 == r);
CHECK(0 == g);
CHECK(0 == b);
@ -154,17 +154,17 @@ TEST_CASE("ChannelBlendDefaultLeft") {
TEST_CASE("ChannelBlendDefaultRight") {
uint32_t c1 = 0;
uint32_t c2 = 0;
channel_set_rgb8(&c1, 0x80, 0x40, 0x20);
CHECK(!channel_default_p(c1));
CHECK(channel_default_p(c2));
ncchannel_set_rgb8(&c1, 0x80, 0x40, 0x20);
CHECK(!ncchannel_default_p(c1));
CHECK(ncchannel_default_p(c2));
unsigned blends = 0;
uint32_t c = channels_blend(c1, c2, &blends);
CHECK(channel_default_p(c));
CHECK(ncchannel_default_p(c));
CHECK(1 == blends);
c = channels_blend(c1, c2, &blends);
CHECK(!channel_default_p(c));
CHECK(!ncchannel_default_p(c));
unsigned r, g, b;
channel_rgb8(c, &r, &g, &b);
ncchannel_rgb8(c, &r, &g, &b);
CHECK(0x80 == r);
CHECK(0x40 == g);
CHECK(0x20 == b);

16
src/tests/fills.cpp
View File

@ -336,10 +336,10 @@ TEST_CASE("Fills") {
SUBCASE("HighGradient2Colors1Row") {
uint32_t ul, ur, ll, lr;
ul = ur = ll = lr = 0;
channel_set(&ul, 0xffffff);
channel_set(&lr, 0x000000);
channel_set(&ll, 0x00ffff);
channel_set(&ur, 0xff00ff);
ncchannel_set(&ul, 0xffffff);
ncchannel_set(&lr, 0x000000);
ncchannel_set(&ll, 0x00ffff);
ncchannel_set(&ur, 0xff00ff);
int dimy, dimx;
ncplane_dim_yx(n_, &dimy, &dimx);
REQUIRE(0 < ncplane_highgradient_sized(n_, ul, ur, ll, lr, dimy, dimx));
@ -349,10 +349,10 @@ TEST_CASE("Fills") {
SUBCASE("HighGradient") {
uint32_t ul, ur, ll, lr;
ul = ur = ll = lr = 0;
channel_set(&ul, 0xffffff);
channel_set(&lr, 0x000000);
channel_set(&ll, 0x00ffff);
channel_set(&ur, 0xff00ff);
ncchannel_set(&ul, 0xffffff);
ncchannel_set(&lr, 0x000000);
ncchannel_set(&ll, 0x00ffff);
ncchannel_set(&ur, 0xff00ff);
int dimy, dimx;
ncplane_dim_yx(n_, &dimy, &dimx);
REQUIRE(0 < ncplane_highgradient_sized(n_, ul, ur, ll, lr, dimy, dimx));