wgpu | Cross-platform , safe , pure-rust graphics api

Edit: Found a partial solution below.

Let's understand what's going on here.

Lifetimes in closures (impl Fn(&T), and also impl Fn(T<'_>), which is the same as yours impl Fn(HoldsRef)), do not desugar into generic lifetimes like normal elided lifetimes (where fn foo(_: &T) desugars into fn foo<'a>(_: &'a T)); instead, they're desugared into higher ranked trait bounds.

That is, impl Fn(&T) desugars into impl for<'a> Fn(&'a T), and in the same manner, impl Fn(HoldsRef) desugars into impl for<'a> Fn(HoldsRef<'a>). See also How does for<> syntax differ from a regular lifetime bound?.

HRTB (Higher-Ranked Traits Bounds) means that the lifetime can be any lifetime. And "any lifetime" includes, of course, 'static. And because 'static is the longest lifetime possible, the compiler just use this as if you've written impl Fn(HoldsRef<'static>). Note this is only true from the callback's point of view, that is, the callback must be able to handle this case but modify() can call it with whatever lifetime it wants, not only static (as opposed to what would happen if you'd specify impl Fn(HoldsRef<'static>), then you'd have to pass a HoldsRef<'static>).

Because the HoldsRef::set() method takes &'a i64, and 'a is 'static, so it's like it takes &'static i64. Now you will understand why the compiler complains when you provide a shorter lifetime.

You may think that the solution is just to take a generic lifetime instead of HRTB, and tie it to self:

The program works fine when I'm running it on my discrete graphics card, but wgpu is bugged on my integrated Intel HD Graphics 630, which is why the program appeared not to work.

There is an issue for this.

This can be solved by forcing the SurfaceTexture to be dropped after the TextureView.

The CalcNode::update function does not actually need access to its children - really it just wants the value that is calculated from them, so you can move the calculation out of the update function to prevent aliasing references:

It appears the wgpu-rs shader validation is favoring the built-in step() function over a variable declared with the same name. Going by the W3 WGSL docs, this should resolve to the variable since it is in a closer scope.

Renaming the step variable to something else should fix the immediate problem.

There is already an issue created to track this, but I've added this as another example.

Untested but should work:

Thanks to @trentcl for pointing out the solution. I did not realize that functions can have lifetime annotations independently from traits, so I came up with the very convoluted annotations which did not convey my intent properly. Simplifying to the following fixed my issue

Turns out Vulkan style GLSL aligns to the largest field in the struct when using std430.

https://github.com/KhronosGroup/glslang/issues/264

In my case it's vec3. The vec2 tex_coord is throwing it off causing the shader to pull data from the wrong parts of the vertex buffer.

The fix was to change the struct in model_load.comp to specify the individual components instead.

This is an open issue in wgpu-rs. Indeed the simplest workaround may be to make your mat3 into a mat4 until it is resolved.

The problem seems to be a mistake of alignment in generating SPIR-V. The actual alignment is:

1. If the member is a scalar consuming N basic machine units, the base alignment is N.
2. If the member is a two- or four-component vector with components consuming N basic machine units, the base alignment is 2N or 4N, respectively.
3. If the member is a three-component vector with components consuming N basic machine units, the base alignment is 4N.
4. If the member is an array of scalars or vectors, the base alignment and array stride are set to match the base alignment of a single array element, according to rules (1), (2), and (3), and rounded up to the base alignment of a vec4. The array may have padding at the end; the base offset of the member following the array is rounded up to the next multiple of the base alignment.

You are in case 4. Having a mat4 should leave no extra padding on the end and not give any possibility for misalignment issues.