Example #167, and the very first example showing basic usage of the new https://thi.ng/geom-webgl interop package (still unreleased): Parsing a SVG path, sampling it with uniform vertex density (configurable), converting it into a complex polygon (w/ holes) and then into WebGL buffers (w/ vertex color option enabled), randomizing colors via probabilistic color theme, and — finally — drawing it all...
Testing/debugging the dynamic tessellation feature of the upcoming thi.ng/geom-webgl interop package... This will provide a single polymorphic function to convert https://thi.ng/geom shapes into WebGL binary data & model/attribute specs, with lots of options for memory layout, indexing, instancing and other advanced usage...
By default (and as shown here), polygons are tessellated via ear cutting[1], but users have a choice of 9 other algorithm presets (or their own custom ones), incl. iterative application of multiple tessellation strategies..
As part of the work on the upcoming thi.ng/geom-webgl package, today I've also been completely rewriting all tessellators in https://thi.ng/geom-tessellate and extending the package with more features, incl. an adapted version of https://github.com/mapbox/earcut to handle complex polygons (with holes, but can also be combined/nested with all the other tessellators, incl. the non-triangular ones)...
Instead of producing an array of faces (each itself an vertex array), all tessellators are now producing/populating/adding to a single tessellation, consisting of a vertex array and another array of face vertex IDs. This makes the result much more flexible for a number of use cases, incl. WebGL/WebGPU conversion.
Very happy with how the new API for both packages is turning out. The last image shows the source code for generating a single frame of the "SB" anim, starting with parsing two SVG paths, grouping & fitting them into a target bounding rect, then tessellating the entire group, rebuilding a new group from the resulting triangles, and finally serializing everything to SVG. For WebGL, there'll be a single asWebGLModel() function which performs shape tessellation automatically behind the scenes (fully configurable, though)...
Added a convolution kernel filtering operator for polygons/polylines to https://thi.ng/geom, incl. some useful preset kernels: box filter, triangle, gaussian, all with configurable size...
The image shows effects of various kernel sizes & iterations. Unlike with subdivision smoothing, here each version has the exact same number of vertices, only their positions are impacted: orange = box, magenta = triangle, blue = gaussian
(For now the operator is only implemented for polygons (also w/ holes) & polylines, but can be extended to other shape types...)
🦾 Functional TypeScript #1: Algebraic Data Types | Injuly
"In functional programming, algebraic types are so ubiquitous that you would be hard pressed to find a language that doesn't support them. Strangely though, nothing about them demands that a language be functional by paradigm. That imperative languages have avoided ADTs for decades seems almost an accident."
Useful snippet for computing pixel dimensions from paper sizes (both metric (DIN) and (US) imperial presets included) using https://thi.ng/units, an elaborate & powerful unit converter/calculator/DSL for all SI dimensions:
@nclslbrn Yeah, it's one of the more unknown packages in the collection, but I'm finding myself using it much more often than I thought I would initially... :)
Still only on a feature branch, but over the past few days I've been working on updating https://thi.ng/geom to add support for polygons with holes and paths with holes (or more generally support for sub-paths, e.g. multiple curves). Since both of these shape types are containers of multiple geometries and therefore require in some situations (e.g. shape conversions) different handling than the other shapes with a single boundary/geometry, adding support for these also includes updating a dozen or so polymorphic shape operators/functions and unfortunately will involve a few of breaking changes. For instance, some of these functions are returning an array of shapes now, instead of just a single one. Also related, some of the other geom support packages (e.g. https://thi.ng/geom-axidraw, https://thi.ng/geom-sdf) will have to be refactored more and partially have been already (likely only internally, though)...
As part of this work, I've also just added example #160(!!!) to demonstrate & test out some of this new functionality:
Extension.js: a plug-and-play, zero-config, cross-browser extension development tool with built-in support for #TypeScript, #WebAssembly, React, and modern #JavaScript.
Async/await in #TypeScript is essentially “direct style”. It will be interesting to see if Effect, a monadic effect system, will take off, as a case study for #Kotlin & #Scala — although for “direct style”, these have the advantage of context parameters.
@Profpatsch Oof, pass. I got really stoked around typescript for a little while, but they stopped maintaining the spec, and these days I greatly prefer #Purescript if I have to target a browser and have a choice. (It doesn't have a spec either, but I find it a much nicer language.)
At work, we still just do JS, but that's because it's likely to come out of a julius splice from #Yesod.
My short yak shaving journey is over. Lacking a decent logging library, so I created #LogTape and started logging in #Fedify using it, which should make inbox/outbox debugging easier starting with Fedify 0.7.0. ✌️
Hey, #typescript devs: is there any way to compile typescript without needing NPM and Node?
Microsoft’s documentation says the easiest way to install tcl is by using NPM. That means they aren’t saying it’s the only way. But it also lacks mention of other ways.
I’m not adverse to building tcl myself if needed, or use different methods for different operating systems.
For @made and others who might have questions about the new https://thi.ng/transducers-async library, I've tried to illuminate the behind-the-scenes approach over here:
@louisrcouture typescript is fine as long as I can //@ts it. It's the people who insist that everyone use it that get on my nerves. the extensions you use in your IDE are between you and your god. Don't foist a transpiler on your teammates just to do some fancy linting.
What am I doing this weekend? Learning #TypeScript, #Deno, and @hongminhee's #Fedify all at the same time, for a project which I'm hoping will be used by many people.
Earlier today[1], helped my son with a raycasting issue and then ended up updating/extending the 2D shape intersection function in https://thi.ng/geom, which now also supports ray intersections with nested shape groups/hierarchies (via same single function call) and a new option to return all intersection points found (rather than just the first/closest). Both of these features are shown in a new example project (forthcoming) and in the anim below...
New approach—Typia. https://typia.io/docs/setup/
– Compile static type to (runtime) validation code.
– Downside: Tools don’t work that strip out types and run result.
Rust does latter approach well. For TS, I prefer former.
@reconbot I have tried Valibot in the past and it was a pain to write, it very quickly turns into a parentheses hell and Prettier doesn't help it... chaining is a lot more convenient :sad_dog:
That said though, I have honestly completely gave up on those libraries, because they are either pain to set up, or like Zod, completely tank TypeScript's performance doing black magic with types. Perhaps things weren't meant to be strictly validated and writing a custom validator is enough.
I'm trying the whole "lets blog" thing that seems to be in vogue now to get better at writing things longer than a single reddit comment. Open to feedback (be kind 🥺) on my writing :)
@schizanon
Not at all. In computing, however, types are not subjective. JavaScript won't let you add items to an int. Or do math with an Object. You have types. It's just "someone else's problem" to figure out which type it is.
