OpenGL Problem z ustawieniem 2 różnych kolorów dla trójkątów

Question

Witam oto kod który miał służyć jako rozwiązanie zadania z learnopengl.com (Hello Triangle Ćwiczenie 3)
Jedyne czym się różni od rozwiązania prezentowanego na stronie to użycie tablic zamiast np.programShaderOrange
jest programShader[2] oraz użycie EBO zamiast dwóch osobnych tablic z wektorami.
Program kompiluje się ale oba trójkąty mają kolor żółty, a chce żeby były różne:
 

#include <glad/glad.h>
#include <GLFW/glfw3.h>

#include <iostream>

void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void processInput(GLFWwindow *window);

// settings
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;

const char *vertexShaderSource = "#version 330 core\n"
"layout (location = 0) in vec3 aPos;\n"
"void main()\n"
"{\n"
"   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
"}\0";
const char *fragmentShaderSource[2] = { "#version 330 core\n"
	"out vec4 FragColor;\n"
	"void main()\n"
	"{\n"
	"   FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
	"}\n\0",

	"#version 330 core\n"
	"out vec4 FragColor;\n"
	"void main()\n"
	"{\n"
	"   FragColor = vec4(1.0f, 1.0f, 0.0f, 1.0f);\n"
	"}\n\0"
};

int main()
{
	// glfw: initialize and configure
	// ------------------------------
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

#ifdef __APPLE__
	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // uncomment this statement to fix compilation on OS X
#endif

	// glfw window creation
	// --------------------
	GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);
	if (window == NULL)
	{
		std::cout << "Failed to create GLFW window" << std::endl;
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(window);
	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

	// glad: load all OpenGL function pointers
	// ---------------------------------------
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "Failed to initialize GLAD" << std::endl;
		return -1;
	}
	
	// build and compile our shader program
	// ------------------------------------
	// vertex shader
	int vertexShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
	glCompileShader(vertexShader);
	// check for shader compile errors
	int success;
	char infoLog[512];
	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
	if (!success)
	{
		glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
		std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
	}
	// fragment shader
	int fragmentShader[2] = { glCreateShader(GL_FRAGMENT_SHADER), glCreateShader(GL_FRAGMENT_SHADER) };
	for (int i = 0; i < 2; ++i)
	{
		glShaderSource(fragmentShader[i], 1, &fragmentShaderSource[i], NULL);
		glCompileShader(fragmentShader[i]);
		// check for shader compile errors
		glGetShaderiv(fragmentShader[i], GL_COMPILE_STATUS, &success);
		if (!success)
		{
			glGetShaderInfoLog(fragmentShader[i], 512, NULL, infoLog);
			std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
		}
	}
	
	// link shaders
	int shaderProgram[2] = { glCreateProgram(), glCreateProgram() };
	for (int i = 0; i < 2; ++i)
	{
		glAttachShader(shaderProgram[i], vertexShader);
		glAttachShader(shaderProgram[i], fragmentShader[i]);
		glLinkProgram(shaderProgram[i]);
	}
	
	// check for linking errors
	for (int i = 0; i < 2; ++i)
	{
		glGetProgramiv(shaderProgram[i], GL_LINK_STATUS, &success);
		if (!success) {
			glGetProgramInfoLog(shaderProgram[i], 512, NULL, infoLog);
			std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
		}
	}
	glDeleteShader(vertexShader);
	for (int i = 0; i < 2; ++i)
		glDeleteShader(fragmentShader[i]);

	// set up vertex data (and buffer(s)) and configure vertex attributes
	// ------------------------------------------------------------------
	// add a new set of vertices to form a second triangle (a total of 6 vertices); the vertex attribute configuration remains the same (still one 3-float position vector per vertex)
	float vertices[] = {
	-1.0f, 0.0f, 0.0f,
	0.0f, -0.5f, 0.0f,
	0.0f, 0.5f, 0.0f,
	1.0f, -0.5f, 0.0f,
	1.0f, 0.5f, 0.0f
	};
	unsigned int indices[] = {
		0, 1, 2,
		1, 3, 4
	};

	unsigned int VBO[2], VAO[2], EBO;
	glGenVertexArrays(2, VAO);
	glGenBuffers(2, VBO);
	glGenBuffers(1, &EBO);
	for (int i = 0; i < 2; ++i)
	{
		// bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
		glBindVertexArray(VAO[i]);

		glBindBuffer(GL_ARRAY_BUFFER, VBO[i]);
		glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
		glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE,  i * 3 * sizeof(float), (void*)0);
		glEnableVertexAttribArray(0);

		// note that this is allowed, the call to glVertexAttribPointer registered VBO as the vertex attribute's bound vertex buffer object so afterwards we can safely unbind
		glBindBuffer(GL_ARRAY_BUFFER, 0);

		// You can unbind the VAO afterwards so other VAO calls won't accidentally modify this VAO, but this rarely happens. Modifying other
		// VAOs requires a call to glBindVertexArray anyways so we generally don't unbind VAOs (nor VBOs) when it's not directly necessary.
		glBindVertexArray(0);
	}

	// uncomment this call to draw in wireframe polygons.
	//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

	// render loop
	// -----------
	while (!glfwWindowShouldClose(window))
	{
		// input
		// -----
		processInput(window);

		// render
		// ------
		glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);

		// draw our first triangle
		
		for (int i = 0; i < 2; ++i)
		{
			glUseProgram(shaderProgram[i]);
			glBindVertexArray(VAO[i]); // seeing as we only have a single VAO there's no need to bind it every time, but we'll do so to keep things a bit more organized
			glDrawArrays(GL_TRIANGLES, 0, 6); // set the count to 6 since we're drawing 6 vertices now (2 triangles); not 3!
		}
		
		// glBindVertexArray(0); // no need to unbind it every time 

		// glfw: swap buffers and poll IO events (keys pressed/released, mouse moved etc.)
		// -------------------------------------------------------------------------------
		glfwSwapBuffers(window);
		glfwPollEvents();
	}

	// optional: de-allocate all resources once they've outlived their purpose:
	// ------------------------------------------------------------------------
	glDeleteVertexArrays(2, VAO);
	glDeleteBuffers(2, VBO);
	

	// glfw: terminate, clearing all previously allocated GLFW resources.
	// ------------------------------------------------------------------
	glfwTerminate();
	return 0;
}

// process all input: query GLFW whether relevant keys are pressed/released this frame and react accordingly
// ---------------------------------------------------------------------------------------------------------
void processInput(GLFWwindow *window)
{
	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
		glfwSetWindowShouldClose(window, true);
}

// glfw: whenever the window size changed (by OS or user resize) this callback function executes
// ---------------------------------------------------------------------------------------------
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
	// make sure the viewport matches the new window dimensions; note that width and 
	// height will be significantly larger than specified on retina displays.
	glViewport(0, 0, width, height);
}

 

Answer 1

Jak mają być różnych kolorów skoro kolor jest hardcoded w fragment shaderze?
edit
ah, dobra, widzę. Są dwa fragment shadery. Problem w tym, że najpierw rysujesz trójkąty z ustawionym pierwszym shaderem, a zaraz potem identyczną geometrie rysujesz z drugim shaderem (tj. w kolorze vec4(1.0f, 1.0f, 0.0f, 1.0f)). Także przykrywasz pierwsze trójkąty drugimi. Poza tym: obecnie niemożliwe, żeby trójkąty były różnych kolorów, bo oba rysujesz jednym drawcallem a kolor jest hardcoded w shaderze.

Druga sprawa.. nie wiem jak te trójkąty ci się rysują, bo skoro używasz indeksów (EBO, index buffer, zwał jak zwał), to powinieneś rysować za pomocą glDrawElements.

Comments

Wciąż nie działa, zmieniłem glDrawArray na glDrawElements i dalej jest kolor żółty, z EBO też zrobiłem tablice i dalej nie mam pomysłu jak to zrobić, jeśli chodzi o drawcalle są tam w while(!glfwWindowShouldClose()) w pętli for więc myślałem że dalej są osobne. Co konkretnie jest źle w tym kodzie? Wydaje mi się taki sam jak ten: https://learnopengl.com/code_viewer_gh.php?code=src/1.getting_started/2.5.hello_triangle_exercise3/hello_triangle_exercise3.cpp (poza użyciem EBO, pętli oraz tablic zamiast np shaderProgramOrange, więc nie wiem co poprawic.

Answer 2

Rozwiązałem!
Okazało się że linijkę nr 182:

glDrawArrays(GL_TRIANGLES, 0, 6)

Musiałem zamienić na:
 

glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, (void*)(i * 3 * sizeof(unsigned int)));

I to tyle względem pierwszego postu! Musiałem zmienić liczbe vertexow na 3 żeby tylko jeden trójkąt narysowało w jednej iteracji pętli, oraz ustawić dobrze offset tak jak w 4 parametrze tej funkcji.