Translate two objects in the same 3D space in different ways? - c++

Question

I am trying to move objects with my 3D world in different ways but I can't move one object without affecting the entire scene. I tried using a second shader with different uniform names and I had some very strange results like objects disappearing and other annoying stuff.
I tried linking and unlinking programs but everything seems to translate together when I apply different matrices to the different shaders in hopes of seeing them move differently.
The TRANSLATE matrix is just a rotation * scale * translation matrix.
Edit - here is how set my uniforms:
//All of my mat4's
// Sorry for not initialising any of the vec3 or mat4's don't want the code to be too lengthy
perspectiveproj = glm::perspective(glm::radians(95.0f), static_cast<float>(width)/height , 0.01f, 150.0f);
views = glm::lookAt(position, position + viewdirection, UP);
trans1 = glm::rotate(trans1, 0.0f, glm::vec3(0.0f, 1.0f, 0.0f));
trans1 = glm::scale(trans1, glm::vec3(0.0f, 0.0f, 0.0f));
trans1 = glm::translate(trans1, glm::vec3(1.0f, 0.0f, 1.0f));
//These are the uniforms for my perspective matrix per shader
int persp = glGetUniformLocation(shader_one, "perspective");
glUniformMatrix4fv(persp, 1, GL_FALSE, glm::value_ptr(perspectiveproj));
int persp2 = glGetUniformLocation(shader_two, "perspective");
glUniformMatrix4fv(persp2, 1, GL_FALSE, glm::value_ptr(perspectiveproj));
//These are the uniforms for my lookAt matrix per shader
int Look = glGetUniformLocation(shader_one, "lookAt");
glUniformMatrix4fv(Look, 1, GL_FALSE, glm::value_ptr(views));
int Look2 = glGetUniformLocation(shader_two, "perspective");
glUniformMatrix4fv(Look2, 1, GL_FALSE, glm::value_ptr(views));
//This is the one uniform for my Translation to one shader object matrix
moving Shader two
//objects differently than shader one
int Moveoneshader = glGetUniformLocation(shader_two, "TRANSLATE");
glUniformMatrix4fv(Moveoneshader, 1, GL_FALSE, glm::value_ptr(trans1))
shader one:
gl_Positions = perspective * lookAt * vec4(position.x, position.y, position.z, 1.0);
shader two:
gl_Positions = perspective * lookAt * TRANSLATE * vec4(position.x, position.y, position.z, 1.0);
linking and drawing:
glUseProgram(shader_one);
glBindVertexArray(vao_one);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
glDeleteProgram(shader_one);
glUseProgram(shader_two);
glBindVertexArray(vao_two);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
glDeleteProgram(shader_two);

Answer 1

It seems that you are having trouble understanding the mechanics behind using a shader.
A shader is supposed to be a set of instructions that can run on multiple inputs, e.g. objects.
Let's first call the TRANSLATE matrix model matrix, since it holds all transformations that affect our model directly. The model matrix can have different values for different objects. So instead of using different shaders, you can use one generalized shader that calculates:
gl_Position = perspective * view * model * vec4(position, 1.0);
where view equals lookAt. I have exchanged the names of your matrices to follow naming conventions. I advise you to use these names so that you can find more information during research.
When creating a model matrix, you have to be careful about the order of matrix multiplication as well. In most cases, you want your model matrix to be composed like this
model = translate * rotate * scale
to avoid distortions of your object.
To be able to render multiple objects with their own respective model matrix, you have to loop over all objects and update the matrix value in the shader before drawing the object. A simplified example would be:
std::string name = "model";
for (Object obj : objects)
{
glUniformMatrix4fv(glGetUniformLocation(shaderID, name.c_str()), 1,
GL_FALSE, glm::value_ptr(model));
// draw object
}
You can read more about this here https://learnopengl.com/Getting-started/Coordinate-Systems.
Related to your problem, objects can disappear if you draw them with multiple shaders. This is related to how shaders write their data to your screen. By default, the active shader writes on all pixels of your screen. This means that when switching shaders to draw with the second shader after drawing with the first shader, the result of the first shader will be overwritten.
To combine multiple images, you can use Framebuffers. Instead of writing directly on your screen, you can use them to write into images first. Later, these images can be combined in a third shader.
However, this will cost way too much memory and will be too computationally inefficient to consider for your scenario. These techniques are usually applied when rendering post-processing effects.