常連

提示コードですが下記のコマンドを入力しても未定義というエラー出ます。ライブラリリンクでおそらくglfwが存在していないためだと思うのですがコンパイル手順が知りたいです。
まず`CMakeLists.txt`を実行その後　`make `を実行してインストールしたのですがリンクエラーになるということはこの時点で何か間違えていると思うのですが何が違うのでしょうか？


##### 試したこと
参考サイトに沿って#defineを入れました。
 ヘッダーファイルを`shigurechan@shigurechan-System-Product-Name:/usr/include/GLFW$ ` に設置
依存関係をインストール　https://qiita.com/pollenjp/items/aef8f2e4692af1662289
コンパイル方法：　https://www.glfw.org/docs/3.3/compile.html




##### 環境
OS: ubuntu 

参考サイト: https://stackoverflow.com/questions/43445942/opengl-glfw-undefined-reference-to-glfwinit
参考サイト：　https://qiita.com/chihiro/items/f270744d7e09c58a50a5

##### インストールのコマンド
```
shigurechan@shigurechan-System-Product-Name:~/ダウンロード/glfw/glfw/build$ sudo make install
[ 23%] Built target glfw
[ 26%] Built target boing
[ 28%] Built target gears
[ 30%] Built target heightmap
[ 32%] Built target sharing
[ 34%] Built target triangle-opengles
[ 38%] Built target particles
[ 40%] Built target splitview
[ 42%] Built target triangle-opengl
[ 44%] Built target offscreen
[ 46%] Built target wave
[ 48%] Built target windows
[ 51%] Built target window
[ 53%] Built target triangle-vulkan
[ 55%] Built target title
[ 57%] Built target tearing
[ 59%] Built target allocator
[ 62%] Built target clipboard
[ 64%] Built target joysticks
[ 67%] Built target events
[ 70%] Built target msaa
[ 73%] Built target glfwinfo
[ 77%] Built target iconify
[ 79%] Built target reopen
[ 81%] Built target gamma
[ 84%] Built target monitors
[ 86%] Built target timeout
[ 89%] Built target inputlag
[ 92%] Built target threads
[ 94%] Built target cursor
[ 97%] Built target empty
[100%] Built target icon
Install the project...
-- Install configuration: ""
-- Installing: /usr/local/lib/libglfw3.a
-- Up-to-date: /usr/local/include/GLFW
-- Up-to-date: /usr/local/include/GLFW/glfw3.h
-- Up-to-date: /usr/local/include/GLFW/glfw3native.h
-- Installing: /usr/local/lib/cmake/glfw3/glfw3Config.cmake
-- Installing: /usr/local/lib/cmake/glfw3/glfw3ConfigVersion.cmake
-- Installing: /usr/local/lib/cmake/glfw3/glfw3Targets.cmake
-- Installing: /usr/local/lib/cmake/glfw3/glfw3Targets-noconfig.cmake
-- Installing: /usr/local/lib/pkgconfig/glfw3.pc
shigurechan@shigurechan-System-Product-Name:~/ダウンロード/glfw/glfw/build$ 

```

##### Console
```
shigurechan@shigurechan-System-Product-Name:~/prg/test2$ g++ -lGL -lGLU -lglfw -lXrandr -lXxf86vm -lXi -lXinerama -lX11 -lrt -ldl Main.cpp
/usr/bin/ld: /tmp/ccnCZs5r.o: in function `main':
Main.cpp:(.text+0x9): undefined reference to `glfwInit'
collect2: error: ld returned 1 exit status

```


```cpp
File Edit Options Buffers Tools C++ Help                                                                   
#define GLFW_DLL
#include <iostream>
#include <GL/gl.h>
#include <GLFW/glfw3.h>

int main()
{
  GLFWwindow *window;

  if(glfwInit() == GL_FALSE)
    {

    }
  else
    {
      printf("初期化成功");
    }


  return 0;
}



```

インストールしてもglfwがリンクエラーになってしまう原因が知りたい。

### 実現したいこと

- [ ] M1macでGLSL のシェーダプログラムを利用したいです。

### 前提

C++でOlenGLのシェーダプログラムを使って、赤い画面を表示したいです。
しかし、シェーダープログラムが反映されず、白い画面のままになってしまいます。

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

シェーダープログラムが反映されません。
コンパイル、実行はどちらも正常に行えます。エラーや警告は出ていません。

### 調査したこと・試したこと
コンパイルコマンド
   ```cmd
g++ -o main main.cpp -lglfw -lglew -framework Cocoa -framework OpenGL -framework IOKit -framework CoreVideo -std=c++11
```
で実行すると、シェーダープログラムが反映されず、白い画面が表示される。

### 該当のソースコード

```C++
#ifdef __APPLE__
#define GL_SILENCE_DEPRECATION
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#endif

#include <cstdlib>
#include <fstream>
#include <iostream>
#include <vector>
using namespace std;

// シェーダオブジェクトのコンパイル結果を表示する
// shader: シェーダオブジェクト名
// str: コンパイルエラーが発生した場所を示す文字列
GLboolean printShaderInfoLog(GLuint shader, const char *str) {
  // コンパイル結果を取得する
  GLint status;
  glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
  if (status == GL_FALSE) std::cerr << "Compile Error in " << str << std::endl;
  // シェーダのコンパイル時のログの長さを取得する
  GLsizei bufSize;
  glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &bufSize);
  if (bufSize > 1) {
    // シェーダのコンパイル時のログの内容を取得する
    std::vector<GLchar> infoLog(bufSize);
    GLsizei length;
    glGetShaderInfoLog(shader, bufSize, &length, &infoLog[0]);
    std::cerr << &infoLog[0] << std::endl;
  }
  return static_cast<GLboolean>(status);
}

// プログラムオブジェクトのリンク結果を表示する
// program: プログラムオブジェクト名
GLboolean printProgramInfoLog(GLuint program) {
  // リンク結果を取得する
  GLint status;
  glGetProgramiv(program, GL_LINK_STATUS, &status);
  if (status == GL_FALSE) std::cerr << "Link Error." << std::endl;
  // シェーダのリンク時のログの長さを取得する
  GLsizei bufSize;
  glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufSize);
  if (bufSize > 1) {
    // シェーダのリンク時のログの内容を取得する
    std::vector<GLchar> infoLog(bufSize);
    GLsizei length;
    glGetProgramInfoLog(program, bufSize, &length, &infoLog[0]);
    std::cerr << &infoLog[0] << std::endl;
  }
  return static_cast<GLboolean>(status);
}

// プログラムオブジェクトを作成する
// vsrc: バーテックスシェーダのソースプログラムの文字列
// fsrc: フラグメントシェーダのソースプログラムの文字列
GLuint createProgram(const char *vsrc, const char *fsrc) {
  // 空のプログラムオブジェクトを作成する
  const GLuint program(glCreateProgram());
  if (vsrc != NULL) {
    // バーテックスシェーダのシェーダオブジェクトを作成する
    const GLuint vobj(glCreateShader(GL_VERTEX_SHADER));
    glShaderSource(vobj, 1, &vsrc, NULL);
    glCompileShader(vobj);
    // バーテックスシェーダのシェーダオブジェクトをプログラムオブジェクトに組み込む
    if (printShaderInfoLog(vobj, "vertex shader"))
      glAttachShader(program, vobj);
    glDeleteShader(vobj);
  }
  if (fsrc != NULL) {
    // フラグメントシェーダのシェーダオブジェクトを作成する
    const GLuint fobj(glCreateShader(GL_FRAGMENT_SHADER));
    glShaderSource(fobj, 1, &fsrc, NULL);
    glCompileShader(fobj);
    // フラグメントシェーダのシェーダオブジェクトをプログラムオブジェクトに組み込む
    if (printShaderInfoLog(fobj, "fragment shader"))
      glAttachShader(program, fobj);
    glDeleteShader(fobj);
  }
  // プログラムオブジェクトをリンクする
  glBindAttribLocation(program, 0, "position");
  glBindFragDataLocation(program, 0, "fragment");
  glLinkProgram(program);
  // 作成したプログラムオブジェクトを返す
  if (printProgramInfoLog(program)) return program;
  // プログラムオブジェクトが作成できなければ 0 を返す
  glDeleteProgram(program);
  return 0;
}

int main() {
  // GLFW を初期化する
  if (glfwInit() == GL_FALSE) {
    // 初期化に失敗した
    std::cerr << "Can't initialize GLFW" << std::endl;
    return 1;
  }
  // プログラム終了時の処理を登録する
  atexit(glfwTerminate);

  // OpenGL Version 3.2 Core Profile を選択する
  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
  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) {
    // ウィンドウが作成できなかった
    std::cerr << "Can't create GLFW window." << std::endl;
    return 1;
  }
  // 作成したウィンドウを OpenGL の処理対象にする
  glfwMakeContextCurrent(window);

  // GLEW を初期化する
  glewExperimental = GL_TRUE;
  if (glewInit() != GLEW_OK) {
    // GLEW の初期化に失敗した
    std::cerr << "Can't initialize GLEW" << std::endl;
    return 1;
  }

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

  // 背景色を指定する
  glClearColor(1.0f, 1.0f, 1.0f, 0.0f);

  // バーテックスシェーダのソースプログラム
  static constexpr GLchar vsrc[] =
      "#version 150 core\n"
      "in vec4 position;\n"
      "void main()\n"
      "{\n"
      " gl_Position = position;\n"
      "}\n";
  // フラグメントシェーダのソースプログラム
  static constexpr GLchar fsrc[] =
      "#version 150 core\n"
      "out vec4 fragment;\n"
      "void main()\n"
      "{\n"
      " fragment = vec4(1.0, 0.0, 0.0, 1.0);\n"
      "}\n";
  // プログラムオブジェクトを作成する
  const GLuint program(createProgram(vsrc, fsrc));

  // ウィンドウが開いている間繰り返す
  while (glfwWindowShouldClose(window) == GL_FALSE) {
    // ウィンドウを消去する
    glClear(GL_COLOR_BUFFER_BIT);

    // シェーダプログラムの使用開始
    glUseProgram(program);

    //
    // ここで描画処理を行う
    //
    // カラーバッファを入れ替える
    glfwSwapBuffers(window);
    // イベントを取り出す
    glfwWaitEvents();
  }
}
```

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

PCの環境
　OS: macOS Monterey version 12.3.1
   MacBook Air (M1, 2020)
   チップ: Apple M1
   メモ:16GB

g++バージョン
   Apple clang version 13.1.6 (clang-1316.0.21.2.3)

コンパイルコマンド
   ```cmd
g++ -o main main.cpp -lglfw -lglew -framework Cocoa -framework OpenGL -framework IOKit -framework CoreVideo -std=c++11
```


M1mac でOpenGLのシェーダープログラムを使いたい

xcodeにてC++を使っています。
openglを使おうとし、glutをincludeしました。
glutinit関数を使用した際以下のようなエラーが出ました。

```C++
'glutInit' is deprecated: first deprecated in macOS 10.9
```

調べて行くと、より新しいmacOSではglutを推奨しておらず、GLFWを推奨しているようです。

さらに調べて行くと、C++でコンパイルする際に以下のコマンドをオプションで入れると、先ほどのエラーが表示されないそうです。

```console
$ g++ sample.cpp -mmacosx-version-min=10.8 -framework GLUT -framework OpenGL
```

自分はopencvはおろかglutについても初心なため、勉強することにおいては情報量の多いGLUTを使用したいのですが、非推奨ということとGLFWの方が初期状態からダブルバッファリングであったりするそうで使い勝手が良さそうです。

私はGLUTとGLFWのどちらを使って学んで行くべきですか？
色々とアドバイスをしてくれるとかなり嬉しいです。( ͡° ͜ʖ ͡°)



----- 追伸 ------

OpenGLを使って何をしたいかと聞かれればゲームを作りたいと思っています。

C++  GLUTかGLFWか？？

### 前提・実現したいこと

C++二日目の初心者です。
以下サンプルプログラムを実行したく、C++に触れ始めました。
https://github.com/tokoik/fisheye

まことに恐縮ですが、C++の基礎やプロジェクト/ライブラリに対する理解が不足しており、初歩的な質問になっておりましても、ご容赦いただけますと幸甚です。

環境
　Windows10 Pro
　VS Code

### 発生している問題・エラーメッセージ

MinGWインストールのうえ、「gcc -v」が通ることを確認した状態で、
前述のサンプルコードをclone、「c_cpp_properties.json」を以下のように記載したうえで
```json
{
    "configurations": [
        {
            "name": "Win32",
            "includePath": [
                "${workspaceFolder}/**" ,
                "C:/MinGW/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/x86_64-w64-mingw32",
                "C:/MinGW/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/backward",
                "C:/MinGW/lib/gcc/x86_64-w64-mingw32/7.1.0/include",
                "C:/MinGW/lib/gcc/x86_64-w64-mingw32/7.1.0/include-fixed",
                "C:/MinGW/lib/gcc/x86_64-w64-mingw32/7.1.0/../../../../x86_64-w64-mingw32/include",
                "C:/MinGW/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++",
                "C:/MinGW/lib/gcc/x86_64-w64-mingw32/7.1.0/include/c++/tr1",
                "C:/programs/fisheye-master/fisheye-master/libs/include"
            ],
            "defines": [
                "_DEBUG",
                "UNICODE",
                "_UNICODE"
            ],
            "windowsSdkVersion": "10.0.18362.0",
            "compilerPath": "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.23.28105/bin/Hostx64/x64/cl.exe",
            "cStandard": "c11",
            "cppStandard": "c++17",
            "intelliSenseMode": "msvc-x64"
        }
    ],
    "version": 4
}
```
「gcc fisheye.cpp」を実行したところ、エラーが発生しました。
```
PS C:\programs\fisheye-master\fisheye-master> gcc .\fisheye\fisheye.cpp
In file included from .\fisheye\GgApplication.h:29,
                 from .\fisheye\fisheye.cpp:2:
.\fisheye\gg.h:32:10: fatal error: GLFW/glfw3.h: No such file or directory
 #include <GLFW/glfw3.h>
          ^~~~~~~~~~~~~~
compilation terminated.
```
「C:/programs/fisheye-master/fisheye-master/libs/include/GLFW」以下に「glfw3.h」は存在しておりますので、理由がわからず苦戦しております。

### 試したこと

・GLFW（recompiled）を別パスへインストールのうえ、そちらのパスをinclude pathに追加する。
・環境の再構築、サンプルプログラムの再clone
　　→いずれも、エラーに変わりありませんでした。

### 補足情報

補足とも言えない情報となりますが、「Hello World！」をコンソールに出力することはできており、
最もベースの環境構築そのものには誤りはないのではないかと考えております。


以上、よろしくお願いいたします。

【C++/初心者】includePathの設定をしても、ビルド時にエラー「fatal error: GLFW/glfw3.h: No such file or directory」が発生する

GLFWライブラリを介してOpenGLを使用しているのですが、
OpenGLの動きに関連してCPUとGPUのどちらがどのタイミングで使われているかを知りたいです。

現在私はウィンドウを作成し、シェーダープログラムを実行する環境を整えたところまでしかわかりません。(図形描画を実際に行なっていないということです。)

その上で質問ですが、

1. GLFW(OpenGL)にてCPU, GLSLにてGPUを司っているのか？
少し語弊があるかと思いますが、ウィンドウ作成やダブルバッファリングのバッファ入れ替えをCPUで司り、シェーダー等をGPUで処理しているのかということです。

2. また、もし1.が正しかった場合、ダブルバッファリングのバッファ入れ替えと各バッファへの描画をそれぞれCPUとGPUで分けているからこそスムーズな処理が可能であり、CPUの他にGPUを必要としている理由なのか？

まだ始めたばかりなので自分の中でだいぶフワフワしています。
この質問である程度はっきりさせておきたいです。

回答お願いします。( ͡° ͜ʖ ͡°)

OpenGLにおけるCPUとGPUの動作の違いについて

### 実現したいこと

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

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

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


```main.cpp
#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;
}
```

```Object.h
#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);
	}
};

```

```Shape.h
#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);
	}
};

```
```shader.cpp
#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;
}
```

```shader.h
#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)




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

提示コードのコメント部のshader.Active();関数で提示画像ようにエラー0x502発生していますデバッグするとglUseProgram();関数でエラーが発生していてそのprogaram変数を追うとglCreateProgram():関数に行きつくのですが中身を見ると１とい値が入っています。glUseProgaram();関数でエラーglCreateProgram();関数が失敗しているというのはどういう意味なのでしょうか？ちなみにprogram変数には1という値が入っていますがこれもなんかおかしい感じがするのではやりglCreateProgram();関数で失敗していると思います。この関数が廃止されて関数とは思えません。

※Main();関数でopengl glfw glew の初期化はすんでいます。


glGetErro()" [0x502 現在のステートで無効な操作をしている場合、もしくは廃止された関数を呼び出した場合  ]

![イメージ説明](f165bf0626ffdaac583da144c4b0c7fa.png)
参考サイト: https://qiita.com/_ydah/items/da56763e94ba58af3d91
公式リファレンス: https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glUseProgram.xhtml
```cpp
//#define GLEW_STATIC	//スタティックリンク
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <vector>
#include <glew/include/GL/glew.h>
#include <glfw/include/GLFW/glfw3.h>

#include "Window.hpp"
#include "Shader.hpp"
#include "DrawTest.hpp"


int main()
{
	if (glfwInit() == GL_FALSE)
	{
		std::cerr << "glfw初期化失敗。" << std::endl;
		return -1;
	}

	atexit(glfwTerminate);	//プログラム終了時の処理を登録
	Window window;			//コンテキストを作成

	//OpenGL Verison 3.2 Core Profile　を選択する
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR,3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR,3);
	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT,GL_TRUE);
	glfwWindowHint(GLFW_OPENGL_PROFILE,GLFW_OPENGL_CORE_PROFILE);

	glClearColor(1.0, 0.0, 0.0, 1.0);	//背景色
// #############################################################################


	DrawTest test;	//表示オブジェクト

	Shader shader("Test.vert","Test.frag");

	//shader.setBindAttribVertex("position");

	//shader.setBindAttribVertex("fragment");

	//shader.setBindAttribFragment("out_fragment");

	//shader.setUniform4fv();
	while (window)
	{
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	//カラーバッファをクリア
//////////////////////////////////////////////////
		shader.Active();
//////////////////////////////////////////////////		
		test.Draw();
		

		





		window.SwapBuffers();	//ダブルバッファリング
	}

}

```
```cpp
#include "Shader.hpp"

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

//コンストラクタ
Shader::Shader(const char* vert, const char* frag)
{
	program = loadProgram(vert,frag);
	if (program == 0)
	{
		std::cerr << "シェーダープログラム作成エラー"<<std::endl;
		exit(1);
	}

	//std::cout<< program << std::endl;

}

//シェーダーをロード
GLuint Shader::loadProgram(const char* vert, const char* frag)
{
	std::vector<GLchar> vsrc;
	const bool vstat = ReadShaderSource(vert, vsrc);

	std::vector<GLchar> fsrc;
	const bool fstat = ReadShaderSource(frag, fsrc);


	if (vstat && fstat)
	{
		return CreateProgram(vsrc.data(), fsrc.data());
	}
	else {
		return 0;
	}
}



//シェーダーファイルを読み込む
bool Shader::ReadShaderSource(const char* name, std::vector<GLchar>& buffer)
{
	if (name == NULL)
	{
		return false;
	}
	

	std::ifstream file(name, std::ios::binary);
	if (file.fail())
	{
		std::cerr << "ソースファイルが読み込めません: " << name << std::endl;
		file.close();
		return false;
	}

	file.seekg(0L, std::ios::end);
	GLsizei length = static_cast<GLsizei>(file.tellg());
	buffer.resize(length + 1);

	file.seekg(0L, std::ios::beg);
	file.read(buffer.data(), length);
	buffer[length] = '\0';
	
	if (file.fail())
	{
		std::cerr << "ソースファイルを読み込めません: " << name << std::endl;
		file.close();

		return false;
	}

	file.close();
	return true;
}



//エラーログを取得
GLboolean Shader::InfoLog(GLuint shader, const char* str)
{
	GLint status;

	//コンパイル結果
	glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
	if (status == GL_FALSE)
	{
		std::cerr << "コンパイルエラー　" << str << std::endl;
	}
	
	//エラーログの長さを得る
	GLsizei bufSize;
	glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &bufSize);

	if (bufSize > 1)
	{
		std::vector<GLchar> infoLog(bufSize);
		GLsizei length;
		glGetShaderInfoLog(shader, bufSize, &length, &infoLog[0]);

		std::cerr<< &infoLog[0] << std::endl;
	}



	return (GLboolean)status;
}




//プログラムオブジェクト作成
GLuint Shader::CreateProgram(const char* vsrc, const char* fsrc)
{
	const GLuint program = glCreateProgram();	//シェーダープログラムを作成
	//std::cout << program << std::endl;

	if (vsrc != NULL)
	{
		const GLuint vobj = glCreateShader(GL_VERTEX_SHADER);
		glShaderSource(vobj, 1, &vsrc, NULL);
		glCompileShader(vobj);

		InfoLog(vobj, vsrc);

		glAttachShader(program, vobj);
		glDeleteShader(vobj);

	}
	else {
		std::cout << "頂点シェーダー読み込み失敗" << std::endl;
	}

	if (fsrc != NULL)
	{
		const GLuint fobj = glCreateShader(GL_FRAGMENT_SHADER);
		glShaderSource(fobj, 1, &fsrc, NULL);
		glCompileShader(fobj);

		InfoLog(fobj, fsrc);

		glAttachShader(program, fobj);
		glDeleteShader(fobj);
	}
	else {
		std::cout << "フラグメントシェーダー読み込み失敗" << std::endl;

	}

	glLinkProgram(program);

	return program;
}

//頂点シェーダーに属性変数を関連ずける
void Shader::setBindAttribVertex(const char* str)
{
	GLint n = glGetAttribLocation(program, str);

	//エラー処理
	if (n == -1)
	{
		std::cerr <<"setBindAttribVertex(): "<< n << std::endl;
	}
	else 
	{
		glBindAttribLocation(program, n, str);
	}
}


//フラグメントシェーダーに属性変数を関連ずける
void Shader::setBindAttribFragment(const char* str)
{
	GLint n = glGetAttribLocation(program, str);

	//エラー処理
	if (n == -1)
	{
		std::cerr << "setBindAttribFragment(): " << n << std::endl;
	}
	else 
	{
		glBindFragDataLocation(program, n, str);
	}
}

//有効にする
void Shader::Active()
{
	glUseProgram(program);
}

//　######################################################### Uniform 設定

//vec1
void Shader::setUniform1f(const char* name, const float vec)
{
	const GLuint object = glGetUniformLocation(program, name);
	glUniform1f(object, vec);
}

//vec2
void Shader::setUniform2fv(const char* name, const glm::vec2 vec)
{
	const GLuint object = glGetUniformLocation(program, name);
	GLfloat v[2] = { vec.x,vec.y };
	glUniform2fv(object, 1, v);
}

//vec3
void Shader::setUniform3fv(const char* name, const glm::vec3 vec)
{
	const GLuint object = glGetUniformLocation(program, name);
	GLfloat v[3] = { vec.x,vec.y,vec.z };
	glUniform3fv(object, 1, v);
}

//vec 4
void Shader::setUniform4fv(const char* name, const glm::vec4 vec)
{	
	const GLuint object = glGetUniformLocation(program,name);
	GLfloat v[4] = { vec.x,vec.y,vec.z,vec.w };
	glUniform4fv(object,1,v);

}



//デストラクタ
Shader::~Shader()
{

}

```

glUseProgram();関数でエラーコード0x502が発生する理由が知りたい。　glCreateProgram();関数がエラーになる。？

提示コードの///コメント部内の部のコードですがglfwSetKeyCallback();イベント処理関数を使ってキーが押された瞬間１と返す方法が知りたいです。提示画像ですが提示コードのように実装したのですがなぜか１という値が数フレーム返って来てしまいます。本来押された瞬間であれば１は一回だけで後は２の値が来るはずなのですがログを見ると数フレーム来てしまっています。これは何が原因なのでしょうか？



参考サイト: https://www.glfw.org/docs/latest/group__input.html#ga1caf18159767e761185e49a3be019f8d

![イメージ説明](5ab6fd60b2faf850b37b3115bc174654.png)

```cpp
//#define GLEW_STATIC	//スタティックリンク
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <vector>
#include <glew/include/GL/glew.h>
#include <glfw/include/GLFW/glfw3.h>



#include "Window.hpp"
#include "Shape.hpp"
#include "Shader.hpp"

Object::Vertex rectangleVertex[4] =
{
	{-0.5f,-0.5f},
	{0.5f,-0.5f},
	{0.5f,0.5f},
	{-0.5f,0.5f}
};


int main()
{
	if (glfwInit() == GL_FALSE)
	{
		std::cerr << "glfw初期化失敗。" << std::endl;
		return -1;
	}


	atexit(glfwTerminate);	//プログラム終了時の処理を登録
	Window window;

	//OpenGL Verison 3.2 Core Profile　を選択する
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR,3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR,2);
	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT,GL_TRUE);
	glfwWindowHint(GLFW_OPENGL_PROFILE,GLFW_OPENGL_CORE_PROFILE);

	Shape* shape = new Shape(2, 4, rectangleVertex);
	
	Shader shader("Test.vert","Test.frag");
	shader.setBindAttribVertex(0, "Position");
	shader.setBindAttribFragment(0, "fragment");


	glClearColor(1.0, 0.0, 0.0, 1.0);	//背景色
	while (window)
	{
		glClear(GL_COLOR_BUFFER_BIT);	//カラーバッファをクリア
		shader.Active();
		

		
		printf(": %d\n", window.getKeyInput(GLFW_KEY_SPACE));

		





		window.SwapBuffers();	//ダブルバッファリング
	}

}

```

```cpp
#include "Window.hpp"

//コンストラクタ
Window::Window(int width, int height, const char* title)
	:window(glfwCreateWindow(width, height, title, NULL, NULL)),
	wheel(0)
{
	std::fill(std::begin(keyStatus),std::end(keyStatus),0);

	if (window == NULL)
	{
		std::cerr << "ウインドウ生成失敗" << std::endl;
		exit(1);
	}

	glfwMakeContextCurrent(window);	//コンテキストを作成

	glewExperimental = GL_TRUE;
	if (glewInit() != GLEW_OK)
	{
		std::cerr << "GLFW 初期化失敗" << std::endl;
		exit(1);
	}

	atexit(glfwTerminate);	//プログラム終了時の処理を登録
	glfwSwapInterval(1);	//垂直同期


	//イベント処理
	glfwSetWindowUserPointer(window, this);	//このインスタンスのthis
	glfwSetWindowSizeCallback(window, Resize);	//ウインドウサイズを変更する時に呼び出す処理
	glfwSetScrollCallback(window,Wheel);		//マウスホイール操作時に呼び出す処理
//////////////////////////////////////////////////////////////////////////////////////////////
	glfwSetKeyCallback(window, KeyBoard);		//キー入力時に呼び出す処理
//////////////////////////////////////////////////////////////////////////////////////////////


	Resize(window, width, height);

}

//サイズ変更
void Window::Resize(GLFWwindow* const win, int width, int height)
{
	int fbWidth, fbHeight;
	glfwGetFramebufferSize(win, &fbWidth, &fbHeight);
	glViewport(0, 0, fbWidth, fbHeight);

	Window* const instance = (Window*)glfwGetWindowUserPointer(win);

	if (instance != NULL)
	{
		instance->size.x = (GLfloat)width;
		instance->size.y = (GLfloat)height;		
	}
}

//ウインドウサイズを取得
const glm::vec2 Window::getSize() const 
{
	return size;
}


//キー入力を取得
const int Window::getKeyInput(int key)const
{
	return keyStatus[key];
}

//マウスホイール
void Window::Wheel(GLFWwindow* win, double x, double y)
{
	Window* const instance = (Window*)glfwGetWindowUserPointer(win);

	if (instance != NULL)
	{
		instance->wheel += (GLfloat)y;
	}
}

/////////////////////////////////////////////////////////////////////////////////////////////////
//キー入力
void Window::KeyBoard(GLFWwindow* win, int key, int scancode, int action, int mods)
{
	Window* const instance = (Window*)glfwGetWindowUserPointer(win);

	if (instance != NULL)
	{	
		instance->keyStatus[key] = action;		
	}
}
////////////////////////////////////////////////////////////////////////////////////////////////

//bool 演算子
Window::operator bool()
{
	glfwPollEvents();	//イベントを取り出す

	//ウインドウを閉じる必要があれば false
	if (glfwWindowShouldClose(window) != 0)
	{
		return false;
	}
	else {
		return true;
	}
}

//ダブルバッファリング
void Window::SwapBuffers()const
{
	glfwSwapBuffers(window);
}

//デストラクタ
Window::~Window()
{
	glfwDestroyWindow(window);
}

```