From 3afa26fb20ed0ce140b7a98fdaf22400eb8607ef Mon Sep 17 00:00:00 2001 From: Chris Hodapp Date: Mon, 26 Jul 2021 16:47:38 -0400 Subject: [PATCH] Add some scratch work for writing --- README.md | 13 ++++++++- draft.org | 79 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 91 insertions(+), 1 deletion(-) create mode 100644 draft.org diff --git a/README.md b/README.md index 0434f02..022c337 100644 --- a/README.md +++ b/README.md @@ -24,10 +24,21 @@ high-level goal, but almost completely unrelated in their descent. and found a section I'd ignored on the difficulties of producing good meshes from isosurfaces for the sake of rendering. I kept the code around because I figured it would be useful to refer to - later, particularly for the integration with Blender. + later, particularly for the integration with Blender - but + otherwise shelved this effort. - `blender_scraps` contains some scraps of Python code meant to be used inside of Blender's Python scripting - and it contains some conversions from another project, Prosha, for procedural mesh generation in Rust (itself based on learnings from `python_extrude_meshgen`). These examples were proof-of-concept of generating meshes as control cages rather than as "final" meshes. + +It would probably make sense to rename this repo to something with +`procedural` in the name rather than `automata` since at some point it +ceased to have much to do with automata. + +## Projects not covered here + +- curl-noise work (both in Clojure and in Python/vispy) +- parallel transport +- prosha, of course diff --git a/draft.org b/draft.org new file mode 100644 index 0000000..2f1e970 --- /dev/null +++ b/draft.org @@ -0,0 +1,79 @@ + +* Brief history? + - I've done different forms of procedural graphics for awhile... + - POV-Ray is where I learned about implicit surfaces and some other + kinds of parametric geometry. + - At some point I discovered Context Free and Structure Synth. + (and synthopia blog and sphere tracing). + - I sort of pursued these as separate paths: implicit surfaces + (great for rendering methods like sphere tracing), and parametric + geometry (much easier to implement). + - It wasn't until about 2018 that I sketched out some ideas for + parametric 3D geometry - based loosely around Structure Synth - + and implemented some things. + - First this was some exploration of Parallel Frame Transport that + I'd read about via thi.ng, and then python_extrude_meshgen. + - Things I learned there become Prosha. + - Things I learned *there* are at my current unnamed work. + +* Brief history, written out more + + (TODO: a note to me, reading later: you don't need to give your + entire life story here.) + + Context Free is one of my favorite projects since I discovered it + about 2010. It's one I've written about before (TODO: link to my + posts), played around in (TODO: link to images), presented on, as + well as re-implemented myself in different ways (TODO: link to + contextual). That is sometimes because I wanted to do something + different, such as make it realtime and interactive, and sometimes + because implementing its system of recursive grammars and + replacement rules can be an excellent way to learn things in a new + language. + + I've also played around in 3D graphics, particularly raytracing, + since about 1999 in PolyRay and POV-Ray. POV-Ray is probably what + led me to learn about things like implicit surfaces, parametric + surfaces, and procedural geometry - its scene language is full of + constructs for that. Naturally, this led me to wonder how I might + extend Context Free's model to work more generally with 3D geometry. + + [[http://structuresynth.sourceforge.net/index.php][Structure Synth]] of course already exists (thank you to Mikael + Hvidtfeldt Christensen's blog [[http://blog.hvidtfeldts.net/][Syntopia]], another of my favorite + things ever), and so does [[https://kronpano.github.io/BrowserSynth/][BrowserSynth]], and they're excellent tools + that are straightforward generalizations of Context Free to 3D. + However, at some point I realized they weren't exactly what I + wanted. These tools let you combine together 3D primitives to build + up a more complex scene - but they don't properly handle any sort of + *joining* of these primitives in a way that respects many of the + 'rules' of geometry that are necessary for a lot of tools, like + having a well-defined inside/outside, not being self-intersecting, + being manifold, and so forth. + + Tools like [[https://openscad.org/][OpenSCAD]], based on [[https://www.cgal.org/][CGAL]], handle the details of this, and + I suspect that [[https://www.opencascade.com/][Open CASCADE]] (thus [[https://www.freecadweb.org/][FreeCAD]]) also does. In CAD work, + it's crucial. I experimented with similar recursive systems with + some of these, but I quickly ran into a problem: they were made for + actual practical applications in CAD, not for my nonsensical + generative art, and they scaled quite poorly with the sort of + recursion I was asking for. + + Implicit surfaces (or one of the many + equivalent-except-for-when-it's-not names for this, e.g. F-Reps or + distance bounds or SDFs or isosurfaces) handle almost all of this + well! They express CSG (TODO: link to CSG) operations, blending + shapes is easy, and they can be rendered directly on the GPU... see + Syntopia (again), or nearly anything by Inigo Quilez (TODO: link to + this), or look up raymarching, or look up sphere tracing, or see + nTopology (TODO: link), or libfive and Keeter's research paper + (TODO: link). It's pure magic and it's elegant. + + This is except for one big problem: converting them to good meshes + is a pain. None of my attempts have ever quite worked. + + ----- + + So, with these limitations in mind, around 2018 June I had started + jotting some ideas down. The gist is that I wanted to create + "correct-by-construction" meshes from these recursive grammars. +