for surfaces you would probably want to use something like polthier's method which is kind of what they describe in that video very quickly
calculating the forces is actually not that terrible, though the preconditioning step sounds a bit complicated
but i think their split preconditioning scheme is actually not too bad to implement once you grind through the algebra
the hard part in terms of actual coding for repulsive surfaces is definitely that remeshing though
I'm having some TS issues, should this have
| Texture2D in the least?
There's a DefinitelyTyped entry https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/ndarray but I haven't tried it
(but it also supports webgl2 and webgpu)
I wanted to use pex-context but couldn't find a way to do transform feedback
see here: https://luma.gl/docs/getting-started/external-context
the Model and Transform classes provide an interface very similar to regl and pex-context, albeit more object oriented
I want to study https://observablehq.com/@mourner/webgl-2-boilerplate and https://webgl2fundamentals.org/webgl/lessons/webgl1-to-webgl2.html before deciding anything for webgl2
How are you liking luma.gl?
How are you liking luma.gl?
Well, turns out it's in a state of flux right now as they're overhauling the API. Seems like in the end it'll be a pretty cool API with a gpu abstraction that supports webgl, webgl2 and webgpu. From what I can tell there are also both low level and high level abstractions for drawing.
But right now it's been too hard for me to juggle the documentation (which has stuff from both their v8 and v9 APIs mixed together and the website is tough to navigate.
I'm guessing maybe it'll clear up in 6 months or so but in the meantime I'm gonna try picogl.
twgl is a bit smaller, at 50k, compared to picogl at 67k or regl around 90k
twgl is from the author of https://webgl2fundamentals.org/ and he's also made useful things like webgl-lint and webgl-memory and webgl-capture
Is there a way to only use a part of an image or video as a texture? As far as I can tell, passing width, height, x, and y to the texture function has no effect on images and videos
@ojack:matrix.org I had to convince myself that I'd get the half-pixel offsets just right, so here's a notebook that transforms the texture sampling coordinate to accomplish this: https://observablehq.com/@rreusser/sampling-a-partial-image-in-webgl
1 reply
turns out you don't have to care about half-pixels in order to get the extents just right.
Of course it's kind of wasteful to only sample part of the texture, but nothing in the webgl API jumps out as supporting a partial image/video: https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/texImage2D
Of course it's kind of wasteful to only sample part of the texture, but nothing in the webgl API jumps out as supporting a partial image/video: https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/texImage2D
because it seems not to do that
@meh it will not automatically update the texture. To do that, you can manually call texture.subimage: https://github.com/regl-project/regl/blob/master/API.md#texture-subimage
I'm not 100% sure your setup, but one thing definitely not to do is
uniforms: { texture: (ctx, props) => regl.texture(props.textureData) }, as this will instantiate a new texture on every frame (without destroying previous textures?) and so will be very slow
is it possible to pass a buffer to a fragment shader? for example, i have a face buffer, [0,1,2,3,4,5...], and I wanted to pass a buffer that represents selected state [false, false, false, true, true, true...]. i could hack this by using a selected buffer the same length as the vertex buffer and passing it through the vertex shader, but that seems unideal for a bunch of reasons. am i missing something? is this possible?
@jeffreyhuber_twitter :wave: one approach might be to use (or just implement from scratch; it's a straightforward operation) something like this: https://github.com/hughsk/unindex-mesh
an indexed mesh passes vertices once and then uses elements to reuse the same vertex in multiple triangles. an unindexed mesh just duplicates 'em all so that every three vertices make a new triangle. then you could pass
vertices = [[ v0, v1, v2 ], [ v3, v4, v5 ], [ v6, v7, v8 ]]
selected = [[1, 1, 1], [0, 0, 0], [1, 1, 1]]