summaryrefslogtreecommitdiff
AgeCommit message (Collapse)Author
2023-11-14libs/playit: add libplayit submoduleVito Caputo
Preparatory commit for implementing an .IT file playback module
2023-11-14til: introduce til_module_t.render_audio entrypointVito Caputo
Simple audio rendering modules need a way to render their audio without affecting the fragment's state. By providing a til_module_t.render_audio() a module indicates it's only an audio renderer, and its render won't trigger an implicit clear of the frame's fragment. There might be a new flag added to indicate when modules are audio modules, but this is good enough for now.
2023-11-14til_stream: add til_audio_context_t to til_stream_tVito Caputo
Preliminary means of making the audio context available to modules.
2023-11-14til: add preliminary audio backendVito Caputo
This is an early implementation of something resembling an audio backend for rototiller/libtil. The assumption for now is that everything will use signed 16-bit native-endian stereo output @ 44.1khz.
2023-11-10build: restore -Werror to CFLAGSVito Caputo
f89689b unintentionally removed this for some reason. Just noticed a build with warnings wasn't failing...
2023-11-09sdl_fb: introduce vsync={on,off} settingVito Caputo
Defaults to on, controls inclusion of SDL_RENDERER_PRESENTVSYNC in the flags passed to SDL_CreateRenderer(). Useful for obesrving how high FPS can be with the overhead of the GPU upload, unlike --video=mem which tells you how fast FPS can be entirely headless.
2023-11-09sdl_fb: s/fullscreen_values/bool_values/Vito Caputo
Preparatory commit for a vsync setting sharing these values.
2023-11-09sdl_fb: s/flags/window_flags/Vito Caputo
Preparatory commit for introducing c->renderer_flags to allow vsync configure at runtime.
2023-11-06doc: mention YouTube development playlistVito Caputo
HACKING.txt should point readers interested in such things to the video tutorials now that there's enough content in that playlist to start being potentially useful:
2023-11-06modules/compose: handle layers/texture create failuresVito Caputo
Some trivial error handling improvements for compose... til_module_t.create_context() should really return -errno instead, since some modules try do stuff like opening files or network connections @ create_context().
2023-11-03modules/*: drop til_setup_t.free_func() NULL setup checksVito Caputo
Trivial cleanup. These are unnecessary nowadays since til_setup_free() won't invoke the free_func() on a NULL setup, and everything uses til_setup_free() to free a til_setup_t.
2023-11-02til,checkers: move checkers_rgb_to_uint32() to libtilVito Caputo
Becomes til_rgb_to_uint32(). Nothing functionally changed, just making this generally available for anything wanting to parse an rgb hex string into a uint32 packed pixel in a setup_func.
2023-10-31libs/rocket: bump submodule for new sockio supportVito Caputo
Preparatory commit for implementing nonblocking connects in modules/rkt, shouldn't change anything by itself.
2023-10-23build: tidy up some Makefile.am filesVito Caputo
Been ignoring this mess for too long, just whitespace changes - nothing functionally different. This makes diffs far easier to read when libs or modules get added/removed etc. Some of the other Makefile.am files could use similar tidying, but these are the most commonly messed with in the course of rototiller development.
2023-10-19modules/stub: add a stub sample moduleVito Caputo
Intended as a bootstrap for new module creation, particularly aimed at new contributors. No module context, fragmenting, taps, or settings are implemented, to keep things as simple as possible.
2023-10-16doc: add YouTube playlist URL to READMEVito Caputo
The playlist isn't comprehensive yet, but it's better than nothing for folks that just want to see something before spending time on figuring out how to clone, build, execute, etc.
2023-10-16modules/pixbounce: use float for multiplierVito Caputo
The lack of support for fractional multipliers prevents pixbounce from drawing anything in small frame scenarios, like as a checkers fill_module. You can easily reproduce this by doing: --module=pixbounce,pixmap_size=0.8,pixmap=err --video=sdl,size=64x64 --defaults --go Which after this commit works... While here I did a minor optimization removing some divides, and fixed up the assumption that fragment->{width,height} == fragment->frame_{width,height} in pixbounce_prepare_frame(). It should have been using .frame_{width,height}.
2023-10-11doc: minor HACKING.txt fixupVito Caputo
2023-10-11modules/compose: don't use *res_setting for textureVito Caputo
This is vestigial from pre-everything's-til_setting_t days, where the local setting values were just the bare char* value, requiring getting at the related til_setting_t via *res_setting. Now that's unnecessary since the local texture variable is now a til_setting_t*, so clean this bit up.
2023-10-11modules/blinds: uninline the per-blind functionsVito Caputo
In the pre-threaded blinds days these were tiny functions, not anymore. Plus it's not like there's very many blinds ever anyways so the number of calls isn't huge, making the syntactic sugar aspect of "inline suggests hot" a bit misleading here.
2023-10-11modules/checkers: staticify checkers_fragment_tile_single()Vito Caputo
Minor oversight when this was written, this fragmenter is private to checkers.
2023-10-04modules/asc: turn into a "built-in" moduleVito Caputo
This deviates from the established pattern of all built-in modules being in til_builtins.c, but that's ok. The main impetus for this is to just get asc out of rotation for randomized compose layers, since it's so uninteresting. But it's also valid as a built-in since it's primarily for diagnostic purposes anyways.
2023-10-03modules/asc: add justify= and [hv]offset= settingsVito Caputo
justify= now supports "aligned" and "offsetted", justify=aligned being the existing behavior where you would specify halign={left,right,center} and valign={top,bottom,center}. When justify=offsetted is specified however, {valign=,halign=} are unused and instead {hoffset=,voffset=} are expected, as either hoffset=auto/voffset=auto for automagic offsetting according to the x/y coords, or explicit offsetting using -1..+1 normalized fractional values serving as coordinates within the rendered text's rectangle where to anchor the x/y coordinate. By using halign=auto,valign=auto one can carelessly vary the x/y coordinates using the taps (i.e. via rkt) without having to deal with justification concerns (modulo large texts that can't possibly fit), as the offsets will automatically adapt according to the coordinates.
2023-10-03libs/txt: implement txt_render_fragment_offsetted() variantVito Caputo
Instead of rigid txt_align_t enums to specify how the text is aligned relative to the x/y coordinates, you specify float offsets in normalized coordinates -1..+1 allowing fine-grained control of the offsets. modules/asc will use this to automatically adjust the offsets when requested, so x/y coordinates may be varied dynamically using taps with the text automagically adjusting its offset to try stay in-fragment.
2023-10-03libs/txt,modules/*: rename txt_render_fragment()Vito Caputo
Mechanical rename to txt_render_fragment_aligned(), updating all existing call sites accordingly. This is a preparatory commit for introducing an offsetted variant of txt_render_fragment() (txt_render_fragment_offsetted()). No functional difference, purely naming changes.
2023-10-03modules/asc: tap x/y coordinatesVito Caputo
Nothing terribly exciting, the string can now be moved dynamically via taps in the usual manner. When nobody's driving the taps they just use the setting, still defaulting to 0,0 (centered).
2023-10-03 modules/flow: whitespace fixupVito Caputo
Just removing a spurious newline noticed while grabbing some taps boilerplate for asc...
2023-10-03modules/asc: implement a simple ascii text moduleVito Caputo
This just binds the simple libs/txt/txt.c stuff to a rendering module, exposing the minimal options as settings. It's handy for testing libs/txt/txt.c, and introduces a module requiring free-form strings potentially including newlines be handled properly as settings values. This latter aspect is important for improving settings syntax, any improvements must handle these more complicated scenarios and now there's a good test case for exercising those nuances. I suppose there might also be use in the creative process if you want a text element but haven't got around to hacking up a prettier module for it yet. Just use this one temporarily. See commit for some remaining TODO items.
2023-10-03libs/txt: fix width measurement without a \nVito Caputo
Silly oversight preventing some haligns from working right if the string doesn't have a newline... uncovered while testing a new txt module's alignment settings.
2023-10-02modules/checkers: adopt til_value_to_pos() helperVito Caputo
Mechanical transition from checkers_value_to_pos() to the now libtil-provided equivalent of identical implementation.
2023-10-02til: introduce til_value_to_pos() helperVito Caputo
This copies from checkers_value_to_pos() turning it into a libtil helper. It's a common operation in setup_funcs to map a setting value to a numeric position in the list of values.
2023-09-08til_builtins/blank: add force= settingVito Caputo
When using the blank builtin for profiling purposes it can be necessary to ensure it actually incurs the cost of clearing.
2023-09-07doc: add links for browsable source repo to READMEVito Caputo
2023-09-07modules/flow: add TODO blurb abot per-cpu seedsVito Caputo
Writing this down so it doesn't completely fall off my radar.
2023-09-07doc: trivial fixup to README citationsVito Caputo
fix misplaced :
2023-09-06modules/flow: fix elements overflow bugVito Caputo
s->count isn't always perfectly divisable by n_cpus, which is why ctxt->n_elements is computed from n_cpus * elements_per_cpu in the transition to threaded rendering for flow. That's all fine and dandy, but the ctxt->elements initialization loop was still using the vestigial s->count from the pre-threaded implementation. So on core counts where ctxt->n_elements was smaller than s->count, initialization scribbled. Thanks Sketch for assistance in chasing this down w/ASAN enabled on a box that exhibited crashing w/rtv,channels=flow.
2023-09-05modules/flow: fix default countVito Caputo
57bae7 removed the default from the settings list when bumping the counts, oops!
2023-09-05modules/flow: add "(threaded)" labelVito Caputo
The convention has been to label threaded modules in their description.
2023-09-05modules/flow: bump the counts up a bitVito Caputo
Now that there's threaded rendering, handling larger counts without bogging down the frame rate on anything remotely modern is feasible.
2023-09-04modules/flow: restore previous Z depthVito Caputo
While optimizing the threaded rendering in commit 6d6c141, the pos.{xy} expanding from 0-1 to -1..+1 were eliminated from the inner loops in favor of just having the positions always in -1..+1 coordinates. But I missed that it was only the x/y coordinates which were being expanded, with .z being left in the 0-1 space, which had a desirable aesthetic effect of condensing the Z space, flattening everything. This commit undoes that, without reintroducing the expansion to the inner loops. It's a bit crufty because now .z is treated exceptionally throughout as 0..1 while {.x,.y} are in -1..+1, but it's fine for now.
2023-09-04modules/flow: implement threaded renderingVito Caputo
This exploits the just added multipass rendering support. In the first pass, the flow-field is sampled and applied to the elements, with every thread operating on its own subset of the elements list. Since the flow-field sampling is all read-only, it's perfectly safe too do in parallel. Nothing is drawn in the first pass, it's only the elements updating according to the flow-field which is performed. In the second pass, the elements are rendered in parallel using the slice_per_cpu fragmenter. Since the elements are kept on a simple array, with no spatial indexing, every thread must visit every element. Since the fragmenter used divides the frame into horizontal slices, every thread needing to reject elements not overlapping its region can take some shortcuts in easily identifying elements entirely outside its region. But the whole 3d->2d projection step must still be performed for every element's current position and +n_iters final position for the frame, which does have a divide unfortunately. Nonetheless, this change improves frame rates substantially on my 2c/4t i7 X230 as benchmarked w/--video=mem,1366x768: --seed=0x64fa9508 '--module=rtv,channels=flow,duration=3,context_duration=3,caption_duration=0,log_channels=on,snow_duration=0,snow_module=none' '--video=mem,size=1366x768' rtv channel settings: 'flow,size=4,count=40000,speed=.8' FPS: 261 FPS: 265 rtv channel settings: 'flow,size=4,count=1000,speed=.9' FPS: 1153 FPS: 3204 FPS: 2934 rtv channel settings: 'flow,size=8,count=5000,speed=.9' FPS: 2923 FPS: 1634 FPS: 1592 rtv channel settings: 'flow,size=2,count=50000,speed=.4' FPS: 1006 FPS: 219 FPS: 268 rtv channel settings: 'flow,size=16,count=30000,speed=.8' FPS: 304 FPS: 350 FPS: 343 rtv channel settings: 'flow,size=16,count=30000,speed=.02' FPS: 379 FPS: 503 FPS: 472 rtv channel settings: 'flow,size=8,count=1000,speed=.16' FPS: 1393 FPS: 3822 FPS: 3876 --- Prior to this commit: --seed=0x64fa9508 '--module=rtv,channels=flow,duration=3,context_duration=3,caption_duration=0,log_channels=on,snow_duration=0,snow_module=none' '--video=mem,size=1366x768' rtv channel settings: 'flow,size=4,count=40000,speed=.8' FPS: 53 FPS: 53 rtv channel settings: 'flow,size=4,count=1000,speed=.9' FPS: 426 FPS: 1366 FPS: 1335 rtv channel settings: 'flow,size=8,count=5000,speed=.9' FPS: 1097 FPS: 368 FPS: 367 rtv channel settings: 'flow,size=2,count=50000,speed=.4' FPS: 279 FPS: 73 FPS: 74 rtv channel settings: 'flow,size=16,count=30000,speed=.8' FPS: 71 FPS: 71 FPS: 70 rtv channel settings: 'flow,size=16,count=30000,speed=.02' FPS: 136 FPS: 305 FPS: 305 rtv channel settings: 'flow,size=8,count=1000,speed=.16' FPS: 972 FPS: 2593 FPS: 2634
2023-09-04til: support multi-pass renderingVito Caputo
Modules can now use the til_module_t.finish_frame() return value to trigger re-rendering by returning 1, returning 0 finishes the frame. A smattering of til_module_t.finish_frame() implementations were largely mechanically updated to match this change by returning 0, since nothing actually uses multi-pass rendering yet. The impetus for this is experimenting with the flow module doing two passes of threaded rendering per frame. A first pass to sample the flow field and update the elements, per-cpu, but drawing nothing. Then a second pass to render the elements in a tiled manner.
2023-09-04til,til_fb: introduce a noop_per_cpu fragmenterVito Caputo
This is intended to perhaps be of use for threaded rendering that don't actually produce pixels during their render phase, but still need n_cpus fragments to dispatch the parallel work keying off the fragment.number. Such a renderer might then put its pixels on-screen serially @ finish_frame(), or maybe the rendering functions will get a return value to trigger multi-pass rendering on the same tick.
2023-09-03modules/flow: expose speed as a tapVito Caputo
Nothing too crazy here, the speed= setting still controls the speed in lieu of something driving the tap.
2023-09-03modules/strobe: trivial fixup; s/<=/</Vito Caputo
Remove strobe_update_taps() redundant assignment if already zero
2023-09-03til_utils: switch til_get_ncpus() to sysconfVito Caputo
The ad-hoc sys-based probe of cpus works fine on Linux, but it's not really preferable when Linux's sysconf supports _SC_NPROCESSORS_ONLN, and there's a chance non-Linux's will support it too. Supposedly even Emscripten supports this, and will report the number of available WebWorkers through this interface, even with pthreads emulation. I'm curious if that actually works, getting wasm builds of rototiller demos could be fun.
2023-09-03modules/flow: don't reap elements on screen-space exitVito Caputo
This is too aggressive and produces some undesirable visible artifacts on the periphery, especially for slow-moving small-size fields. In such scenarios the elements near the edges would be excessively pruned when the direction wandered off-screen, then leaving an overly sparse region when the direction inevitably wandered back. This is still an issue but it's far less prominent when only clipping to the flow field boundaries... since the FOV doesn't quite encompass the edges of the flow field. Now the elements can survive wandering a bit off-screen, and re-enter.
2023-09-03drm_fb: better handle empty modes/connectors resultsVito Caputo
Phil tripped over this when his TV powered off in the midst of playing with rototiller over hdmi output. The NULL mode/connector was being supplied as the til_setting_spec_t.preferred value throwing an assert in til_setting_desc_new(). Just detect this exception and return an error.
2023-09-03modules/voronoi: spot-fix a crash Phil reportedVito Caputo
The repro is: --seed=0x64f6820b '--module=compose,layers=blank\,pixbounce\\\,pixmap_size\\\=0.8\\\,pixmap\\\=err\,pixbounce\\\,pixmap_size\\\=0.4\\\,pixmap\\\=ignignokt,texture=voronoi\,cells\=512\,randomize\=on' '--video=mem,size=3840x2160' The major culprit seems to be the combination of high resolution, and small number of voronoi cells (cells=512), with randomize=on which exercises jumpfill every frame. The way jumpfill is implemented currently is racy by design to allow threading, and mostly works fine despite not really being how the algorithm is intended to work. The assumption has been, something like: "the seeds are already placed before the threaded phase, so the threaded jumpfill should at least find stable seed cells in the face of racing against other tiles being jumpfilled simultaneously" But it appears that assumption isn't always true, in that we won't necessarily find one of the seed cells at the start of the jumpfill when there aren't that many cells (512) compared to the area of the voronoi (3840x2160). By noticing when we've finished a tile's jumpfill with remaining unassigned cells, we can just repeat the jumpfill, with time passed, and the other tiles will have made progress on their work propagating more knowledge of where cells are... so the subsequent pass will probably leave nothing unassigned. This approach sucks, but stops the crashing. It'd also be possible to just change the way cells are looked up so there's no potential for a NULL pointer dereference, just have some uninitialized cell color which gets shown erroneously in the output. That avoids the computational cost of repeating the tile's jumpfill, and likely nobody would notice the likely single pixel of error for a single frame. I'm just doing this quick and dirty fix to prevent the crashing for now, and would like to just revisit voronoi more thoroughly with an eye towards decoupling the voronoi cost from the resolution. It's a cheap hack the way there's a distance entry per pixel, done just to simplify the implementation when I slapped it together on a Zephyr train ride.
2023-09-03doc: minor HACKING.txt fixupsVito Caputo
© All Rights Reserved