OpenGL transformation in NDC coordinates instead of screen coordinates (2D)

Question

I'm having trouble figuring out how to position a 2D object in my scene using screen coordinates. At the moment I have something working (code below) but it want NDC coordinates which isn't easy to work with. I can't figure out where it's going wrong. I think I've used everything like it should be so I think I'm forgetting something.

Here's the code that handles the drawing of the objects in my scene:

glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);


// RENDERING HERE
colorProgram.bind();

for (size_t t = 0; t < objectsWithGraphicsComponentInThisScene.size(); ++t)
{
    // set texture
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, objectsWithGraphicsComponentInThisScene[t]->getComponent<GraphicsComponent>()->getTexture());

    GLint texLocation = colorProgram.getUniformLocation("texSampler");
    glUniform1i(texLocation, 0);

    glm::mat4 trans;
    trans = glm::translate(glm::mat4x4(1.0f), glm::vec3(objectsWithGraphicsComponentInThisScene[t]->getPosition().x, objectsWithGraphicsComponentInThisScene[t]->getPosition().y, 0));
    GLint transMatLocation = colorProgram.getUniformLocation("transformMatrix");
    glUniformMatrix4fv(transMatLocation, 1, GL_FALSE, glm::value_ptr(trans));

    // set camera Matrix
    GLint projMatLocation = colorProgram.getUniformLocation("projectionMatrix");
    glm::mat4 cameraMatrix = camera->getCameraMatrix();
    glUniformMatrix4fv(projMatLocation, 1, GL_FALSE, glm::value_ptr(cameraMatrix));

    objectsWithGraphicsComponentInThisScene[t]->getComponent<GraphicsComponent>()->getSprite()->draw();

    // unbind all
    glBindTexture(GL_TEXTURE_2D, 0);
}

colorProgram.unbind();

where colorProgram is the shader my sprites use and getPosition() simply returns a value which I've set. (where the x y and z value should be given as screen coordinates). so for example, getPosition might return [100, 50, 0] but that will render the object outside of the screen (the screen is 1280x720).

Now the code that renders the sprite (objectsWithGraphicsComponentInThisScene[t]->getComponent()->getSprite()->draw();):

void Sprite::draw()
{
glBindBuffer(GL_ARRAY_BUFFER, vboID);

glEnableVertexAttribArray(0);

// position
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, position));

//color
glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(Vertex), (void*)offsetof(Vertex, color));

// uv
glVertexAttribPointer(2, 2, GL_FLOAT, GL_TRUE, sizeof(Vertex), (void*)offsetof(Vertex, uv));

glDrawArrays(GL_TRIANGLES, 0, 6);

glDisableVertexAttribArray(0);

glBindBuffer(GL_ARRAY_BUFFER, 0);
}

And here's the code in the shader (colorProgram): VERTEX SHADER:

#version 130
// per vertex

// input data from VBO
in vec2 vertexPosition;
in vec4 vertexColor;
in vec2 vertexUV;

// output to fragment shader
out vec4 fragmentColor;
out vec2 fragmentUV;

uniform mat4 projectionMatrix;
uniform mat4 transformMatrix;

void main()
{
mat4 resultMatrix = transformMatrix * projectionMatrix;
gl_Position.xy = (resultMatrix * vec4(vertexPosition, 0.0, 1.0)).xy;
gl_Position.z = 0.0;

// Indicate that the coordinates are normalized
gl_Position.w = 1.0;

fragmentColor = vertexColor;
fragmentUV = vec2(vertexUV.x, 1.0 - vertexUV.y);
}

FRAGMENT SHADER

#version 130
// per pixel

// input from vertex shader
in vec4 fragmentColor;
in vec2 fragmentUV;

out vec4 color;

uniform sampler2D texSampler;

void main()
{
vec4 textureColor = texture(texSampler, fragmentUV);
if (textureColor.a < 0.5) discard;
color = fragmentColor * textureColor;
}

If you need more code I'd be happy to add more although I think this is everything that is needed.

Answer 1

This sequence in your vertex shader

mat4 resultMatrix = transformMatrix * projectionMatrix;
gl_Position.xy = (resultMatrix * vec4(vertexPosition, 0.0, 1.0)).xy;

is very unlikely what you actually want. Since you use the matrix * vector convention, you'll end up with

position = transform  *  projection * v
         = transform  * (projection * v)

In other words: you apply the transformation after the projection. Since after the projection, the viewing volume is in the [-1,1]^3 range (in euclidean NDC space after the perspecitive divide. In reality, we are working in clip space here, where it is [-w,w]^3, but this is not really important in this context,), translating the object by values like 100 units will certainly move it out of the frustum.

You should just reverse the order of your matrix multiplication.