summaryrefslogtreecommitdiff
AgeCommit message (Collapse)Author
2022-05-02modules/montage: fix fragnum misuse as cpu #Vito Caputo
This was causing the snow module to scribble via montage, since snow uses per-cpu rand seeds indexed using the cpu value. I didn't dig in to see if this was a vestigial thing where fragnum once was passed as a parameter (it's also in til_fb_fragment_t.number, but probably wasn't always that way). But it's now used as a cpu idx, but since they're the same type nothing complained, they say programming is hard.
2022-05-01modules/rtv: make "compose" the default channelVito Caputo
Also shortened the durations across the board, and defaulted snow to "none". With "compose" being another meta module, and the randomized settings, this actually gives a more interesting grand tour of everything possible.
2022-05-01til_fb: add draw flags for controlling texturabilityVito Caputo
Just adds TIL_FB_DRAW_FLAG_TEXTURABLE so callers can granularly inhibit texturing if desired.
2022-05-01til_fb: introduce a fragment texture sourceVito Caputo
Idea here is to provide texture sources for obtaining pixel colors at the til_fb_put_pixel/fill drawing API, making it possible for at least overlayable modules to serve as mask/stencil operators where their drawn areas are populated by the contents of another fragment produced dynamically, potentially by other modules altogether. This commit adds a texture=modulename option to the compose module for specifying if a texture should be used when compositing, excepting and defaulting to "none" for disabling texturing. A future commit should expand this compose option to accept a potential list of modules for composing the texture in the same way as the main layers= list functions. Something this all immediately makes clear is the need for a better settings syntax, probably in the form of all module setting specifiers optionally being followed by a squence of settings, with support for escaping to handle nested situations.
2022-05-01modules/julia: randomize initial stateVito Caputo
Same as for roto and plasma...
2022-05-01modules/plasma: randomize initial state of contextsVito Caputo
As with roto, it's important to differentiate plasma instances when layered... plus it's kind of boring to always start plasma identically.
2022-05-01modules/roto: randomize roto initial stateVito Caputo
Just something quick and dirty to differentiate roto layers, plus it's kind of boring having roto always start at the same state.
2022-05-01modules/rtv: snow_module=blank is blanking, "none" for disabledVito Caputo
It's no longer necessary to specify both snow_duration=0 AND snow_module=none to disable snow, just specify snow_module=none. A future commit should really make describing the "snow_duration" setting contingent on snow_module != "none".
2022-05-01til: introduce "blank" built-in moduleVito Caputo
rtv special-cased handling a nil module to mean clear the fragment, and called this "none" But it really makes more sense for rtv to treat "none" as not doing anything at all for its snow_module - not even blanking. And it would be nice to have a consistent way to express a blank module throughout rototiller, so this introduces a concept of built-in modules accessible only via explicit lookup by name which don't get enumerated via til_get_modules(), as they're inherently uninteresting more utility-oriented modules for use by other modules. For now it's only "blank" that constitutes the built-ins list, but expanding this is only a matter of introducing more modules there. Future commits will rework rtv to use "blank" in place of its current "none", and rtv's "none" will be reworked to represent no snow mechanism at all, obviating the need to specify snow_duration=0,snow_module=none required today.
2022-05-01modules/*: make use of generic fragmentersVito Caputo
Just one case, modules/submit, was using 32x32 tiles and is now using 64x64. I don't expect it to make any difference. While here I fixed up the num_cpus/n_cpus naming inconsistencies, normalizing on n_cpus.
2022-05-01til: introduce some generic fragmenters for convenienceVito Caputo
Most of the threaded modules have settled down on two basic forms of fragmenter function: 1. a slice per cpu, where tile-oriented locality isn't useful 2. ~64x64 tiles, in scenarios where screen-space locality helps Now that n_cpus is wired up to the fragmenter, #1 can be fulfilled without requiring a module-private context plumbing n_cpus from create_context(). A future commit will replace some module-specific fragmenters by returning one of these instead as res_fragmenter in their prepare_frame(), wherever applicable.
2022-05-01til: wire n_cpus up to the fragmenter functionVito Caputo
Fragmenting is often dimensioned according to the number of cpus, and by not supplying this to the fragmenter it was made rather common for module contexts to plumb this themselves - in some cases incorporating a context type/create/destroy rigamarole for the n_cpus circuit alone. So just plumb it in libtil, and the prepare_frame functions can choose to ignore it if they have something more desirable onhand. Future commits will remove a bunch of n_cpus from module contexts in favor of this.
2022-04-29modules/rtv: except snow_module=none,snow_duration=0Vito Caputo
The code was deliberately showing a single frame of snow when snow_duration=0, since the durations are integral seconds ther was no way to have a sub 1-second snow otherwise. snow_module=none just means cleared for the snow_duration, not no snow mechanism whatsoever. So the combination of 0 duration and "none" was still flashing a single blank frame. With this commit the combination of "none" and 0 snow_duration prevents even a single frame of blank snow from being rendered.
2022-04-29modules/rtv: align all struct membersVito Caputo
cosmetic indentation fixup
2022-04-29modules/rtv: rtv_channel_t: s/settings/settings_as_arg/Vito Caputo
Mechanical rename to something less ambiguous in a world with til_settings_t, til_setting_t, and til_setup_t etc.
2022-04-29modules/voronoi: voronoi diagram moduleVito Caputo
This adds a voronoi diagram module, which when used as an overlay produces a mosaic effect. Some settings: cells=N number of voronoi cells randomize={on,off} randomizes the cell locations every frame dirty={on,off} uses a faster sloppy/dithery-looking method Some TODO items: - use a more space efficient representation of the distance buffer, maybe use uint16_t relative offsets into the cells rather than pointers - capping their quantity to 64KiB - anti-alias edges between cells
2022-04-28libs/din: lose the asserts in dotgradient()Vito Caputo
This just slows things down, and now that the code is mature enough to never trigger these asserts just get rid of them.
2022-04-28libs/din: minor optimization in clamp()Vito Caputo
short-circuit by directly returning bound when exceeded
2022-04-28libs/din: premultiply din->width * din->heightVito Caputo
dotgradient() is very hot and needs this result when indexing din->grid[]. Since it doesn't change for a given din instance, just cache the result @ din_new().
2022-04-28libs/din: minor optimizationVito Caputo
compute scaled x/y coordinates less often by reusing them
2022-04-28modules/swab: switch to tiled fragmenterVito Caputo
Quick FPS based comparisons shows this simple change gets a nearly 10% FPS boost on this particular 4-core i7 laptop.
2022-04-27modules/pixbounce: randomize pixmap sizesPhilip J Freeman
2022-04-27modules/pixbounce: add 2 new pixmapsPhilip J Freeman
2022-04-27modules/pixmap: randomize colorsPhilip J Freeman
2022-04-27til_fb: til_fb_fragment_t.{pitch,stride} uint32_t unitsVito Caputo
Originally it seemed sensible to make these units of bytes, for flexibility reasons. But it's advantageous for everything to be able to assume pixels are always 4-byte/32-bit aligned. Having the stride/pitch be in bytes of units made it theoretically possible to produce unaligned rows of pixels, which would break that assumption. I don't think anything was ever actually producing such things, and I've added some asserts to the {sdl,drm}_fb.c page acquisition code to go fatal on such pages. This change required going through all the modules and get rid of their uint32_t vs. void* dances and other such 1-byte vs. 4-byte scaling arithmetic. Code is simpler now, and probably faster in some cases. And now allows future work to just assume things cna always occur 4-bytes at a time without concern for unaligned accesses.
2022-04-27til_fb: fix til_fb_fragment_fill() memset() misuseVito Caputo
This braino wasn't actually showing itself in any output since it was always being used to fill either 0xffffffff or 0x00000000. But if an actual pixel having distinct RGB values were supplied, it wouldn't have worked right as just the low char was being written to the destination buffer's bytes. Additionally I think the til_fb_fragment_t.{pitch,stride} members should probably change to the number of pixels (uint32_t) vs. bytes. The thinking initially was to facilitate describing fragments having rows split up with arbitrary numbers of bytes. Having a constraint of requiring the pixels always be 32-bit aligned ensures dword-at-a-time optimized copies can always succeed without something like SIGBUS occurring. When such a constraint is respected, the pitch/stride will always be 32-bit aligned so they should just describe numbers of pixels. Except, one can imagine scenarios where writing bytes at a time instead of uint32_t's at a time can produce interesting color-staggerring effects, and introducing a deliberate offset in the pitch/stride making it unaligned can be interesting. I'm leaving it all alone for now, but there's already assumptions being made about doing uint32_t-grained operations on the fragment's buf. Even the til_fb_fragment_t.buf's type is a uint32_t* already, and it forces us to use a void* or char* version of the pointer to apply pitch/stride as in this commit.
2022-04-25modules/flui2d: add some gamma correctionVito Caputo
Without gamma correction the linear colors don't really pop, this helps tremendously. The gamma factor is hard-coded at 1.4 currently but may make sense as a runtime setting.
2022-04-25modules/flui2d: colorify the density fieldVito Caputo
This is a first approximation at introducing colors to flui2d, the emitter colors aren't really well tuned or anything yet.
2022-04-25modules/flui2d: introduce another emitter; "clockgrid"Vito Caputo
Inspired by my little fomo match-four game PoC, this is a similar style phased emitter grid layout producing some neat turbulent interactions. Introduces an emitters={figure8,clockgrid} setting, and when clockgrid is used, a clockstep=[.05-.99] for the radians step made from one grid cell's emitter to the next where 1=2PI.
2022-04-25modules/pixbounce: rand start pos and dirPhilip J Freeman
2022-04-25modules/swarm: use put_pixel_checked() to stop segfaultingVito Caputo
During rtv runs we'd occasionally segfault in the unchecked line drawing. This needs to be fixed, but for now just go slower.
2022-04-25doc: mention libtool dep in HACKING.txtVito Caputo
@Ph1l tripped over this after installing just build-essential
2022-04-25modules/blinds: add count and orientation settingsVito Caputo
This adds count=N and orientation={horizontal,vertical} settings. Which was precipitated by the introduction of a vertical blinds mode. e.g.: --module=blinds,count=32,orientation=vertical or for a quick tour of the possibilities: --module=rtv,channels=blinds,duration=1,context_duration=1,snow_duration=0 weeeee
2022-04-25modules/compose: implement layer setting randomizerVito Caputo
It's getting crazy in here, this is fun: --module=rtv,channels=compose,duration=1,snow_duration=0,context_duration=1 which will rejigger the commpose module w/randomized layers every second.
2022-04-25modules/*: set TIL_MODULE_OVERLAYABLE where appropriateVito Caputo
In the interests of facilitating randomized automagic layered compositing, tell the world when you're overlay-appropriate.
2022-04-25til: add til_module_t.flags and TIL_MODULE_OVERLAYABLEVito Caputo
For modules which are overlay-appropriate, they should indicate it when initializing their respective til_module_t. If they intend to participate in automagic compositing as overlays anyways.
2022-04-25doc: fix some typos/inconsistencies in HACKING.txtVito Caputo
Just some fixups after a quick review
2022-04-24*: free setup allocations via til_setup_free()Vito Caputo
This should plug a bulk of the setup leaks. Some of the free_funcs still need to be changed to bespoke ones in modules that allocate nested things in their respective setup, so those are still leaking the nested things which are usually just a small strdup of some kind.
2022-04-24til_setup: introduce til_setup_free()Vito Caputo
simple wrapper around til_setup_t.free()
2022-04-24*: s/void */til_setup_t */Vito Caputo
This brings something resembling an actual type to the private objects returrned in *res_setup. Internally libtil/rototiller wants this to be a til_setup_t, and it's up to the private users of what's returned in *res_setup to embed this appropriately and either use container_of() or casting when simply embedded at the start to go between til_setup_t and their private containing struct. Everywhere *res_setup was previously allocated using calloc() is now using til_setup_new() with a free_func, which til_setup_new() will initialize appropriately. There's still some remaining work to do with the supplied free_func in some modules, where free() isn't quite appropriate. Setup freeing isn't actually being performed yet, but this sets the foundation for that to happen in a subsequent commit that cleans up the setup leaks. Many modules use a static default setup for when no setup has been provided. In those cases, the free_func would be NULL, which til_setup_new() refuses to do. When setup freeing actually starts happening, it'll simply skip freeing when til_setup_t.free_func is NULL.
2022-04-24til_setup: add til_setup_new() helperVito Caputo
For use when setup functions allocate their private setup to return in *res_setup. They specify the size of their private setup, and supply the free function to use. This may be libc's free() when it's a simple setup struct, or a bespoke free function when deep/complex freeing is required for cleanup. It's expected that callers will be embedding til_setup_t at the start of their private setup struct, and returning a pointer to this in *res_setup which would be the same value as a pointer to to their private setup struct.
2022-04-24til_setup: introduce til_setup_tVito Caputo
Preparatory commit for providing a res_setup type to replace void*. The impetus for this isn't just pursuit of less void*, but primarily implementing setup freeing by embedding this struct into the private setup types. An alternative method of adding setup freeing would have been to introduce something like til_module_t.free_setup(). But that would require having the til_module_t on hand, and the whole setup machinery is more generalized than til_module_t anyways. This way anything can simply embed the struct in their private setup instance and return the pointer to that in *res_setup. They should always be able to find their containing struct's offset from the til_setup_t* they returned. Either by using container_of(), or simply placing it at the start of the private setup struct.
2022-04-22modules/compose: randomize layer settingsVito Caputo
Randomize the setting of the layered modules like rtv does. This needs to free the setup, similarly to the others, once that facility is added.
2022-04-22modules/montage: randomize module setupsVito Caputo
Instead of always showing defaults, randomize the setup like rtv does.
2022-04-22til: make til_module_randomize_setup() return -errnoVito Caputo
This makes the arg return optional by using a res_arg pointer, instead returning -ENOMEM when it would have returned NULL on allocation failures. This also makes it possible to detect when no setup was performed, by returning 0 in such a case. Now returns 1 when setup occurs and res pointers populated.
2022-04-22til: add til_module_randomize_setup() from rtvVito Caputo
This commit pulls the setup randomizer out of rtv into libtil proper, so other modules may make use of it. Other than adding an assert no functional changes occurred. It may make sense to split this into two functions; one which takes a til_module_t as-is, and a lower-level bare setup function callback based function that doesn't know about til_module_t the former would call into. That way generic setup randomization can occur (the same setup machinery is used in video contexts for example) without necessarily having a til_module_t on hand.
2022-04-22til: wire up modules/checkersVito Caputo
expose the checkers module to the rest of the world
2022-04-22modules/checkers: experimenting with a checkers overlayVito Caputo
This adds a checkers style overlay module, it's not terribly interesting but may be made more useful if modules start differentiating themselves as substantial vs. overlay effects. It'd be nice if rtv/compose could automagically apply and randomize overlay modules atop others, which would make use of this type of thing as well as encourage more small modules like these be written.
2022-04-22modules/montage: stop assuming modules don't fragmentVito Caputo
There's been a longstanding todo item in montage where it was ignoring the fragmenter returned by a module's prepare_frame(). This commit continues with the single-threaded rendering of the modules within their respective tiles, still ad-hoc open coded. But now actually applies the fragmenter returned as if the rendering were being threaded, since when a module returns a fragmenter from its prepare_frame() it may strongly depend on that fragmenting for its output.
2022-04-19modules/blinds: add simple 80s-aesthetic window blindsVito Caputo
This isn't super interesting but I might just start adding simplistic overlay style modules for compositing/transition use.
© All Rights Reserved