callumhay
commented
4 years ago Tried to debug this... got the point where I found the fragment shader code that may be the issue... perhaps the mapping of the index on the GPU side vs. the CPU side with glReadPixels (see erect3DArray3 in utils.js, and renderRawOutput in float.js)?
I've focused on the relevant frag shader code for my own clarity... still very difficult to follow all the mappings, I don't have enough familiarity with the code base to figure this out without spending a lot more time on it:
vec3 getMemoryOptimizedVec3(sampler2D tex, ivec2 texSize, ivec3 texDim, int z, int y, int x) {
int fieldIndex = 3 * (x + texDim.x * (y + texDim.y * z));
int vectorIndex = fieldIndex / 4;
int vectorOffset = fieldIndex - vectorIndex * 4;
int readY = vectorIndex / texSize.x;
int readX = vectorIndex - readY * texSize.x;
vec4 tex1 = texture2D(tex, (vec2(readX, readY) + 0.5) / vec2(texSize));
if (vectorOffset == 0) {
return tex1.xyz;
} else if (vectorOffset == 1) {
return tex1.yzw;
} else {
readX++;
if (readX >= texSize.x) {
readX = 0;
readY++;
}
vec4 tex2 = texture2D(tex, vec2(readX, readY) / vec2(texSize));
if (vectorOffset == 2) {
return vec3(tex1.z, tex1.w, tex2.x);
} else {
return vec3(tex1.w, tex2.x, tex2.y);
}
}
}
ivec3 indexTo3D(int idx, ivec3 texDim) {
int z = int(idx / (texDim.x * texDim.y));
idx -= z * int(texDim.x * texDim.y);
int y = int(idx / texDim.x);
int x = int(integerMod(idx, texDim.x));
return ivec3(x, y, z);
}
const float constants_VOXELu_uERR_UNITS_SQR = 0.24999750001874987;
uniform sampler2D user_framebufTex;
ivec2 user_framebufTexSize = ivec2(21, 19);
ivec3 user_framebufTexDim= ivec3(8, 8, 8);
ivec2 uTexSize = ivec2(24, 22);
ivec3 uOutputDim = ivec3(8, 8, 8);
varying vec2 vTexCoord;
void main(void) {
index = int(vTexCoord.s * float(uTexSize.x)) + int(vTexCoord.t * float(uTexSize.y)) * uTexSize.x;
threadId = indexTo3D(index, uOutputDim);
vec3 user_voxelColour=getMemoryOptimizedVec3(user_framebufTex,user_framebufTexSize, user_framebufTexDim, threadId.x, threadId.y, threadId.z);
vec3 kernelResult = vec3(user_voxelColour[0], user_voxelColour[1], user_voxelColour[2]);
gl_FragData[0][0] = kernelResult[0];
gl_FragData[0][1] = kernelResult[1];
gl_FragData[0][2] = kernelResult[2];
}
What is wrong?
When using a kernel to draw a CPU Array3D(3) into a texture and then converted back using toArray(), the resulting array is very strange and wrong, with some values being correct and others being either duplicated or entirely incorrect.
Where does it happen?
In GPU.js, running on my Windows 7 PC, headlessgl in node.js v12.18.1.
How do we replicate the issue?
Create a 3D array and assign each value set to its index in the array... e.g.,
Build the following kernel:
Draw the CPU buffer into a GPU texture and retrieve it as an array:
Then look to see if what we did was properly copied from the CPU -> GPU -> CPU:
... and get this comparative abomination:
CPU (Original/Control) i.e.,
debugPrint(buffer);:GPU toArray() result i.e.,
debugPrint(texBuffer);:How important is this (1-5)?
Strikes me as a pretty integral issue since there appears to be a non-identical transformation between CPU and GPU buffers.
Expected behavior (i.e. solution)
Those two arrays should be the same (or at least differ by an obvious matrix transform/mapping), instead the toArray() buffer is filled with duplicate data and errors that don't map at all to the original CPU buffer.