@maxicode

you’re probably wondering why the first devlog of this project is so long. it’s because i spent far too long wrangling typescript+cloudflare workers+openapi+dart+flutter into submission, not helped by the fact that i’ve never used flutter (oops). anyways i finally finished an initial api design for dynamic data definition and scouting reports. i also made form and competition editing menus in flutter, including a custom timezone picker that also took far too long :(.

i added pako fingerprint detection

turns out webpack arbitrarily decided to inline 1 threejs class into polytrack’s custom wrapper module???? i’m pretty sure the only way to account for this is by splicing out three.js at the declaration-level using a cross-module control flow graph so i’m now working on the necessary refactorings for that

as seen below, i basically need to fingerprint every single variable/function/class declaration across every module, instead of only checking exports of each

i re-refactored everything again and did a bunch more testing. turns out some three.js modules were being missed due to terser’s peephole optimizations on template expressions and string concatenation :(

the three.js detector can now fingerprint and detect the majority of three.js modules! still, many of the fingerprints don’t have enough entropy or got mangled by webpack/terser, so it doesn’t completely work.

as it turns out, the bundle still had a lot of undiscovered media files that needed new scanning infrastructure to detect. however, after that was written, i was able to get asset linking and js-sha version extraction working. unfortunately fingerprinting Three.js’s hundreds of modules down to a precise version is very hard so that is still not done.

full bundle->cjs->esm works now! some modules are dynamically loaded from other chunk files because Polytrack’s author enabled source splitting, so i restructured the driver code to support multi-bundle recursive module/chunk loading. also, i originally had the converter unwrap umd wrappers, but i realized that’s completely pointless because the entire module will get spliced out by npm detection, so it just marks such modules as “complex.” unbundling wise, the only thing left to write is npm package detection.

loader detection works now! i had to rewrite the entire unpacking library with custom semantic AST traversal to keep everything zero-copy without unsafe blocks

module splicing works now, so the webpack unbundler is able split the bundle into multiple commonjs chunks in <0.1s! next is to add webpack helper inlining, webpack loader detection (for non-js assets), and cjs->esm conversion.

static JS analysis is hard to do so all you get is a screenshot of code :(

i took a dump of Polytrack’s code and found that it is distributed in webpack bundles. so, i’m currently working on a rust script that uses oxc to parse an AST, simplify the bundle, and then split it into separate linked files.

hooray! roblox doesn’t complain any more!

headless blender kinda works now, but the normals are broken in a different way?! the converter now streams in keyword data and imports it to blender via wavefront, while applying a decimate + data transfer + solidify LoD pipeline, except the solidify breaks baked normals??

small problem: Roblox really really really doesn’t like me trying to import a >200,000 tri mesh, so i had to add a decimation step to the mesher. i tried multiple open source algorithms for decimation, but none of them were able to preserve enough fidelity, and others completely broke (see the attached screenshot). plan B is to write a headless blender driver to do the decimation for me :(

yes, i’m going to use roblox

why? putting microtransactions in a menial game sounds really funny to me

no, i have absolutely zero clue about:

1. why all the shelled face normals are inside out
2. why none of my material properties carried over
3. how the heck i’m supposed to record piece offsets after the roblox importer ignored all of the explicit mesh origins

materials work now! the material type (steel, plastic, etc.) is automatically detected from the plasticity of each part because LS-DYNA doesn’t encode material names. also, i had to switch to manual gLTF generation to add the material properties and joint metadata.

however, when i was adding the joint detection, i found that inter-part constraints may constrain an arbitrary number of nodes in arbitrary locations, which makes it impossible to map the entire assembly of parts to specific screws in a way that makes sense for a game. instead, i think i’m going to use an absolute grid system for part placement, and just take the part positioning for granted

the LS-DYNA keyword convert is almost done after writing an algorithm to offset & thicken *ELEMENT_SHELL to the correct thickness! i just need to implement material and mate copying!

yay! all of the geometry exports cleanly now, and in one assembly file! to implement this, i first process each part by fixing broken geometry, triangulating quads/n-gons, and merging its 1000’s of finite elements/shells into one manifold. then, i insert the mesh into a glTF scene at the correct location, and it works!

i had this incredibly funny idea for a puzzle game: all of the parts for a car/computer/(other complex mechanical assembly) are dumped in front of the player, who must assemble [that thing] from scratch.

i searched online for high-fidelity full-assembly CAD of a car. i eventually found GMU CCSA’s public library of scanned cars (with internals!). unfortunately, all of the files use a weird ahh format called LS-DYNA that’s typically used for finite element analysis. obviously the only logical solution is to reverse engineer the file format because too bad it lacks basically any documentation :(.

so far i’ve figured out how to export individual parts, so long as the part consists exclusively of non-degenerate hexahedrons