无符号int向量的差异，被解释为有符号并转换为不正确呈现的浮点向量

Question

If I take the difference of the two uint vectors in my c++ code, cast to int, cast to float, and pass to GLSL, it renders fine. But when I try to make GLSL do the difference and cast, it covers the screen in a near uniform shade as if the square I'm trying to draw is really zoomed in. And yes, I really really do want to do it in GLSL, if only to see how. Also, my matrices and vectors are in Eigen objects, although I'm not sure if it matters.

Anyway, to make sure it's clear, my projviewMatrix (the same in both cases) works perfectly fine when given what should be an identical float vector to multiply with. So I'm pretty sure the issue is with the uint vector subtraction in GLSL. I did the exact same operation (uint vector subtract, cast to int, and cast to float) in c++ as I do in my shader, but one worked and one didn't.

Here's the vertex shader I'm currently trying. I tried just considering the vectors as signed ints and doing the subtract since the op should be the same... I think. No change in behavior.

#version 150 core

uniform mat4 projviewMatrix;
uniform ivec3 camera;

in ivec3 in_Position;
in vec3 in_Color;

out vec3 pass_Color;

void main()
{
 gl_Position = projviewMatrix * vec4(in_Position - camera, 1.0);
 pass_Color = in_Color;
}

I've tried passing in_Position and camera as uvec3s and then doing ivec4(in_Position - camera, 1) and other various silly rearranging to no avail. Also tried renaming camera to in_Camera . I'll admit, that was desperate.

My uniform passing stuff. When I pass in the working float vector, I simply comment out the 2 camera lines.

GLint viewLoc = glGetUniformLocation(shader.id(), "projviewMatrix"); //this is an ortho projection with 1/2 scaling, no rotation or translation
GLint cameraLoc = glGetUniformLocation(shader.id(), "camera");

glUniformMatrix4fv(viewLoc, 1, GL_FALSE, projview.data());
glUniform3uiv(cameraLoc, 1, camera.pos.data());

This is how I bind the VBO to the VAO.

glBindBuffer(GL_ARRAY_BUFFER, vboID[0]);
glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLint), 0, GL_STREAM_DRAW);

glVertexAttribPointer(0, 3, GL_INT, false, 0, 0);

Here is the float vector input GLSL that works. in_Position is the in_Position from above minus camera and casted to int then float in my c++ code.

#version 150 core

uniform mat4 projviewMatrix;

in vec3 in_Position;
in vec3 in_Color;

out vec3 pass_Color;

void main()
{
 gl_Position = projviewMatrix * vec4(in_Position, 1.0);
 pass_Color = in_Color;
}

My projviewMatrix only does two things: ortho projection and 1/2 scaling. No translation or rotation, or whatever else. The ortho part of it is generated with these parameters, with width/height being the window width/height.

proj = orthoProj(-width, width, -height, height, -4, 4);

edit:
At Alf's request:

This happens right after I bind my uniform stuff:

glBindBuffer(GL_ARRAY_BUFFER, vboID[0]);
int* buffer = (int*) glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);

static const int width = 1000;
TestObject& test = game.test;

buffer[0] = test.pos[0] - width;
buffer[1] = test.pos[1] - width;
buffer[2] = 0;

And I continually fill out buffer manually like so. test.pos is the center of the square, which is equal to camera.pos xy coords (1 << 31, 1 << 31) currently. In the case where I do the subtraction in c++, I have 3 lines like this after each vertex in buffer:

buffer[0] -= camera.pos[0];
buffer[1] -= camera.pos[1];
buffer[2] -= camera.pos[2];

Either way, I pass in the data as integers. The above block (happening for each buffer vertex) is the only difference between my "subtract in GLSL" and "subtract in c++" stuff, besides the camera uniform binding and the GLSL code difference.

test.pos and camera.pos are both Eigen::Vector3ui objects, so uint vector 3s.

edit2:

I think it's also worth noting that I have debug output printing any errors in the shaders, and there are none. Also, if I change in_Position and camera to vec3 , the result is the same blue-green shade as with anything else.

If I create my own ivec3 in the vertex shader and use it in place of camera , I can alter the "camera" values and move around what I can now confirm is the super inflated square, roughly spanning from 0 to 1 << 32 in the x and y axes. No amount of type juggling or intermediate variables in my vertex shader seem to be capable of fixing this.

edit 3:

Using glVertexAttribIPointer() to put data into in_Position has fixed part of the issue, which definitely appears to be OpenGL doing an extra cast to float before my GLSL code executes. However, the camera vector is still bugged up in the same fashion, and I don't know of anything I can do beyond my current use of glUniform3uiv . I tried using glUniform3ui and putting in its 3 values, but that also didn't work.

Answer 1

There were 2 problems.

1. Pointers to integer attributes should be set with glVertexAttribIPointer() since glVertexAttribPointer() causes openGL to perform some additional casts to/from float.
2. ivec3 uniform was set with glUniform3uiv() which also may caused unexpected casts. The right solution is to use unsinged uniform and perform cast inside shader.