stackgl / contributing Goto Github PK

http://en.wikipedia.org/wiki/Texture_synthesis

Would be nice to have tools for generating extrusions/sweeps along curves.

Just uploaded a new org logo.
Here's an svg and png if you like.

stackgl.zip

Source in figma

Might be nice to have something like a path tracing module (this would be more a fun project rather than something serious at this point).

Would be nice to have glslify/webgl implementations of the following:

• FFT
• Sorting
• Map-reduce / parallel prefix sum
• Stream compaction

Other ideas may be adaptable from cudpp.

Appears to not be supported in WebGL (or at least not my machine), though it's listed in the spec, e.g.:

uniform vec3 initialUniform = vec3(1.0, 0.0, 0.0);

This provides default values for uniforms which would be really nice for making more reusable shaders, but quite likely out of scope for gl-shader to shim. Maybe a wrapper package, or even a polyfill? Polyfill runs the risk of putting more burden on the package consumer, though also provides a leaner and more generic way of getting support across multiple frameworks/libraries.

Some projects

• BVH file parser
• Motion interpolation
• Skinning routines
• Motion graphs
• Dynamic/adaptive controllers

Having some tools to simplify texture atlas generation would be nice.

Likely tricky as gl-texture2d has to cover a lot of ground, but this would be super useful for enabling skyboxes (#4) and reflection/refraction among other things :)

Would be fantastic to have a module for subdividing simplicial complex meshes, e.g. for smoothing out the bunny mesh in some demos. I got halfway there using Loop subdivision but got stuck unfortunately :(

• Tone mapping routines
• Intensity solving

Still need:

• gl-quaternion
• gl-vec2
• gl-vec3

Also nice to have:

• Plucker coordinates for lines
• Conic sections?
• Maybe some module for working with exterior forms?

à la http://easings.net / http://glsl.io

Obviously they should be friendly toward Typed Arrays, RAF, etc.

Bonus points if one supplies GLSL variants.

We need more parsers for various 3D geometry formats. Eventually, it would also be nice to build some generic module that takes a simplicial complex and serializes it to various standard formats.

Using either alpha shapes or Poisson screening

Just curious if there's been any thought about adding TypeScript type definitions to these modules. One nice thing I still like about three.js is that there is a well-maintained .d.ts file, which makes working with TS and JS a lot more pleasant in modern editors like VSCode. VSCode can even infer types from standalone JS source files, but when you use require unfortunately it can't infer anything.

Screen space ambient occlusion may not be perfect, but it would certainly be useful from time to time :)

Stuff like B-splines/nurbs and tensor product splines.

This is a fairly big topic. Lots of ways to solve it.

applications / tools

• typeface.js is old, no kernings etc
• fontpath is pretty experimental
• opentype.js seems pretty robust and well tested
• SDF image generation - could be improved with a better algorithm
• BMFont or Hiero for SDF / general purpose stuff
• gdx-fontpack for tight packing / multi-page - would be nice to have NodeJS CLI versions and SDF integration

rendering

• gl-sprite-text for bitmap / SDF rendering
• fontpath-gl for simple geometry text (ThreeJS style)
• vectorize-text for runtime vectorization of canvas output
• gl-ttf seems experimental? via @tmpvar
• ??? for vector (loop-blinn) rendering

modules / utils

the fontpath modules are fairly experimental / scattered. Been using them on a couple projects but ideally I'd like to clean them up and rip some things out into their own generic interfaces.

• word-wrapper
• bmfont2json

I'm interested in adding support for ANGLE_instanced_arrays. After a cursory look at the modules that might be involved, it's starting to look like this might need alterations to:

• gl-geometry
• gl-buffer
• gl-vao

I'm wondering if anyone has taken a look at this issue yet and formed an idea of what needs to be done. If there's already a plan in place somewhere, I'd follow that. If not, I'd love any thoughts/pointers before I get started.

Pinging likely relevant parties 😁 @mikolalysenko @hughsk

I think simplicial complexes are a good approach for modularity but they have some drawbacks:

• "simplicial complex" is long-winded and intimidating; all of the search results related to it are extremely complex for somebody just trying to get a cube or sphere on screen
• they generally don't provide 3D rendering features like UVs or normals (lighting/texturing)

I am experimenting with a torus-mesh module and it would be great to have UVs baked in (like in @TatumCreative's geo-3d-box). It would also be good to standardize naming (mesh.uvs, module name, etc).

Normals would also be handy. So far I am using normals and glsl-face-normal, which seems to work well. Are there instances where they might provide less than desirable results compared to using the normals generated with the mesh?

/cc @mikolalysenko @hughsk

This could be implemented using a variety of different data structures.

With WebVR picking up speed, it'd be interesting to start investigating supporting it with a small collection of modules. Namely:

• Calculating the projection matrices for each eye of a HMD, as seen in WebVRRenderer.
• Post-processing shaders for barrel distortion, vignettes, and shifting RGB channels.

Would be nice to have a gl-skybox package that can take a cubemap texture and render it behind the main scene.

More expensive, but rendering the sky in a shader as demonstrated here would also be super nice.

Possibly for use with finite elements

Possible applications include:

• Particles
• Fluids
• Rigid bodies
• Deformable objects/continuum mechanics

Lots of ways to solve this, often comes down to particular application and requirements (anti-aliasing, performance, polygon complexity, etc).

Some starting points...

lines / curves / arcs

• https://www.npmjs.com/package/extrude-polyline
• https://www.npmjs.com/package/polyline-normals
• https://www.npmjs.com/package/arc-to
• adaptive-bezier-curve (and quadratic), bezier
• https://www.npmjs.com/package/three-line-2d (e.g. expanding line in shader)

SVG / complex polygons

• code example
• triangulation via #16
• use stencil buffer like in Pixi (downside: no AA)

• Bokeh
• Depth of field
• Motion blur

Using either Hoppe or random decimation (as described by Kobbelt). This is a big project, but would have lots of applications in reducing meshes for transfer over the wire.

Related to this would be implementing POP buffers

@hughsk @chrisdickinson @mattdesl @mikolalysenko hello!

I’m finishing glsl → js compiler, it is going to be a RC soon, the most significant part is ready.
I would like to donate this project to stack-gl, as it fits here. Could you please have a look and tell what are necessary enhancements.

Demo is coming.

Looking forward.

Thanks!

Would be nice to have a single docs repo that brings together some stuff, like:

• installing node/npm
• creating a new module
• explain best practices eg arrays vs objects for vector math
• explain simplicial complex / idea behind it
• higher level tutorials like lighting a mesh with glslify

• Graph cuts
• Water shed transform
• ...etc