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

actually finished loopback modems

Browse Source
This commit is contained in:
IonutParau
2025-07-20 17:26:05 +02:00
parent 2cd485b355
commit b30a180c90
5 changed files with 129 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/components/gpu.c
View File

@@ -431,6 +431,10 @@ void nni_gpu_maxDepth(nni_gpu *gpu, void *_, nn_component *component, nn_compute
nn_return(computer, nn_values_integer(gpu->currentScreen->maxDepth));
}
void nni_gpu_useless(nni_gpu *gpu, void *_, nn_component *component, nn_computer *computer) {
nn_return_boolean(computer, true);
}
void nn_loadGraphicsCardTable(nn_universe *universe) {
nn_componentTable *gpuTable = nn_newComponentTable(nn_getAllocator(universe), "gpu", NULL, NULL, (nn_componentDestructor *)nni_gpuDeinit);
nn_storeUserdata(universe, "NN:GPU", gpuTable);
@@ -456,6 +460,8 @@ void nn_loadGraphicsCardTable(nn_universe *universe) {
nn_defineMethod(gpuTable, "fill", (nn_componentMethod *)nni_gpu_fill, "fill(x: integer, y: integer, w: integer, h: integer, s: string)");
nn_defineMethod(gpuTable, "copy", (nn_componentMethod *)nni_gpu_copy, "copy(x: integer, y: integer, w: integer, h: integer, tx: integer, ty: integer) - Copies stuff");
nn_defineMethod(gpuTable, "getViewport", (nn_componentMethod *)nni_gpu_getViewport, "getViewport(): integer, integer - Gets the current viewport resolution");
nn_defineMethod(gpuTable, "freeAllBuffers", (nn_componentMethod *)nni_gpu_useless, "dummy for now");
}
nn_component *nn_addGPU(nn_computer *computer, nn_address address, int slot, nn_gpuControl *control) {

25
src/components/loopbackModem.c
View File

@@ -86,6 +86,26 @@ nn_bool_t nn_loopModem_send(nn_modemLoop *loop, nn_address address, nn_size_t po
return true;
}
double nn_loopModem_getStrength(nn_modemLoop *loop, nn_errorbuf_t err) {
return loop->strength;
}
double nn_loopModem_setStrength(nn_modemLoop *loop, double n, nn_errorbuf_t err) {
loop->strength = n;
return n;
}
nn_size_t nn_loopModem_getWakeMessage(nn_modemLoop *loop, char *msg, nn_errorbuf_t err) {
nn_memcpy(msg, loop->wakeup, loop->wakeupLen);
return loop->wakeupLen;
}
nn_size_t nn_loopModem_setWakeMessage(nn_modemLoop *loop, const char *msg, nn_size_t msglen, nn_bool_t fuzzy, nn_errorbuf_t err) {
loop->wakeupLen = msglen;
nn_memcpy(loop->wakeup, msg, loop->wakeupLen);
return loop->wakeupLen;
}
nn_modem *nn_debugLoopbackModem(nn_Context *context, nn_debugLoopbackNetworkOpts opts, nn_networkControl control) {
opts.address = nn_strdup(&context->allocator, opts.address);
nn_modemLoop *m = nn_alloc(&context->allocator, sizeof(nn_modemLoop));
@@ -114,6 +134,11 @@ nn_modem *nn_debugLoopbackModem(nn_Context *context, nn_debugLoopbackNetworkOpts
.send = (void *)nn_loopModem_send,
.maxStrength = opts.maxStrength,
.getStrength = (void *)nn_loopModem_getStrength,
.setStrength = (void *)nn_loopModem_setStrength,
.setWakeMessage = (void *)nn_loopModem_setWakeMessage,
.getWakeMessage = (void *)nn_loopModem_getWakeMessage,
};
return nn_newModem(context, table, control);
}

92
src/components/modem.c
View File

@@ -65,7 +65,42 @@ static nn_bool_t nni_modem_wirelessOnly(nn_modem *modem, void *_) {
}
static void nni_modem_maxStrength(nn_modem *modem, void *_, nn_component *component, nn_computer *computer) {
nn_return_integer(computer, modem->table.maxStrength);
nn_return_number(computer, modem->table.maxStrength);
}
static void nni_modem_getStrength(nn_modem *modem, void *_, nn_component *component, nn_computer *computer) {
nn_errorbuf_t err = "";
nn_lock(&modem->ctx, modem->lock);
double n = modem->table.getStrength(modem->table.userdata, err);
nn_unlock(&modem->ctx, modem->lock);
if(!nn_error_isEmpty(err)) {
nn_setError(computer, err);
return;
}
nn_return_number(computer, n);
}
static void nni_modem_setStrength(nn_modem *modem, void *_, nn_component *component, nn_computer *computer) {
double n = nn_toNumber(nn_getArgument(computer, 0));
if(n < 0) n = 0;
if(n > modem->table.maxStrength) n = modem->table.maxStrength;
nn_errorbuf_t err = "";
nn_lock(&modem->ctx, modem->lock);
n = modem->table.setStrength(modem->table.userdata, n, err);
nn_unlock(&modem->ctx, modem->lock);
if(!nn_error_isEmpty(err)) {
nn_setError(computer, err);
return;
}
nn_return_number(computer, n);
}
static nn_bool_t nni_modem_validSendPort(nn_intptr_t port) {
@@ -216,6 +251,51 @@ static void nni_modem_broadcast(nn_modem *modem, void *_, nn_component *componen
nn_return_boolean(computer, res);
}
static void nni_modem_getWake(nn_modem *modem, void *_, nn_component *component, nn_computer *computer) {
char msg[NN_MAX_WAKEUPMSG];
nn_errorbuf_t err = "";
nn_lock(&modem->ctx, modem->lock);
nn_size_t len = modem->table.getWakeMessage(modem->table.userdata, msg, err);
nn_unlock(&modem->ctx, modem->lock);
if(!nn_error_isEmpty(err)) {
nn_setError(computer, err);
return;
}
nn_return_string(computer, msg, len);
}
static void nni_modem_setWake(nn_modem *modem, void *_, nn_component *component, nn_computer *computer) {
nn_size_t buflen;
const char *buf = nn_toString(nn_getArgument(computer, 0), &buflen);
if(buf == NULL) {
nn_setCError(computer, "invalid wake message");
return;
}
if(buflen > NN_MAX_WAKEUPMSG) {
buflen = NN_MAX_WAKEUPMSG;
}
nn_bool_t fuzzy = nn_toBoolean(nn_getArgument(computer, 1)); // nil is false
nn_errorbuf_t err = "";
nn_lock(&modem->ctx, modem->lock);
buflen = modem->table.setWakeMessage(modem->table.userdata, buf, buflen, fuzzy, err);
nn_unlock(&modem->ctx, modem->lock);
if(!nn_error_isEmpty(err)) {
nn_setError(computer, err);
return;
}
nn_return_string(computer, buf, buflen);
}
void nn_loadModemTable(nn_universe *universe) {
nn_componentTable *modemTable = nn_newComponentTable(nn_getAllocator(universe), "modem", NULL, NULL, (nn_componentDestructor *)nn_modem_destroy);
nn_storeUserdata(universe, "NN:MODEM", modemTable);
@@ -231,9 +311,17 @@ void nn_loadModemTable(nn_universe *universe) {
nn_defineMethod(modemTable, "getPorts", (nn_componentMethod *)nni_modem_getPorts, "close([port: integer]): boolean - Closes a port, or nil for all ports");
nn_defineMethod(modemTable, "send", (nn_componentMethod *)nni_modem_send, "send(address: string, port: integer, ...): boolean - Sends a message to the specified address at the given port. It returns whether the message was sent, not received");
nn_defineMethod(modemTable, "broadcast", (nn_componentMethod *)nni_modem_broadcast, "broadcast(port: integer, ...): boolean - Broadcasts a message at the given port. It returns whether the message was sent, not received");
nn_defineMethod(modemTable, "setWakeMessage", (nn_componentMethod *)nni_modem_setWake, "setWakeMessage(msg: string[, fuzzy: boolean]): string - Sets the wake-up message. This will be compared with the first value of modem messages to turn on computers. Set it to nothing to disable this functionality.");
nn_defineMethod(modemTable, "getWakeMessage", (nn_componentMethod *)nni_modem_getWake, "getWakeMessage(): string - Returns the current wake-up message");
// wireless stuff
method = nn_defineMethod(modemTable, "maxStrength", (nn_componentMethod *)nni_modem_maxStrength, "maxStrength(): integer - Returns the maximum strength of the device");
method = nn_defineMethod(modemTable, "maxStrength", (nn_componentMethod *)nni_modem_maxStrength, "maxStrength(): number - Returns the maximum strength of the device");
nn_method_setCondition(method, (nn_componentMethodCondition_t *)nni_modem_wirelessOnly);
method = nn_defineMethod(modemTable, "getStrength", (nn_componentMethod *)nni_modem_getStrength, "getStrength(): number - Returns the current strength of the device");
nn_method_setCondition(method, (nn_componentMethodCondition_t *)nni_modem_wirelessOnly);
method = nn_defineMethod(modemTable, "setStrength", (nn_componentMethod *)nni_modem_setStrength, "setStrength(value: number): number - Returns the current strength of the device");
nn_method_setCondition(method, (nn_componentMethodCondition_t *)nni_modem_wirelessOnly);
}