Rendering to different objects using different textures and different shaders - c++

Question

I'm programming a voxel game. I have implented procedurally generated terrain. Now I want to program a map that should show on the upper right corner of the screen and that shows the biomes that are nearby. To do this my idea was to create a separate shader program, vbo, and vao, and a texture and that I would write to as the player moved around.
Is there a better way to do this?
Here I create the map:
GLuint VAO, VBO, EBO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &EBO);
glGenBuffers(1, &VBO);
float vertices[] = {
-.5f, -.5f, 0, 0, 0,
-.5f, .5f, 0, 0, 1,
.5f, .5f, 0, 1, 1,
.5f, -.5f, 0, 1, 0
};
/*float vertices[] = {
-1, -.5f, 0,
0, .5f, 0,
.5f, -.5f, 0
};*/
unsigned int indices[] = {
0, 1, 2,
0, 2, 3
};
glBindVertexArray(VAO);
// 2. copy our vertices array in a vertex buffer for OpenGL to use
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
// 3. copy our index array in a element buffer for OpenGL to use
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
// 4. then set the vertex attributes pointers
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3*sizeof(float)));
glEnableVertexAttribArray(1);
GLuint tbo;
int apothem = 256;
unsigned char pixels[apothem*apothem*3];
for(size_t i = 0; i < apothem*apothem*3; i++) {
pixels[i] = 1;
//std::cout << "changed pixels[" << i << "]" << std::endl;
}
glGenTextures(1, &tbo);
glActiveTexture(GL_TEXTURE0 + 1);
glBindTexture(GL_TEXTURE_2D, tbo);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, apothem, apothem, 0, GL_RGB, GL_UNSIGNED_BYTE, pixels);
//glTexSubImage2D(GL_TEXTURE_2D, 1, 0, 0, apothem, apothem, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
// set the texture wrapping/filtering options (on the currently bound texture object)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glGenerateMipmap(GL_TEXTURE_2D);
And here's the rendering loop:
while (!glfwWindowShouldClose(window))
{
// Poll and handle events (inputs, window resize, etc.)
// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
glfwPollEvents();
// Start the Dear ImGui frame
ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame();
static float scale[3] = {1, 1, 1};
static float rotation[3] = {0, 0, 0};
static float position[3] = {0, 0, 0};
// 2. Show a simple window that we create ourselves. We use a Begin/End pair to create a named window.
{
ImGui::Begin("Chunk settings"); // Create a window called "Hello, world!" and append into it.
ImGui::SliderFloat3("scale", scale, -5, 5);
ImGui::SliderFloat3("rotation", rotation, -360, 360);
ImGui::SliderFloat3("position", position, -5, 5);
ImGui::ColorEdit3("clear color", (float*)&clear_color); // Edit 3 floats representing a color
ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
ImGui::End();
}
{
int x = mainPlayer.GetPos().x(), z = mainPlayer.GetPos().z();
ImGui::Begin("World settings");
float continentalness = voxelEngine::mainWorld.GetContinentalness(x, z);
ImGui::Text("Continentalness: %.4f, Continentalness degree: %d", continentalness,
voxelEngine::mainWorld.ContinentalnessDegree(continentalness));
float erosion = voxelEngine::mainWorld.GetErosion(x, z);
ImGui::Text("Erosion: %.4f, Erosion Degree: %d", erosion,
voxelEngine::mainWorld.GetErosionDegree(erosion));
float humidity = voxelEngine::mainWorld.GetHumidity(x, z);
ImGui::Text("Humidity: %.4f, Humidity Degree: %d", humidity,
voxelEngine::mainWorld.GetHumidityDegree(humidity));
float temperature = voxelEngine::mainWorld.GetTemperature(x, z);
ImGui::Text("Temperature: %.4f, Temperature Degree: %d", temperature,
voxelEngine::mainWorld.GetTemperatureDegree(temperature));
float elevation = voxelEngine::mainWorld.GetElevation(x, z);
ImGui::Text("Elevation: %.4f, Elevation Degree: %d", elevation,
voxelEngine::mainWorld.GetElevationDegree(elevation));
ImGui::End();
}
static float n = .3, f = .5, speed, sensitivity, fov, pitch, yaw;
static Eigen::Vector3f cam_pos;
speed = voxelEngine::players->GetSpeed();
sensitivity = voxelEngine::players->GetSensitivity();
fov = voxelEngine::players->GetFOV();
pitch = voxelEngine::players->GetPitch();
yaw = voxelEngine::players->GetYaw();
cam_pos = voxelEngine::players->GetPos();
{
ImGui::Begin("Camera settings");
ImGui::SliderFloat("cam x", &cam_pos.x(), -10, 10);
ImGui::SliderFloat("cam y", &cam_pos.y(), -10, 10);
ImGui::SliderFloat("cam z", &cam_pos.z(), -10, 10);
ImGui::SliderFloat("speed", &speed, 0, 1);
ImGui::SliderFloat("sensitivity", &sensitivity, 0, 1);
ImGui::SliderFloat("fov", &fov, 0, 90);
ImGui::SliderFloat("pitch", &pitch, -360, 360);
ImGui::SliderFloat("yaw", &yaw, -360, 360);
ImGui::SliderFloat("near plane", &n, 0, 1);
ImGui::SliderFloat("far plane", &f, 0, 1);
ImGui::ColorEdit3("clear color", (float*)&clear_color); // Edit 3 floats representing a color
ImGui::End();
}
voxelEngine::players->SetPos(cam_pos);
voxelEngine::players->SetSpeed(speed);
voxelEngine::players->SetSensitivity(sensitivity);
voxelEngine::players->SetFOV(fov);
voxelEngine::players->SetDirection(pitch, yaw);
// Rendering
ImGui::Render();
int display_w, display_h;
glfwGetFramebufferSize(window, &display_w, &display_h);
glViewport(0, 0, display_w, display_h);
glClearColor(clear_color.x * clear_color.w, clear_color.y * clear_color.w, clear_color.z * clear_color.w, clear_color.w);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
float projMat[16];
float viewMat[16];
//float modelMat[16];
/*voxelEngine::genModelMatrix({scale[0], scale[1], scale[2]}, {rotation[0], rotation[1], rotation[2]},
{position[0],
position[1],
position[2]}, modelMat);*/
voxelEngine::players->genViewMatrix(viewMat);
voxelEngine::genProjMatrix(n, f, (float)display_h/display_w, voxelEngine::players->GetFOV(), projMat);
//glUniformMatrix4fv(glGetUniformLocation(voxelEngine::program, "modelMatrix"), 1, GL_FALSE, modelMat);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, blockTextures);
glUseProgram(worldProgram);
glUniformMatrix4fv(glGetUniformLocation(worldProgram, "viewMatrix"), 1, GL_FALSE, viewMat);
glUniformMatrix4fv(glGetUniformLocation(worldProgram, "projMatrix"), 1, GL_TRUE, projMat);
mainPlayer.Render();
float mapProj[16];
float mapModel[16];
voxelEngine::genModelMatrix(Eigen::Vector3f(.7, .7, .7), Eigen::Vector3f(0, 0, 0), Eigen::Vector3f(0, 0, 1), mapModel);
voxelEngine::genProjMatrix(n, f, (float)display_h/display_w, 90, mapProj);
glUseProgram(guiProgram);
glUniform1i(glGetUniformLocation(guiProgram, "my_sampler"), 1);
glActiveTexture(GL_TEXTURE0 + 1);
glBindTexture(GL_TEXTURE_2D, tbo);
//glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
glUniformMatrix4fv(glGetUniformLocation(guiProgram, "projMat"), 1, GL_TRUE, mapProj);
glUniformMatrix4fv(glGetUniformLocation(guiProgram, "modelMat"), 1, GL_FALSE, mapModel);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3*sizeof(float)));
glEnableVertexAttribArray(1);
//glTexImage2D(GL_TEXTURE_2D, 1, GL_RGB, apothem, apothem, 0, GL_RGB, GL_UNSIGNED_BYTE, pixels);
//glTexSubImage2D(GL_TEXTURE_2D, 1, 0, 0, apothem, apothem, GL_RGB, GL_UNSIGNED_BYTE, pixels);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
/*voxelEngine::mainBiomeMap->Bind();
voxelEngine::mainBiomeMap->Render();*/
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
// Update and Render additional Platform Windows
// (Platform functions may change the current OpenGL context, so we save/restore it to make it easier to paste this code elsewhere.
// For this specific demo app we could also call glfwMakeContextCurrent(window) directly)
if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
{
GLFWwindow* backup_current_context = glfwGetCurrentContext();
ImGui::UpdatePlatformWindows();
ImGui::RenderPlatformWindowsDefault();
glfwMakeContextCurrent(backup_current_context);
}
glfwSwapBuffers(window);
}
Everything renders fine except the map which is just black.
This is where I render the map:
float mapProj[16];
float mapModel[16];
voxelEngine::genModelMatrix(Eigen::Vector3f(.7, .7, .7), Eigen::Vector3f(0, 0, 0), Eigen::Vector3f(0, 0, 1), mapModel);
voxelEngine::genProjMatrix(n, f, (float)display_h/display_w, 90, mapProj);
glUseProgram(guiProgram);
glUniform1i(glGetUniformLocation(guiProgram, "my_sampler"), 1);
glActiveTexture(GL_TEXTURE0 + 1);
glBindTexture(GL_TEXTURE_2D, tbo);
//glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
glUniformMatrix4fv(glGetUniformLocation(guiProgram, "projMat"), 1, GL_TRUE, mapProj);
glUniformMatrix4fv(glGetUniformLocation(guiProgram, "modelMat"), 1, GL_FALSE, mapModel);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3*sizeof(float)));
glEnableVertexAttribArray(1);
//glTexImage2D(GL_TEXTURE_2D, 1, GL_RGB, apothem, apothem, 0, GL_RGB, GL_UNSIGNED_BYTE, pixels);
//glTexSubImage2D(GL_TEXTURE_2D, 1, 0, 0, apothem, apothem, GL_RGB, GL_UNSIGNED_BYTE, pixels);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
How can I get this to work?