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

Redefine CELL_ALPHA_ in their natural forms

Browse Source 
CELL_ALPHA_OPAQUE et al were defined as 0..3, meaning
CELL_ALPHA_SHIFT had to be used to compare them to their
channel representations. Instead, define them in said
representation outright, eliminating the need to shift while
retaining arithmetic properties, and zero initialization for
CELL_ALPHA_OPAQUE. Eliminate CELL_ALPHA_SHIFT #738.
This commit is contained in:
nick black 2020-06-28 01:53:42 -04:00
parent 3985085d04
commit 354152b48b
No known key found for this signature in database
GPG Key ID: 5F43400C21CBFACC
11 changed files with 112 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
NEWS.md
View File

@ -5,6 +5,14 @@ rearrangements of Notcurses.
* The default blitter when `NCSCALE_STRETCH` is used is now `NCBLIT_2x2`,
replacing `NCBLIT_2x1`. It is not the default for `NCSCALE_NONE` and
`NCSCALE_SCALE` because it does not preserve aspect ratio.
* The values of `CELL_ALPHA_OPAQUE` and friends have been redefined to
match their values within a channel representation. If you've been
using the named constants, this should have no effect on you; they sort
the same, subtract the same, and a zero initialization remains just as
opaque as it ever was. If you weren't using their named constants, now's
an excellent time to revise that policy. `CELL_ALPHA_SHIFT` has been
eliminated; if you happened to be using this, the redefinition of the
other `CELL_*` constants (probably) means you no longer need to.
* 1.5.2 (2020-06-19)
* The `ncneofetch` program has been added, of no great consequence.

31
USAGE.md
View File

@ -1367,8 +1367,8 @@ ncplane_bg_alpha(const struct ncplane* nc){
}
// Set the alpha parameters for ncplane 'n'.
int ncplane_set_fg_alpha(struct ncplane* n, int alpha);
int ncplane_set_bg_alpha(struct ncplane* n, int alpha);
int ncplane_set_fg_alpha(struct ncplane* n, unsigned alpha);
int ncplane_set_bg_alpha(struct ncplane* n, unsigned alpha);
// Extract 24 bits of foreground RGB from 'n', split into subcomponents.
static inline unsigned
@ -1463,13 +1463,13 @@ typedef struct cell {
// corresponding default color bit *is not* set, and the corresponding
// palette index bit *is* set.
uint32_t attrword; // + 4B -> 8B
// (channels & 0x8000000000000000ull): left half of wide character
// (channels & 0x8000000000000000ull): part of a wide glyph
// (channels & 0x4000000000000000ull): foreground is *not* "default color"
// (channels & 0x3000000000000000ull): foreground alpha (2 bits)
// (channels & 0x0800000000000000ull): foreground uses palette index
// (channels & 0x0700000000000000ull): reserved, must be 0
// (channels & 0x00ffffff00000000ull): foreground in 3x8 RGB (rrggbb)
// (channels & 0x0000000080000000ull): right half of wide character
// (channels & 0x0000000080000000ull): reserved, must be 0
// (channels & 0x0000000040000000ull): background is *not* "default color"
// (channels & 0x0000000030000000ull): background alpha (2 bits)
// (channels & 0x0000000008000000ull): background uses palette index
@ -1483,19 +1483,18 @@ typedef struct cell {
uint64_t channels; // + 8B == 16B
} cell;
#define CELL_WIDEASIAN_MASK 0x8000000080000000ull
#define CELL_WIDEASIAN_MASK 0x8000000000000000ull
#define CELL_BGDEFAULT_MASK 0x0000000040000000ull
#define CELL_FGDEFAULT_MASK (CELL_BGDEFAULT_MASK << 32u)
#define CELL_BG_MASK 0x0000000000ffffffull
#define CELL_FG_MASK (CELL_BG_MASK << 32u)
#define CELL_BG_PALETTE 0x0000000008000000ull
#define CELL_FG_PALETTE (CELL_BG_PALETTE << 32u)
#define CELL_ALPHA_MASK 0x0000000030000000ull
#define CELL_ALPHA_SHIFT 28u
#define CELL_ALPHA_HIGHCONTRAST 3
#define CELL_ALPHA_TRANSPARENT 2
#define CELL_ALPHA_BLEND 1
#define CELL_ALPHA_OPAQUE 0
#define NCCHANNEL_ALPHA_MASK 0x30000000ull
#define CELL_ALPHA_HIGHCONTRAST 0x30000000ull
#define CELL_ALPHA_TRANSPARENT 0x20000000ull
#define CELL_ALPHA_BLEND 0x10000000ull
#define CELL_ALPHA_OPAQUE 0x00000000ull
```
`cell`s must be initialized with an initialization macro or `cell_init()`
@ -1763,12 +1762,12 @@ cell_set_bg(cell* c, uint32_t channel){
}
static inline int
cell_set_fg_alpha(cell* c, int alpha){
cell_set_fg_alpha(cell* c, unsigned alpha){
return channels_set_fg_alpha(&c->channels, alpha);
}
static inline int
cell_set_bg_alpha(cell* c, int alpha){
cell_set_bg_alpha(cell* c, unsigned alpha){
return channels_set_bg_alpha(&c->channels, alpha);
}
@ -2332,7 +2331,7 @@ channel_alpha(unsigned channel){
// Set the 2-bit alpha component of the 32-bit channel.
static inline int
channel_set_alpha(unsigned* channel, int alpha){
channel_set_alpha(unsigned* channel, unsigned alpha){
if(alpha < CELL_ALPHA_OPAQUE || alpha > CELL_ALPHA_TRANS){
return -1;
}
@ -2447,7 +2446,7 @@ channels_set_bg(uint64_t* channels, unsigned rgb){
// Set the 2-bit alpha component of the foreground channel.
static inline int
channels_set_fg_alpha(uint64_t* channels, int alpha){
channels_set_fg_alpha(uint64_t* channels, unsigned alpha){
unsigned channel = channels_fchannel(*channels);
if(channel_set_alpha(&channel, alpha) < 0){
return -1;
@ -2458,7 +2457,7 @@ channels_set_fg_alpha(uint64_t* channels, int alpha){
// Set the 2-bit alpha component of the background channel.
static inline int
channels_set_bg_alpha(uint64_t* channels, int alpha){
channels_set_bg_alpha(uint64_t* channels, unsigned alpha){
if(alpha == CELL_ALPHA_HIGHCONTRAST){ // forbidden for background alpha
return -1;
}

4
doc/man/man3/notcurses_plane.3.md
View File

@ -110,9 +110,9 @@ notcurses_plane - operations on ncplanes
**void ncplane_set_bg_default(struct ncplane* n);**
**int ncplane_set_fg_alpha(struct ncplane* n, int alpha);**
**int ncplane_set_fg_alpha(struct ncplane* n, unsigned alpha);**
**int ncplane_set_bg_alpha(struct ncplane* n, int alpha);**
**int ncplane_set_bg_alpha(struct ncplane* n, unsigned alpha);**
**int ncplane_set_fg_palindex(struct ncplane* n, int idx);**

8
include/ncpp/Cell.hh
View File

@ -17,11 +17,11 @@ namespace ncpp
public:
static constexpr uint64_t WideAsianMask = CELL_WIDEASIAN_MASK;
static constexpr uint64_t FGDefaultMask = CELL_FGDEFAULT_MASK;
static constexpr uint64_t FGMask = CELL_FG_MASK;
static constexpr uint64_t FGRGBMask = CELL_FG_RGB_MASK;
static constexpr uint64_t BGDefaultMask = CELL_BGDEFAULT_MASK;
static constexpr uint64_t BGMask = CELL_BG_MASK;
static constexpr uint64_t AlphaMask = CELL_ALPHA_MASK;
static constexpr uint32_t AlphaShift = CELL_ALPHA_SHIFT;
static constexpr uint64_t BGRGBMask = CELL_BG_RGB_MASK;
static constexpr uint64_t BGAlphaMask = CELL_BG_ALPHA_MASK;
static constexpr uint64_t FGAlphaMask = CELL_FG_ALPHA_MASK;
static constexpr int AlphaHighContrast = CELL_ALPHA_HIGHCONTRAST;
static constexpr int AlphaTransparent = CELL_ALPHA_TRANSPARENT;
static constexpr int AlphaBlend = CELL_ALPHA_BLEND;

70
include/notcurses/notcurses.h
View File

@ -163,19 +163,41 @@ mbswidth(const char* mbs){
return cols;
}
#define CELL_WIDEASIAN_MASK 0x8000000080000000ull
// extract these bits to get a channel's alpha value
#define NCCHANNEL_ALPHA_MASK 0x30000000ull
// background cannot be highcontrast, only foreground
#define CELL_ALPHA_HIGHCONTRAST 0x30000000ull
#define CELL_ALPHA_TRANSPARENT 0x20000000ull
#define CELL_ALPHA_BLEND 0x10000000ull
#define CELL_ALPHA_OPAQUE 0x00000000ull
// if this bit is set, the cell is part of a multicolumn glyph. whether a
// cell is the left or right side of the glyph can be determined by checking
// whether ->gcluster is zero.
#define CELL_WIDEASIAN_MASK 0x8000000000000000ull
// if this bit is set, we are *not* using the default background color
#define CELL_BGDEFAULT_MASK 0x0000000040000000ull
// if this bit is set, we are *not* using the default foreground color
#define CELL_FGDEFAULT_MASK (CELL_BGDEFAULT_MASK << 32u)
#define CELL_BG_MASK 0x0000000000ffffffull
#define CELL_FG_MASK (CELL_BG_MASK << 32u)
// extract these bits to get the background RGB value
#define CELL_BG_RGB_MASK 0x0000000000ffffffull
// extract these bits to get the foreground RGB value
#define CELL_FG_RGB_MASK (CELL_BG_RGB_MASK << 32u)
// if this bit *and* CELL_BGDEFAULT_MASK are set, we're using a
// palette-indexed background color
#define CELL_BG_PALETTE 0x0000000008000000ull
// if this bit *and* CELL_FGDEFAULT_MASK are set, we're using a
// palette-indexed foreground color
#define CELL_FG_PALETTE (CELL_BG_PALETTE << 32u)
#define CELL_ALPHA_MASK 0x0000000030000000ull
#define CELL_ALPHA_SHIFT 28u
#define CELL_ALPHA_HIGHCONTRAST 3
#define CELL_ALPHA_TRANSPARENT 2
#define CELL_ALPHA_BLEND 1
#define CELL_ALPHA_OPAQUE 0
// extract these bits to get the background alpha mask
#define CELL_BG_ALPHA_MASK NCCHANNEL_ALPHA_MASK
// extract these bits to get the foreground alpha mask
#define CELL_FG_ALPHA_MASK (CELL_BG_ALPHA_MASK << 32u)
// initialize a 64-bit channel pair with specified RGB fg/bg
#define CHANNELS_RGB_INITIALIZER(fr, fg, fb, br, bg, bb) \
(((((uint64_t)(fr) << 16u) + ((uint64_t)(fg) << 8u) + (uint64_t)(fb)) << 32ull) + \
(((br) << 16u) + ((bg) << 8u) + (bb)) + CELL_BGDEFAULT_MASK + CELL_FGDEFAULT_MASK)
// These lowest-level functions manipulate a 64-bit channel encoding directly.
// Users will typically manipulate ncplane and cell channels through those APIs,
@ -220,7 +242,7 @@ channel_set_rgb(unsigned* channel, int r, int g, int b){
return -1;
}
unsigned c = (r << 16u) | (g << 8u) | b;
*channel = (*channel & ~CELL_BG_MASK) | CELL_BGDEFAULT_MASK | c;
*channel = (*channel & ~CELL_BG_RGB_MASK) | CELL_BGDEFAULT_MASK | c;
return 0;
}
@ -324,7 +346,7 @@ channel_set_rgb_clipped(unsigned* channel, int r, int g, int b){
b = 0;
}
unsigned c = (r << 16u) | (g << 8u) | b;
*channel = (*channel & ~CELL_BG_MASK) | CELL_BGDEFAULT_MASK | c;
*channel = (*channel & ~CELL_BG_RGB_MASK) | CELL_BGDEFAULT_MASK | c;
}
// Same, but provide an assembled, packed 24 bits of rgb.
@ -333,23 +355,23 @@ channel_set(unsigned* channel, unsigned rgb){
if(rgb > 0xffffffu){
return -1;
}
*channel = (*channel & ~CELL_BG_MASK) | CELL_BGDEFAULT_MASK | rgb;
*channel = (*channel & ~CELL_BG_RGB_MASK) | CELL_BGDEFAULT_MASK | rgb;
return 0;
}
// Extract the 2-bit alpha component from a 32-bit channel.
static inline unsigned
channel_alpha(unsigned channel){
return (channel & CELL_ALPHA_MASK) >> CELL_ALPHA_SHIFT;
return channel & NCCHANNEL_ALPHA_MASK;
}
// Set the 2-bit alpha component of the 32-bit channel.
static inline int
channel_set_alpha(unsigned* channel, int alpha){
if(alpha < CELL_ALPHA_OPAQUE || alpha > CELL_ALPHA_HIGHCONTRAST){
channel_set_alpha(unsigned* channel, unsigned alpha){
if(alpha & ~NCCHANNEL_ALPHA_MASK){
return -1;
}
*channel = (alpha << CELL_ALPHA_SHIFT) | (*channel & ~CELL_ALPHA_MASK);
*channel = alpha | (*channel & ~NCCHANNEL_ALPHA_MASK);
if(alpha != CELL_ALPHA_OPAQUE){
*channel |= CELL_BGDEFAULT_MASK;
}
@ -409,13 +431,13 @@ channels_combine(uint32_t fchan, uint32_t bchan){
// Extract 24 bits of foreground RGB from 'channels', shifted to LSBs.
static inline unsigned
channels_fg(uint64_t channels){
return channels_fchannel(channels) & CELL_BG_MASK;
return channels_fchannel(channels) & CELL_BG_RGB_MASK;
}
// Extract 24 bits of background RGB from 'channels', shifted to LSBs.
static inline unsigned
channels_bg(uint64_t channels){
return channels_bchannel(channels) & CELL_BG_MASK;
return channels_bchannel(channels) & CELL_BG_RGB_MASK;
}
// Extract 2 bits of foreground alpha from 'channels', shifted to LSBs.
@ -506,7 +528,7 @@ channels_set_bg(uint64_t* channels, unsigned rgb){
// Set the 2-bit alpha component of the foreground channel.
static inline int
channels_set_fg_alpha(uint64_t* channels, int alpha){
channels_set_fg_alpha(uint64_t* channels, unsigned alpha){
unsigned channel = channels_fchannel(*channels);
if(channel_set_alpha(&channel, alpha) < 0){
return -1;
@ -517,7 +539,7 @@ channels_set_fg_alpha(uint64_t* channels, int alpha){
// Set the 2-bit alpha component of the background channel.
static inline int
channels_set_bg_alpha(uint64_t* channels, int alpha){
channels_set_bg_alpha(uint64_t* channels, unsigned alpha){
if(alpha == CELL_ALPHA_HIGHCONTRAST){ // forbidden for background alpha
return -1;
}
@ -631,13 +653,13 @@ typedef struct cell {
// corresponding default color bit *is not* set, and the corresponding
// palette index bit *is* set.
uint32_t attrword; // + 4B -> 8B
// (channels & 0x8000000000000000ull): left half of wide character
// (channels & 0x8000000000000000ull): part of a wide glyph
// (channels & 0x4000000000000000ull): foreground is *not* "default color"
// (channels & 0x3000000000000000ull): foreground alpha (2 bits)
// (channels & 0x0800000000000000ull): foreground uses palette index
// (channels & 0x0700000000000000ull): reserved, must be 0
// (channels & 0x00ffffff00000000ull): foreground in 3x8 RGB (rrggbb)
// (channels & 0x0000000080000000ull): right half of wide character
// (channels & 0x0000000080000000ull): reserved, must be 0
// (channels & 0x0000000040000000ull): background is *not* "default color"
// (channels & 0x0000000030000000ull): background alpha (2 bits)
// (channels & 0x0000000008000000ull): background uses palette index
@ -1917,7 +1939,7 @@ cell_set_fg_palindex(cell* cl, int idx){
}
cl->channels |= CELL_FGDEFAULT_MASK;
cl->channels |= CELL_FG_PALETTE;
cl->channels &= ~(CELL_ALPHA_MASK << 32u);
cell_set_fg_alpha(cl, CELL_ALPHA_OPAQUE);
cl->attrword &= 0xffff00ff;
cl->attrword |= (idx << 8u);
return 0;
@ -1957,7 +1979,7 @@ cell_set_bg_palindex(cell* cl, int idx){
}
cl->channels |= CELL_BGDEFAULT_MASK;
cl->channels |= CELL_BG_PALETTE;
cl->channels &= ~CELL_ALPHA_MASK;
cell_set_bg_alpha(cl, CELL_ALPHA_OPAQUE);
cl->attrword &= 0xffffff00;
cl->attrword |= idx;
return 0;

8
python/src/notcurses/build_notcurses.py
View File

@ -166,8 +166,8 @@ int ncplane_set_fg(struct ncplane* n, unsigned channel);
int ncplane_set_bg(struct ncplane* n, unsigned channel);
void ncplane_set_fg_default(struct ncplane* n);
void ncplane_set_bg_default(struct ncplane* n);
int ncplane_set_fg_alpha(struct ncplane* n, int alpha);
int ncplane_set_bg_alpha(struct ncplane* n, int alpha);
int ncplane_set_fg_alpha(struct ncplane* n, unsigned alpha);
int ncplane_set_bg_alpha(struct ncplane* n, unsigned alpha);
int ncplane_set_fg_palindex(struct ncplane* n, int idx);
int ncplane_set_bg_palindex(struct ncplane* n, int idx);
void ncplane_styles_set(struct ncplane* n, unsigned stylebits);
@ -218,8 +218,8 @@ void cell_styles_on(cell* c, unsigned stylebits);
void cell_styles_off(cell* c, unsigned stylebits);
void cell_set_fg_default(cell* c);
void cell_set_bg_default(cell* c);
int cell_set_fg_alpha(cell* c, int alpha);
int cell_set_bg_alpha(cell* c, int alpha);
int cell_set_fg_alpha(cell* c, unsigned alpha);
int cell_set_bg_alpha(cell* c, unsigned alpha);
bool cell_double_wide_p(const cell* c);
bool cell_simple_p(const cell* c);
const char* cell_extended_gcluster(const struct ncplane* n, const cell* c);

12
src/demo/mojibake.c
View File

@ -3,11 +3,12 @@
static struct ncplane*
mojiplane(struct ncplane* title, int y, int rows, const char* summary){
struct ncplane* n = ncplane_aligned(title, rows, 64, y, NCALIGN_CENTER, NULL);
if(ncplane_perimeter_rounded(n, 0, 0, 0) < 0){
uint64_t channels = CHANNELS_RGB_INITIALIZER(0xf0, 0xa0, 0xf0, 0x10, 0x10, 0x60);
if(ncplane_perimeter_rounded(n, 0, channels, 0) < 0){
ncplane_destroy(n);
return NULL;
}
uint64_t channels = 0;
channels = 0;
channels_set_bg(&channels, 0x0);
if(ncplane_set_fg(n, 0x40d0d0) || ncplane_set_bg(n, 0)){
ncplane_destroy(n);
@ -154,19 +155,21 @@ maketitle(struct ncplane* std, int dimx){
}
uint64_t channels = 0;
channels_set_bg(&channels, 0x0);
if(ncplane_set_base(title, " ", 0, channels) < 0 || ncplane_set_fg(title, 0xffffff)
|| ncplane_set_bg(title, 0)){
if(ncplane_set_base(title, " ", 0, channels) < 0 || ncplane_set_bg(title, 0)){
ncplane_destroy(title);
return NULL;
}
ncplane_set_fg(title, 0x80f0f0);
if(ncplane_putstr_aligned(title, 0, NCALIGN_CENTER, "mojibake 文字化けmodʑibake (english: \"garbled\")") < 0){
ncplane_destroy(title);
return NULL;
}
ncplane_set_fg(title, 0xa0ffff);
if(ncplane_putstr_aligned(title, 1, NCALIGN_CENTER, "Display of emoji depends upon terminal, font, and font rendering engine.") < 0){
ncplane_destroy(title);
return NULL;
}
ncplane_set_fg(title, 0xe0ffff);
if(ncplane_putstr_aligned(title, 2, NCALIGN_CENTER, "Not all symbols are emoji, and not all emoji map to a single code point.") < 0){
ncplane_destroy(title);
return NULL;
@ -180,6 +183,7 @@ int mojibake_demo(struct notcurses* nc){
}
int dimy, dimx;
struct ncplane* std = notcurses_stddim_yx(nc, &dimy, &dimx);
ncplane_greyscale(std);
struct ncplane* title = maketitle(std, dimx);
if(title == NULL){
return -1;

2
src/lib/internal.h
View File

@ -327,7 +327,7 @@ typedef struct notcurses {
void sigwinch_handler(int signo);
int term_verify_seq(char** gseq, const char* name);
int terminfostr(char** gseq, const char* name);
int interrogate_terminfo(tinfo* ti);
// Search the provided multibyte (UTF8) string 's' for the provided unicode

16
src/lib/notcurses.c
View File

@ -347,7 +347,7 @@ void ncplane_home(ncplane* n){
inline int ncplane_cursor_move_yx(ncplane* n, int y, int x){
if(x >= n->lenx){
logerror(n->nc, "Target x %d exceeded length %d\n", x, n->lenx);
logerror(n->nc, "Target x %d >= length %d\n", x, n->lenx);
return -1;
}else if(x < 0){
if(x < -1){
@ -358,7 +358,7 @@ inline int ncplane_cursor_move_yx(ncplane* n, int y, int x){
n->x = x;
}
if(y >= n->leny){
logerror(n->nc, "Target y %d exceeded length %d\n", y, n->leny);
logerror(n->nc, "Target y %d >= length %d\n", y, n->leny);
return -1;
}else if(y < 0){
if(y < -1){
@ -861,8 +861,8 @@ notcurses* notcurses_init(const notcurses_options* opts, FILE* outfp){
}
// Neither of these is supported on e.g. the "linux" virtual console.
if(!(opts->flags & NCOPTION_NO_ALTERNATE_SCREEN)){
term_verify_seq(&ret->tcache.smcup, "smcup");
term_verify_seq(&ret->tcache.rmcup, "rmcup");
terminfostr(&ret->tcache.smcup, "smcup");
terminfostr(&ret->tcache.rmcup, "rmcup");
}
ret->bottom = ret->top = ret->stdscr = NULL;
ret->loglevel = opts->loglevel;
@ -1050,7 +1050,7 @@ int ncplane_set_fg_palindex(ncplane* n, int idx){
}
n->channels |= CELL_FGDEFAULT_MASK;
n->channels |= CELL_FG_PALETTE;
n->channels &= ~(CELL_ALPHA_MASK << 32u);
channels_set_fg_alpha(&n->channels, CELL_ALPHA_OPAQUE);
n->attrword &= 0xffff00ff;
n->attrword |= (idx << 8u);
return 0;
@ -1062,7 +1062,7 @@ int ncplane_set_bg_palindex(ncplane* n, int idx){
}
n->channels |= CELL_BGDEFAULT_MASK;
n->channels |= CELL_BG_PALETTE;
n->channels &= ~CELL_ALPHA_MASK;
channels_set_bg_alpha(&n->channels, CELL_ALPHA_OPAQUE);
n->attrword &= 0xffffff00;
n->attrword |= idx;
return 0;
@ -1653,11 +1653,11 @@ int ncplane_box(ncplane* n, const cell* ul, const cell* ur,
ncplane_cursor_yx(n, &yoff, &xoff);
// must be at least 2x2, with its upper-left corner at the current cursor
if(ystop < yoff + 1){
logerror(n->nc, "Ystop (%d) insufficient for yoff (%d)\n", ystop, yoff);
logerror(n->nc, "ystop (%d) insufficient for yoff (%d)\n", ystop, yoff);
return -1;
}
if(xstop < xoff + 1){
logerror(n->nc, "Xstop (%d) insufficient for xoff (%d)\n", xstop, xoff);
logerror(n->nc, "xstop (%d) insufficient for xoff (%d)\n", xstop, xoff);
return -1;
}
ncplane_dim_yx(n, &ymax, &xmax);

12
tests/channel.cpp
View File

@ -24,12 +24,12 @@ TEST_CASE("ChannelGetAlpha") {
uint32_t channel;
int a;
} test[] = {
{ .channel = 0x00000000, .a = 0, },
{ .channel = 0x10808080, .a = 1, },
{ .channel = 0x20080808, .a = 2, },
{ .channel = 0xe0080808, .a = 2, },
{ .channel = 0x3fffffff, .a = 3, },
{ .channel = 0xffffffff, .a = 3, },
{ .channel = 0x00000000, .a = CELL_ALPHA_OPAQUE, },
{ .channel = 0x10808080, .a = CELL_ALPHA_BLEND, },
{ .channel = 0x20080808, .a = CELL_ALPHA_TRANSPARENT, },
{ .channel = 0xe0080808, .a = CELL_ALPHA_TRANSPARENT, },
{ .channel = 0x3fffffff, .a = CELL_ALPHA_HIGHCONTRAST, },
{ .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));

20
tests/rotate.cpp
View File

@ -120,7 +120,7 @@ TEST_CASE("Rotate") {
uint32_t* rgbaret = ncplane_rgba(rendered, NCBLIT_DEFAULT, 0, 0, -1, -1);
REQUIRE(rgbaret);
for(int i = 0 ; i < height * width / 2 ; ++i){
if(rgbaret[i] & CELL_BG_MASK){
if(rgbaret[i] & CELL_BG_RGB_MASK){
CHECK(rgbaret[i] == rgba[i]);
}
}
@ -132,11 +132,11 @@ TEST_CASE("Rotate") {
char* c = notcurses_at_yx(nc_, 0, x, &attrword, &channels);
REQUIRE(c);
CHECK(0 == strcmp(c, " "));
if(channels_fg(channels) & CELL_BG_MASK){
CHECK(0xffccbb == (channels_fg(channels) & CELL_BG_MASK));
if(channels_fg(channels) & CELL_BG_RGB_MASK){
CHECK(0xffccbb == channels_fg(channels));
}
if(channels_bg(channels) & CELL_BG_MASK){
CHECK(0xffccbb == (channels_bg(channels) & CELL_BG_MASK));
if(channels_bg(channels) & CELL_BG_RGB_MASK){
CHECK(0xffccbb == channels_bg(channels));
}
free(c);
}
@ -171,7 +171,7 @@ TEST_CASE("Rotate") {
uint32_t* rgbaret = ncplane_rgba(rendered, NCBLIT_DEFAULT, 0, 0, -1, -1);
REQUIRE(rgbaret);
for(int i = 0 ; i < height * width / 2 ; ++i){
if(rgbaret[i] & CELL_BG_MASK){
if(rgbaret[i] & CELL_BG_RGB_MASK){
CHECK(rgbaret[i] == rgba[i]);
}
}
@ -183,11 +183,11 @@ TEST_CASE("Rotate") {
char* c = notcurses_at_yx(nc_, 0, x, &attrword, &channels);
REQUIRE(c);
CHECK(0 == strcmp(c, " "));
if(channels_fg(channels) & CELL_BG_MASK){
CHECK(0xffccbb == (channels_fg(channels) & CELL_BG_MASK));
if(channels_fg(channels) & CELL_BG_RGB_MASK){
CHECK(0xffccbb == channels_fg(channels));
}
if(channels_bg(channels) & CELL_BG_MASK){
CHECK(0xffccbb == (channels_bg(channels) & CELL_BG_MASK));
if(channels_bg(channels) & CELL_BG_RGB_MASK){
CHECK(0xffccbb == channels_bg(channels));
}
free(c);
}