zdelta | zdelta delta-compression library | Machine Learning library

Since you don't have ByVal for pSource, you either shouldn't use VarPtr for foo(0), or you should pass it explicitly ByVal: CopyMemory lRet, ByVal VarPtr(foo(0))... or CopyMemory lRet, foo(0)...

Also, you have foo() As Integer, but you assign Long variables to its contents. Are you sure that's what you want?

The formula to calculate the index of a pixel in the 2 dimensional height map image is

I think this happens because you are using gl_PointCoord in the fragment shader although you are not rendering points but lines. If I remove the following two lines of code, your lines are rendered:

One solution is to use the technique sometimes referred to as GPU Picking.

First study https://threejs.org/examples/webgl_interactive_cubes_gpu.html.

Once you understand the concept, study https://threejs.org/examples/webgl_interactive_instances_gpu.html.

Another solution is to replicate on the CPU the instancing logic implemented on the GPU. You would do so in your raycast() method. Whether it is worth it depends on the complexity of your use case.

three.js r.95

Your canvases are 16384 by 16384. That's basically insanely large.

For RGBA format, that is 1073741824 bytes.. a gigabyte of texture data that is getting sent to your GPU from the CPU when you set that texture.needsUpdate = true

You will definitely notice this getting uploaded to the card.

If your use case absolutely requires textures that large.. then you may need to consider doing incremental updates via gl.texSubImage2D, or using a bunch of smaller textures and only updating one of the per frame, or only updating those textures at the start of your app, and not thereafter.

For reference, there are very few cases i've seen where textures > 4k per side are needed.

And that is about 1/16th the size of your textures.

This has nothing to do with three.js btw. It's a fundamental characteristic of GPU/CPU interaction. Uploads and state changes are slow and have to be carefully orchestrated and monitored.

Ah, one must reassign the value of the uniform (stored in the material) and then mark the material as needing an update:

It seems to update a buffer attribute (or indexed buffer attribute) one can set the .dynamic property of that buffer to true, manually mutate the buffer, then set the .needsUpdate attribute of the buffer to true.

In this updated demo, after clicking the scene, the buffer attribute texIdx is updated such that all points have texIdx == 0:

In case others end up here facing the same trouble I had, I wanted to say that the above example was a simplified version of a larger scene. In that other scene, I was passing in an attribute texture but I was initializing the attribute as textureIndex inside the vertex shader. I then passed the textureIndex to the fragment shader as a varying, where it always equalled 0. So the moral of the story is -- if you try to read from an attribute that isn't passed to the vertex shader, that value evidently equates to zero. It would be great if this threw an error instead.

In the silly example above I had commented out the varying declaration in the fragment shader. This is fixed:

This is due to the distortion caused by rectilinear projection, which takes the depth value of each point (the "proximity distance" you were referring to) to be its Z (or Y) coordinate in camera space; you are instead taking this to be the Euclidean distance from the camera's position.

The diagram illustrates that, as you move the camera's axis away from the point, the distance delta increases (the point shrinks) while the depth value (the "apparent proximity") stays constant. To fix this, just replace delta with the depth value project[2] (or [1] - I forgot which one OpenGL uses).

Note that if your modelViewMatrix is set up correctly according to convention, you shouldn't subtract by cameraPosition.