NeoFlock/neonucleus
9
1
Fork 0
Code Issues Packages Projects Releases Wiki Activity

screen brightness

Browse Source
This commit is contained in:
IonutParau
2026-04-11 15:51:26 +02:00
parent 37e5ce0167
commit a5e30abf36
4 changed files with 97 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
src/main.c
View File

@@ -46,10 +46,22 @@ static nn_Exit sandbox_handler(nn_ComponentRequest *req) {
return NN_OK;
}
Color ne_processColor(unsigned int color) {
static unsigned char ne_processColorPart(unsigned char channel, double brightness) {
double n = (double)channel / 255;
n *= brightness;
if(n < 0) n = 0;
if(n > 1) n = 1;
return n * 255;
}
Color ne_processColor(unsigned int color, double brightness) {
color <<= 8;
color |= 0xFF;
return GetColor(color);
Color c = GetColor(color);
c.r = ne_processColorPart(c.r, brightness);
c.g = ne_processColorPart(c.g, brightness);
c.b = ne_processColorPart(c.b, brightness);
return c;
}
int keycode_to_oc(int keycode) {
@@ -447,15 +459,6 @@ int main(int argc, char **argv) {
ncl_ScreenState *scrstate = nn_getComponentState(screen);
ncl_mountKeyboard(scrstate, "mainKB");
{
// draw test
const char *s = "hello there";
for(size_t i = 0; s[i]; i++) {
unsigned char c = s[i];
ncl_ScreenState *scrstate = nn_getComponentState(screen);
ncl_setScreenPixel(scrstate, i+1, 1, c, 0xFFFFFF, 0x000000, false, false);
}
}
nn_Computer *c = nn_createComputer(u, NULL, "computer0", ramTotal, 256, 256);
nn_Component *wrappedC = nn_wrapComputer(c);
@@ -512,6 +515,7 @@ int main(int argc, char **argv) {
int offX = (GetScreenWidth() - cwidth * scrw) / 2;
int offY = (GetScreenHeight() - cheight * scrh) / 2;
double scrbright = ncl_getScreenBrightness(scrbuf);
for(int y = 1; y <= scrh; y++) {
for(int x = 1; x <= scrw; x++) {
ncl_Pixel p = ncl_getScreenPixel(scrbuf, x, y);
@@ -520,9 +524,9 @@ int main(int argc, char **argv) {
offY + (y - 1) * cheight,
};
ncl_needGlyph(gc, p.codepoint);
DrawRectangle(pos.x, pos.y, cwidth, cheight, ne_processColor(p.bgColor));
DrawRectangle(pos.x, pos.y, cwidth, cheight, ne_processColor(p.bgColor, scrbright));
if(p.codepoint != 0) {
ncl_drawGlyph(gc, p.codepoint, pos, cheight, ne_processColor(p.fgColor));
ncl_drawGlyph(gc, p.codepoint, pos, cheight, ne_processColor(p.fgColor, scrbright));
}
}
}
@@ -530,7 +534,7 @@ int main(int argc, char **argv) {
ncl_unlockScreen(scrbuf);
ncl_flushGlyphs(gc);
}
skipDrawScreen:
skipDrawScreen:;
int statY = 10;
if(sand.buf != NULL) {

12
src/ncomplib.c
View File

@@ -2232,6 +2232,18 @@ static nn_Exit ncl_screenHandler(nn_ScreenRequest *req) {
nn_unlock(ctx, st->lock);
return NN_OK;
}
if(req->action == NN_SCREEN_GETBRIGHT) {
nn_lock(ctx, st->lock);
req->brightness = st->brightness;
nn_unlock(ctx, st->lock);
return NN_OK;
}
if(req->action == NN_SCREEN_SETBRIGHT) {
nn_lock(ctx, st->lock);
st->brightness = req->brightness;
nn_unlock(ctx, st->lock);
return NN_OK;
}
if(C) nn_setError(C, "ncl-screen: bad action");
return NN_EBADCALL;

42
src/neonucleus.c
View File

@@ -2695,6 +2695,8 @@ const nn_ScreenConfig nn_defaultScreens[4] = {
.editableColors = 0,
.features = NN_SCRF_NONE,
.energyPerPixel = 0.05,
.minBrightness = 0.5,
.maxBrightness = 1,
},
NN_INIT(nn_ScreenConfig) {
.maxWidth = 80,
@@ -2705,6 +2707,8 @@ const nn_ScreenConfig nn_defaultScreens[4] = {
.editableColors = 0,
.features = NN_SCRF_MOUSE | NN_SCRF_TOUCHINVERTED,
.energyPerPixel = 0.05,
.minBrightness = 0.25,
.maxBrightness = 1.2,
},
NN_INIT(nn_ScreenConfig) {
.maxWidth = 160,
@@ -2715,6 +2719,8 @@ const nn_ScreenConfig nn_defaultScreens[4] = {
.editableColors = 16,
.features = NN_SCRF_MOUSE | NN_SCRF_TOUCHINVERTED | NN_SCRF_PRECISE | NN_SCRF_EDITABLECOLORS,
.energyPerPixel = 0.05,
.minBrightness = 0.1,
.maxBrightness = 1.5,
},
NN_INIT(nn_ScreenConfig) {
.maxWidth = 240,
@@ -2725,6 +2731,8 @@ const nn_ScreenConfig nn_defaultScreens[4] = {
.editableColors = 256,
.features = NN_SCRF_NONE | NN_SCRF_EDITABLECOLORS,
.energyPerPixel = 0.05,
.minBrightness = 0.1,
.maxBrightness = 2,
},
};
@@ -4760,6 +4768,11 @@ typedef enum nn_ScreenNum {
NN_SCRNUM_ISPRECISE,
NN_SCRNUM_SETTOUCHINVERTED,
NN_SCRNUM_ISTOUCHINVERTED,
NN_SCRNUM_MINBRIGHTNESS,
NN_SCRNUM_MAXBRIGHTNESS,
NN_SCRNUM_SETBRIGHTNESS,
NN_SCRNUM_GETBRIGHTNESS,
NN_SCRNUM_COUNT,
} nn_ScreenNum;
@@ -4891,6 +4904,31 @@ static nn_Exit nn_screenHandler(nn_ComponentRequest *req) {
req->returnCount = 1;
return nn_pushbool(C, s.flag);
}
if(m == NN_SCRNUM_MINBRIGHTNESS) {
req->returnCount = 1;
return nn_pushinteger(C, cls->scrconf.minBrightness * 100);
}
if(m == NN_SCRNUM_MAXBRIGHTNESS) {
req->returnCount = 1;
return nn_pushinteger(C, cls->scrconf.maxBrightness * 100);
}
if(m == NN_SCRNUM_GETBRIGHTNESS) {
s.action = NN_SCREEN_GETBRIGHT;
e = cls->handler(&s);
if(e) return e;
req->returnCount = 1;
return nn_pushnumber(C, s.brightness * 100);
}
if(m == NN_SCRNUM_SETBRIGHTNESS) {
if(nn_checknumber(C, 0, "bad argument #1 (number expected)")) return NN_EBADCALL;
s.action = NN_SCREEN_SETBRIGHT;
s.brightness = nn_tonumber(C, 0) / 100;
if(s.brightness < cls->scrconf.minBrightness) s.brightness = cls->scrconf.minBrightness;
if(s.brightness > cls->scrconf.maxBrightness) s.brightness = cls->scrconf.maxBrightness;
e = cls->handler(&s);
if(e) return e;
return nn_pushnumber(C, s.brightness * 100);
}
nn_setError(C, "screen: not implemented");
return NN_EBADCALL;
@@ -4943,6 +4981,10 @@ nn_Component *nn_createScreen(
"isTouchModeInverted",
"function(): boolean - Returns whether inverse touch mode is enabled",
NN_DIRECT},
[NN_SCRNUM_MINBRIGHTNESS] = {"minBrightness", "function(): number - Returns the minimum brightness", NN_DIRECT},
[NN_SCRNUM_MAXBRIGHTNESS] = {"maxBrightness", "function(): number - Returns the maximum brightness", NN_DIRECT},
[NN_SCRNUM_GETBRIGHTNESS] = {"getBrightness", "function(): number - Returns the current brightness", NN_DIRECT},
[NN_SCRNUM_SETBRIGHTNESS] = {"setBrightness", "function(brightness: number): number - Sets the brightness, returns the new one", NN_DIRECT},
};
nn_Exit e = nn_setComponentMethodsArray(

25
src/neonucleus.h
View File

@@ -420,6 +420,20 @@ void nn_forceCrashComputer(nn_Computer *computer, const char *s);
// returns whether an architecture state is present
bool nn_isComputerOn(nn_Computer *computer);
typedef enum nn_ComputerEvent {
// when powered on
NN_COMPUTER_POWERON,
// when powered off
NN_COMPUTER_POWEROFF,
// when force-crashed
NN_COMPUTER_FORCECRASH,
// when crashed
NN_COMPUTER_CRASH,
} nn_ComputerEvent;
typedef void nn_ComputerListener(nn_Computer *computer, nn_ComputerEvent event);
void nn_setComputerListener(nn_Computer *computer, nn_ComputerListener *listener);
typedef struct nn_Beep {
double frequency;
double duration;
@@ -1356,6 +1370,12 @@ typedef struct nn_ScreenConfig {
// Scaled to mathc luminance of each pixel.
// This is meant to be per Minecraft tick, so 20 times per second.
double energyPerPixel;
// minimum brightness. Default brightness is always 100%
// The value here is meant to be scaled such that 1 means 100% brightness
double minBrightness;
// maximum brightness. Note that brightness rendering is emulator-specific
// The value here is meant to be scaled such that 1 means 100% brightness
double maxBrightness;
} nn_ScreenConfig;
// OC has 3 tiers, NN adds a 4th one as well.
@@ -1526,6 +1546,10 @@ typedef enum nn_ScreenAction {
NN_SCREEN_ISPRECISE,
NN_SCREEN_SETTOUCHINVERTED,
NN_SCREEN_ISTOUCHINVERTED,
// sets the brightness (from 0 to 1)
NN_SCREEN_SETBRIGHT,
// get the brightness (from 0 to 1)
NN_SCREEN_GETBRIGHT,
} nn_ScreenAction;
typedef struct nn_ScreenRequest {
@@ -1550,6 +1574,7 @@ typedef struct nn_ScreenRequest {
// setPrecise / isPrecise /
// setTouchModeInverted / isTouchModeInverted
bool flag;
double brightness;
};
} nn_ScreenRequest;