glVertexAttribPointer problem z GL_INVALID_OPERATION

Question

Mam problem bo funckcja glVertexAttribPointer wywala mi caly czas GL_INVALID_OPERATION, a mam określone w ten sposob:

typedef glm::tvec4<GLbyte> byte4;
glVertexAttribPointer(0, 4, GL_BYTE, GL_FALSE, sizeof(byte4), 0);

mi się zdaje że problem leży tutaj, ale w razie czego moge podrzucić resztę kodu

 

Comments

 ale w razie czego moge podrzucić resztę kodu

To lepiej podrzuć, bo nie widzę, żeby cokolwiek było nie tak z tym. Odpisz tu w komentarzu, żebym dostał powiadomienie, to pomoge 

---

cały program bez shader

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

#include <iostream>
#define ASSERT(x) if (!(x)) __debugbreak();
#define GLCall(x) GLClearError();\
	x;\
	ASSERT(GLLogCall(#x, __FILE__, __LINE__))

void GLClearError()
{
	while (glGetError() != GL_NO_ERROR);
}
bool GLLogCall(const char* function, const char* file, int line)
{
	while (GLenum error = glGetError())
	{
		std::cout << "[OpenGL Error] (" << error << "): " << function <<
			" " << file << ":" << line << std::endl;
		return false;
	}
	return true;
}


#define CX 16
#define CY 16
#define CZ 16

#include <glad\glad.h>
#include <GLFW\glfw3.h>
#include <glm\glm.hpp>
#include <glm\gtc\matrix_transform.hpp>

#include <iostream>
#include "Shader.h"

typedef glm::tvec4<GLbyte> byte4;

struct chunk {
	uint8_t blk[CX][CY][CZ];
	GLuint vbo;
	int elements;
	bool changed;

	chunk() {
		memset(blk, 0, sizeof(blk));
		elements = 0;
		changed = true;
		GLCall(glGenBuffers(1, &vbo));
	}

	~chunk() {
		GLCall(glDeleteBuffers(1, &vbo));
	}

	uint8_t get(int x, int y, int z) {
		return blk[x][y][z];
	}

	void set(int x, int y, int z, uint8_t type) {
		blk[x][y][z] = type;
		changed = true;
	}

	void update() {
		changed = false;

		byte4 vertex[CX * CY * CZ * 6 * 6];
		int i = 0;

		for (int x = 0; x < CX; x++) {
			for (int y = 0; y < CY; y++) {
				for (int z = 0; z < CZ; z++) {
					uint8_t type = blk[x][y][z];

					// Empty block?
					if (!type)
						continue;

					// View from negative x
					vertex[i++] = byte4(x, y, z, type);
					vertex[i++] = byte4(x, y, z + 1, type);
					vertex[i++] = byte4(x, y + 1, z, type);
					vertex[i++] = byte4(x, y + 1, z, type);
					vertex[i++] = byte4(x, y, z + 1, type);
					vertex[i++] = byte4(x, y + 1, z + 1, type);

					// View from positive x
					vertex[i++] = byte4(x + 1, y, z, type);
					vertex[i++] = byte4(x + 1, y + 1, z, type);
					vertex[i++] = byte4(x + 1, y, z + 1, type);
					vertex[i++] = byte4(x + 1, y + 1, z, type);
					vertex[i++] = byte4(x + 1, y + 1, z + 1, type);
					vertex[i++] = byte4(x + 1, y, z + 1, type);

					// View from negative y
					vertex[i++] = byte4(x, y, z, type);
					vertex[i++] = byte4(x + 1, y, z, type);
					vertex[i++] = byte4(x, y, z + 1, type);
					vertex[i++] = byte4(x + 1, y, z, type);
					vertex[i++] = byte4(x + 1, y, z + 1, type);
					vertex[i++] = byte4(x, y, z + 1, type);

					// View from positive y
					vertex[i++] = byte4(x, y + 1, z, type);
					vertex[i++] = byte4(x, y + 1, z + 1, type);
					vertex[i++] = byte4(x + 1, y + 1, z, type);
					vertex[i++] = byte4(x + 1, y + 1, z, type);
					vertex[i++] = byte4(x, y + 1, z + 1, type);
					vertex[i++] = byte4(x + 1, y + 1, z + 1, type);

					// View from negative z
					vertex[i++] = byte4(x, y, z, type);
					vertex[i++] = byte4(x, y + 1, z, type);
					vertex[i++] = byte4(x + 1, y, z, type);
					vertex[i++] = byte4(x, y + 1, z, type);
					vertex[i++] = byte4(x + 1, y + 1, z, type);
					vertex[i++] = byte4(x + 1, y, z, type);

					// View from positive z
					vertex[i++] = byte4(x, y, z + 1, type);
					vertex[i++] = byte4(x + 1, y, z + 1, type);
					vertex[i++] = byte4(x, y + 1, z + 1, type);
					vertex[i++] = byte4(x, y + 1, z + 1, type);
					vertex[i++] = byte4(x + 1, y, z + 1, type);
					vertex[i++] = byte4(x + 1, y + 1, z + 1, type);
				}
			}
		}

		elements = i;
		GLCall(glBindBuffer(GL_ARRAY_BUFFER, vbo));
		GLCall(glBufferData(GL_ARRAY_BUFFER, elements * sizeof *vertex, vertex, GL_STATIC_DRAW));
	}

	void render() {
		if (changed)
			update();

		// If this chunk is empty, we don't need to draw anything.
		if (!elements)
			return;

		GLCall(glBindBuffer(GL_ARRAY_BUFFER, vbo));
		GLCall(glEnableVertexAttribArray(0));
		GLCall(glVertexAttribPointer(0, 4, GL_BYTE, GL_FALSE, sizeof(byte4), 0));
		GLCall(glDrawArrays(GL_TRIANGLES, 0, elements));
	}
};


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;

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;
	}
	Shader shader("src/shaders/shader.vs", "src/shaders/shader.fs");
	chunk chunk;
	chunk.set(1, 1, 1, 1);
	shader.use();
	chunk.render();
	// render loop
	// -----------
	while (!glfwWindowShouldClose(window))
	{
		// input
		// -----
		processInput(window);

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

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

	// 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);
}

 

---

Hmm nie widze nic co mogłoby powodować błąd... Jest jednak kilka bardziej logicznych błędów:

• 194 linia: ustawiasz blk[1][1][1], nie chodziło o [0][0][0] ?
• I tak nic nie zobaczysz na ekranie, bo chunk rysujesz raz a potem cały czas w pętli czyścisz color buffer

Może pokaż też kod shadera (kod GLSL), ale nie sądze, żeby tu tkwiło rozwiązanie.

Jesteś pewien, że to glVertexAttribPointer generuje error?

---

w blk[][][] powinna byc petla wy ustawila w kazdym bloku set(), ale chcialem tylko uruchomic program. 

Tak mam pewność, makro GLCall() troche pomaga w takich sprawach

GLSL vertex:

#version 410 core
layout (location = 0) in vec4 coord;

uniform mat4 mvp;
out vec4 texcoord;

void main(void) {
        texcoord = coord;
        gl_Position = mvp * coord;
}

chociaz nawet nie dochodzi do rysowanie bo glvertexattribpointer nic nie robi przez to ze uznaje GL_BYTE za zły typ, albo coś innego nie pasuje

---

No wybacz, ale nie mam pojęcia, nic nie widze. Ew. możesz podrzucić też tą klase Shader, to może odpale u siebie ale pewnie dopiero jutro

Answer 1

1. Rozmiar typu byte4 chyba nie jest jednakowy z czterokrotnym rozmiarem GL_BYTE. Tak w ogóle, możesz tam dać wartość 0, gdyż wg dokumentacji, dane będą wtedy upakowane jeden za drugim.
2. Czy na pewno indeks atrybutu równy 0 jest poprawny? Użyj lepiej funkcji glGetAttribLocation.

Comments

1. wiesz może jak moge to sprawdzic? i yo raczej tutaj lezy problem i nie wiem jak to poprawic, bo jak zamienie to na GLuint to mi wywala stack overflow

2. sprawdzilem jest dobry indeks.

---

Rozmiar typu byte4 chyba nie jest jednakowy z czterokrotnym rozmiarem GL_BYTE

Dlaczego? byte4 to vec4 bajtów.

 Czy na pewno indeks atrybutu równy 0 jest poprawny?

Nawet jeśli nie, to to nie generuje błędu, najwyżej shader będzie źle zczytywał atrybuty 

---

Możliwe, odpowiadałem przed snem i nie chciało mi się dokładnie sprawdzać powodu. Podałem bardziej swoje przemyślenia.

---

Sovcio, możesz to sprawdzić poniższym warunkiem.

sizeof(byte4) == sizeof(GLbyte) * 4

Tak jak wcześniej napisałem, stride równy rozmiarowi atrybutu nie ma większego sensu, lepiej użyć 0.