GLFWで四角形が表示されない

Question

実現したいこと

四角形が描画されるようにする

前提

glfwで四角形を描画するプログラムをこちらのサイトを参考にしながら書いています。
https://tokoik.github.io/GLFWdraft.pdf

主な機能分けは下記のようになっています。

• main.cppでウィンドウの初期化
• shader.cppのLoadshader()でシェーダのコンパイル、programIDの生成
• RenderクラスのSimplerenderメソッドで描画していましたが、簡単のためコメントアウトしてmain.cpp内で描画メソッドを呼び出している
• ObjectクラスのObject()で頂点配列オブジェクトの作成～Attribute変数に格納までの処理
• shapeクラスで描画処理

#include <opencv2/opencv.hpp>
#include <cstdlib>
#include <iostream>
#include <memory>

// GL
#include <GL/glew.h>
#include <GLFW/glfw3.h>

// made class
#include "render.h"
#include "Shape.h"
#include "Object.h"

#ifdef _DEBUG
#pragma comment(lib, "opencv_world470d.lib")
#else
#pragma comment(lib, "opencv_world470.lib")
#endif

void checkGLError()
{
	GLenum error;
	while ((error = glGetError()) != GL_NO_ERROR)
	{
		std::cout << "OpenGL Error: " << error << std::endl;
	}
}

using namespace std;
using namespace cv;

constexpr Object::Vertex rectangleVertex[] = 
{
	{ -0.5f, -0.5f },
	{  0.5f, -0.5f },
	{  0.5f,  0.5f },
	{ -0.5f,  0.5f }
};

int main() 
{
	// variables---------------
	GLuint ProgramID;

	//-------------------------

	// instance----------------
	Render render_obj;
	//-------------------------

	if (glfwInit() == GL_FALSE) 
	{
		cerr << "Can't initialize GLFW." << endl;
	}
	
	glfwWindowHint(GLFW_SAMPLES, 4);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);
	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	GLFWwindow *const window(glfwCreateWindow(640, 480, "Hello!", NULL, NULL));
	if (window == NULL)
	{
		cerr << "Can't create GLFW window" << endl;
		return 1;
	}

	atexit(glfwTerminate);

	glfwMakeContextCurrent(window);

	// GLEWの初期化
	glewExperimental = GL_TRUE;
	if (glewInit() != GLEW_OK) 
	{
		cerr << "Can't initialize FLEW" << endl;
		return 1;
	}

	// 垂直同期のタイミングを待つ
	glfwSwapInterval(1);

	glClearColor(1.0f, 1.0f, 1.0f, 0.0f);

	// LoadShaders
	ProgramID = LoadShaders("Simple.vert", "Simple.frag");
	cout << ProgramID << endl;

	unique_ptr<const Shape> shape(new Shape(2, 4, rectangleVertex));

	while (glfwWindowShouldClose(window) == GL_FALSE)
	{
		glClear(GL_COLOR_BUFFER_BIT);

		// 描画処理-----------------------------------------
		//render_obj.SimpleRender(shape, ProgramID);
		glUseProgram(ProgramID);
		shape->draw();
		//--------------------------------------------------

		glfwSwapBuffers(window);

		glfwWaitEvents();
	}
	return 0;
}

#pragma once
#include <GL/glew.h>
#include <iostream>

using namespace std;
//図形データ
class Object
{
	// 頂点配列オブジェクト名
	GLuint vao;

	// 頂点バッファオブジェクト名
	GLuint vbo;

public:

	// 頂点属性
	struct Vertex
	{
		GLuint position[2];
	};

	Object(GLuint size, GLsizei vertexcount, const Vertex* vertex)
	{
		glGenVertexArrays(1, &vao);
		glBindVertexArray(vao);
		glGenBuffers(1, &vbo);
		glBindBuffer(GL_ARRAY_BUFFER, vbo);
		glBufferData(GL_ARRAY_BUFFER, vertexcount * sizeof(Vertex), vertex, GL_STATIC_DRAW);

		glVertexAttribPointer(0, size, GL_FLOAT, GL_FALSE, 0, (void*)0);
		glEnableVertexAttribArray(0);
	}

	// デストラクタ
	virtual ~Object()
	{
		glDeleteVertexArrays(1, &vao);
		glDeleteBuffers(1, &vbo);
	}

private:
	// restrict copy
	Object(const Object& o);
	Object& operator=(const Object &o);

public:
	void bind() const
	{   // yuukouka
		glBindVertexArray(vao);
	}
};

#pragma once
#include <memory>

#include "Object.h"

using namespace std;

class Shape {
	// Class pointer defined
	shared_ptr<const Object> object;

protected:
	// Number of vertexes to use
	const GLsizei vertexcount;

public:
	Shape(GLuint size, GLsizei vertexcount, const Object::Vertex *vertex)
		: object(new Object(size, vertexcount, vertex))
		, vertexcount(vertexcount)
	{
	}

	void draw() const
	{
		object->bind();
		excute();
	}

	virtual void excute() const
	{
		glDrawArrays(GL_LINE_LOOP, 0, vertexcount);
	}
};

#include "shader.h"

GLuint LoadShaders(const char* vertex_file_path, const char* fragment_file_path) {

	// Create the shaders
	GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
	GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);

	// Read the Vertex Shader code from the file
	string VertexShaderCode;
	ifstream VertexShaderStream(vertex_file_path, std::ios::in);
	if (VertexShaderStream.is_open()) {
		std::stringstream sstr;
		sstr << VertexShaderStream.rdbuf();
		VertexShaderCode = sstr.str();
		VertexShaderStream.close();
	}
	else {
		printf("Impossible to open %s. Are you in the right directory ? Don't forget to read the FAQ !\n", vertex_file_path);
		getchar();
		return 0;
	}

	// Read the Fragment Shader code from the file
	string FragmentShaderCode;
	ifstream FragmentShaderStream(fragment_file_path, std::ios::in);
	if (FragmentShaderStream.is_open()) {
		std::stringstream sstr;
		sstr << FragmentShaderStream.rdbuf();
		FragmentShaderCode = sstr.str();
		FragmentShaderStream.close();
	}

	GLint Result = GL_FALSE;
	int InfoLogLength;


	// Compile Vertex Shader
	printf("Compiling shader : %s\n", vertex_file_path);
	char const* VertexSourcePointer = VertexShaderCode.c_str();
	glShaderSource(VertexShaderID, 1, &VertexSourcePointer, NULL);
	glCompileShader(VertexShaderID);

	// Check Vertex Shader
	glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
	glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
	if (InfoLogLength > 0) {
		std::vector<char> VertexShaderErrorMessage(InfoLogLength + 1);
		glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
		printf("%s\n", &VertexShaderErrorMessage[0]);
	}



	// Compile Fragment Shader
	printf("Compiling shader : %s\n", fragment_file_path);
	char const* FragmentSourcePointer = FragmentShaderCode.c_str();
	glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer, NULL);
	glCompileShader(FragmentShaderID);

	// Check Fragment Shader
	glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
	glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
	if (InfoLogLength > 0) {
		std::vector<char> FragmentShaderErrorMessage(InfoLogLength + 1);
		glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]);
		printf("%s\n", &FragmentShaderErrorMessage[0]);
	}



	// Link the program
	printf("Linking program\n");
	GLuint ProgramID = glCreateProgram();
	glAttachShader(ProgramID, VertexShaderID);
	glAttachShader(ProgramID, FragmentShaderID);
	glLinkProgram(ProgramID);

	// Check the program
	glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
	glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
	if (InfoLogLength > 0) {
		std::vector<char> ProgramErrorMessage(InfoLogLength + 1);
		glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
		printf("%s\n", &ProgramErrorMessage[0]);
	}


	glDetachShader(ProgramID, VertexShaderID);
	glDetachShader(ProgramID, FragmentShaderID);

	glDeleteShader(VertexShaderID);
	glDeleteShader(FragmentShaderID);

	return ProgramID;
}

GLuint LoadCompShader(const char* compute_file_path) {

	// Create the shaders
	GLuint ComputeShaderID = glCreateShader(GL_COMPUTE_SHADER);

	// Read the Vertex Shader code from the file
	string ComputeShaderCode;
	ifstream ComputeShaderStream(compute_file_path, std::ios::in);
	if (ComputeShaderStream.is_open()) {
		std::stringstream sstr;
		sstr << ComputeShaderStream.rdbuf();
		ComputeShaderCode = sstr.str();
		ComputeShaderStream.close();
	}
	else {
		printf("Impossible to open %s. Are you in the right directory ? Don't forget to read the FAQ !\n", compute_file_path);
		getchar();
		return 0;
	}

	GLint Result = GL_FALSE;
	int InfoLogLength;


	// Compile Vertex Shader
	printf("Compiling shader : %s\n", compute_file_path);
	char const* VertexSourcePointer = ComputeShaderCode.c_str();
	glShaderSource(ComputeShaderID, 1, &VertexSourcePointer, NULL);
	glCompileShader(ComputeShaderID);

	// Check Vertex Shader
	glGetShaderiv(ComputeShaderID, GL_COMPILE_STATUS, &Result);
	glGetShaderiv(ComputeShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
	if (InfoLogLength > 0) {
		std::vector<char> ComputeShaderErrorMessage(InfoLogLength + 1);
		glGetShaderInfoLog(ComputeShaderID, InfoLogLength, NULL, &ComputeShaderErrorMessage[0]);
		printf("%s\n", &ComputeShaderErrorMessage[0]);
	}

	// Link the program
	printf("Linking program\n");
	GLuint ProgramID = glCreateProgram();
	glAttachShader(ProgramID, ComputeShaderID);
	glLinkProgram(ProgramID);

	// Check the program
	glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
	glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
	if (InfoLogLength > 0) {
		std::vector<char> ProgramErrorMessage(InfoLogLength + 1);
		glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
		printf("%s\n", &ProgramErrorMessage[0]);
	}


	glDetachShader(ProgramID, ComputeShaderID);

	glDeleteShader(ComputeShaderID);

	return ProgramID;
}

#ifndef SHADER_HPP
#define SHADER_HPP

#include <iostream>
#include <cstdlib>
#include <vector>
#include <sstream>
#include <fstream>
#include <GL/glew.h>
#include <GLFW/glfw3.h>

using namespace std;

GLuint LoadShaders(const char* vertex_file_path, const char* fragment_file_path);

#endif

発生している問題・エラーメッセージ

描画されない

試したこと

現状何も描画されていないウィンドウのみ表示されており、エラー文も出ていない状況です。Loadshaderに書いたコンパイル結果のエラー表示も問題なく、glgeterror()でチェックしてもエラー文なく、上記のメソッドが呼び出されているかをcoutで確認しましたが、全て呼び出されているようでした。最後のglfwWaitEvents();をpollにしても駄目でした。

補足情報（FW/ツールのバージョンなど）

• Visual Studio 2022
• Nugetでglfw,glewの最新版をインストール(GLEW-static:2.1.0.3 glfw:3.3.1)

Comments

[cure_fontaine]

glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
こうなっているのですから、「何も表示されない画面」は白の背景になっているのでしょうか。
あと、GLSLによるシェーダーのソースはどうなっていますか。シェーダーを見れば、コンパイルできているかも見てわかります。

[fana]

（背景色と四角形が同じ色であるために視認できてない，みたいな可能性はありませんか？）

[cure_fontaine]

GetUniformLocationを使っている箇所が見当たりません。
シェーダーにuniform変数を使って投影マトリックスを送信するのに必要な処理です。
床井博士の執筆されたPDFドキュメントにはGetUniformLocationを使った記述があります。同じ処理をプログラムに組み込まないと、何も表示されないと思います。

[cure_fontaine]

頂点座標が２Dなのでuniform変数の媒介も不要なのかもしれませんが、３D頂点を扱う場合はuniform変数による媒介は避けて通れないので、GetUniformLocationについても学習してください。

Answer 1

ひょっとして，単にこれが原因なのでは……？

struct Vertex
{
	GLuint position[2];  //←ここの型
};

Comments

[fana]

あと，この構造体が変なパディング(?)とかを持たないことが前提になっているっぽく見えるのも若干気になる．
一旦配列に（密な形に）コピーしてやった方が安心かなぁ，とか．