常連

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か？？

### 実現したいこと

gluLookAt(eyeX,eyeY,eyeZ,centerX,centerY,centerZ,upX,upY,upZ)
で求めたカメラの位置と姿勢があります。
eyeはワールド座標系のカメラの位置、
centerはワールド座標系の目視点、
upはワールド座標系のカメラの上方向を表しています。


この状態で、カメラを球体座標上で回転させたり、回転させず平行移動のみでしたらできますが、回転した後に平行移動をさせると画面のx,y軸ではなく、おそらくカメラ座標系の軸をもとにした動きをしてしまいます。
理想的なカメラの動きは、Blenderなどで、視点の中心に立方体をおいて、その立方体を360度眺めたり、平行移動したりした時の動きです。
このような動きを実装するにはどうしたらよいでしょうか。

追記

遅れてすみません。
質問には、glLookAtを使ってと書きましたが、私はこちらの資料をGLFWによるOpenGL入門https://tokoik.github.io/GLFWdraft.pdf
を参考にプログラムを書きました。こちらの資料では、glLookAt関数と同様の処理をlookAt関数を作成しました。

![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-06-19/67bad348-79e8-4645-9054-4367c85b3735.png)

posにマウスの増加量を示すlocationを使って、球体座標のような座標を作成しています。
この処理で、マウスを動かすことで、立方体を中心とした球の表面をカメラが沿うような動きをさせています。

上のlookAt関数の引数や機能はgluLookAt関数と同じだと思われます。第1から第3引数にカメラの座標、第4から第6引数にカメラの視線を向かせる方向を示す座標、第7から第9引数にカメラの上方向を示す座標です。
今回は、球に沿った座標を入れたposがカメラの座標となり、視線が原点を向き続けることで、原点周辺にある、立方体を360度眺めることができています。

![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-06-19/0fd42649-42be-481b-a756-eca395d62906.png)![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-06-19/3e59e5b2-5967-4937-8a34-183834504d4d.png)
画像では位置や大きさが変わっているように見えますが、実際にはその場で大きさも変わらずに、カメラが立方体の周囲を回りこんだような出力が得られています。

現在のプログラムでは行っていませんが、カメラを平行移動のみさせることはできます。
ただ、カメラを球面座標を用いた移動をさせた後に、通常のx,y座標軸ではなくカメラの姿勢に沿った平行移動をさせようとすると、カメラの姿勢に沿った座標軸ではないのか、もしかしたら通常のx,y座標軸に沿った移動をしてるのか、画像の立方体が大きさや回転によって見えている面が変わらず、画像の立方体をトリミングして左に動かしたかのような平行移動をさせたいのですが、うまくいきません。

実際の動き
![![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-06-19/159e29ec-e2df-42bf-a7e9-d062ca75a2aa.png)](https://ddjkaamml8q8x.cloudfront.net/questions/2023-06-19/b8f39d0d-0580-44f3-8ff9-6a7afa8d40df.png)![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-06-19/d80bcd86-190f-45cc-b5f5-81d30a31915a.png)
上の画像はマウスを右に動かす前、下の画像はマウスを右に動かした後。

理想の動き
実際にBlenderというソフトを使用して、私が作成しているソフトにしてほしい動作の様子を再現しました。
私は以下の動画のようなカメラの動きを実装したいです。
動画のリンクです。
https://youtu.be/fB5qPW6og8U

OpenGLでBlenderみたいにカメラを動かしたい

提示コードですが下記のコメント部内部のCamera.cpp部のコードですがなぜ`has no member named ‘Renderer’itr.Renderer(getViewProjection());`
と表示されるのでしょうか？しっかりと定義されているのですが？






##### Actor.hpp
```
#ifndef ___ACTOR_HPP___
#define ___ACTOR_HPP___

#include <memory>
#include <GL/glew.h>

#include "../../FrameWork/header/Resource.hpp"
#include "../../FrameWork/header/Shader.hpp"
#include "../../FrameWork/header/Model.hpp"

class Actor
{
public:

      Actor();
      ~Actor();

      virtual void Update();
      //virtual void Update() = 0;
      //virtual void Renderer(glm::mat4 view)const = 0;
      virtual void Renderer(glm::mat4 view)const;
      
      
      std::shared_ptr<FrameWork::D3::Object> model;
protected:
      FrameWork::ObjFile file;



};

#endif
```

##### Actor.cpp
```
#include "../header/Actor.hpp"

Actor::Actor()
{
      
}


void Actor::Update()
{

}

void Actor::Renderer(glm::mat4 view)const
{

}
      



Actor::~Actor()
{

}

```




##### Camera.cpp
```

void FrameWork::Camera::Renderer()
{

	glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// 1. draw scene as normal in multisampled buffers
	glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
	glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_BLEND);						//ブレンド有効
	glEnable(GL_TEXTURE_2D);					//テクスチャを有効
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);	//ブレンドタイプ
	glEnable(GL_MULTISAMPLE);				   	//MSAA
	glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);			//半透明
	glEnable(GL_DEPTH_TEST);				   	//深度バッファを有効
	glDepthFunc(GL_LEQUAL);
	glEnable(GL_CULL_FACE);					   	//カリングを有効
	glCullFace(GL_BACK);					   	//裏面を無効

/////////////////////////////////////////////////////////////////////////////////////////
	for(std::vector<std::shared_ptr<Actor>>::iterator itr = actor.begin(); itr != actor.end(); itr++)
	{
		
		itr->Renderer(getViewProjection());
		
	}
/////////////////////////////////////////////////////////////////////////////////////////



	glBindFramebuffer(GL_READ_FRAMEBUFFER, framebuffer);
	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, intermediateFBO);
	glBlitFramebuffer(0, 0, FrameWork::windowContext->getSize().x, FrameWork::windowContext->getSize().y, 0, 0, FrameWork::windowContext->getSize().x, FrameWork::windowContext->getSize().y, GL_COLOR_BUFFER_BIT, GL_NEAREST);

	glBindFramebuffer(GL_FRAMEBUFFER, 0);
	glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT);
	glDisable(GL_DEPTH_TEST);

	shader->setEnable();
	glBindVertexArray(quadVAO);
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, screenTexture);
	glDrawArrays(GL_TRIANGLES, 0, 6);
	shader->setDisable();

	glBindVertexArray(0);
	glBindTexture(GL_TEXTURE_2D,0);



}

```

定義しているのに[has no member named ] と表示される原因がわからない。

###前提・実現したいこと

相対パスで参照できず困っています。ｃ++で画像ファイルを相対パスで参照したいのですがうまくいきません。開発環境はMacBook,Xcode,OpenGLを使っています。
###該当のソースコード
    /* テクスチャの読み込みに使う配列 */
    GLubyte texture[TEXHEIGHT][TEXWIDTH][3];
    FILE *fp;
  
    /* テクスチャ画像の読み込み */
    if ((fp = fopen("sample2.data", "rb")) != NULL) {
        fread(texture, sizeof texture, 1, fp);
        fclose(fp);
    }
    else {
        perror("sample2.data");
    }

絶対パスを使い"/Users/username/Desktop/sample2.data"のように書くと参照できました。画像データはメインファイルと同じフォルダに入れています。.txtファイルでも同様の現象が起こりました。原因がわからず困っています。どうかよろしくお願いします。

相対パスでの参照がうまくいきませんm(_ _)m

提示画像ですがGLSLシェーダーを用いたプログラムを作成していると以下のようなエラーがプログラムを終了すると発生ます。これはどいったことが原因として挙げられるのでしょうか？何回かに一回は普通に実行できるのですがたまにこいったエラーが表示されます。調査した結果コンストラクタのこの関数が悪いのですがなぜなのでしょうか？原因がどうしてもわかりません。



エラー原文[CRT detected that the application wrote to memory after end of heap buffer]
google翻訳[ CRT は、アプリケーションがヒープ バッファの終了後にメモリに書き込んだことを検出しました。 ]




![イメージ説明](d2aba1de7dff1f159d0e0ec6c3d2c46b.png)


```cpp

//コンストラクタ
FrameWork::Sprite::Sprite(std::shared_ptr<Window> w,const char* vert,const char* frag) : Transform_2D(),Shader()
{
	windowContext = w;	//ウインドウコンテキスト

	//シェーダー読み込み
	if (vert == NULL && frag == NULL)
	{
		vert = "Shader/2D/BasicTexture_2D.vert";
		frag = "Shader/2D/BasicTexture_2D.frag";
		LoadShader(vert, frag);	//シェーダーロード

		isDefaultShader = true;
	}
	else 
	{
		std::cout << "個別のシェーダーが読み込まれました。" << std::endl;
		LoadShader(vert, frag);
		isDefaultShader = false;
	}

	//テクスチャ関係	
	textureID = std::vector<TextureData>(0);	//テクスチャーデータ
	textureUnitCount = 0;						//テクスチャユニット数をカウント
	
	//vao
	glGenVertexArrays(1, &vao);
	glBindVertexArray(vao);

	//vbo
	glGenBuffers(1, &vbo);
	glBindBuffer(GL_ARRAY_BUFFER, vbo);

	//頂点	
	GLint attrib = getAttribLocation("vertexPosition");
	glEnableVertexAttribArray(attrib);
	glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(VertexUV), rectangleVertex, GL_DYNAMIC_DRAW);
	glVertexAttribPointer(attrib, 2, GL_FLOAT, GL_FALSE, 7 * sizeof(GLfloat), (GLvoid*)0);
	setBindAttribVertex("vertexPosition");

	//UV
	attrib = getAttribLocation("vertexUV");
	glEnableVertexAttribArray(attrib);
	glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(VertexUV), rectangleVertex, GL_DYNAMIC_DRAW);
	glVertexAttribPointer(attrib, 2, GL_FLOAT, GL_FALSE, 7 * sizeof(GLfloat), (GLvoid*)(sizeof(GLfloat) * 5));
	setBindAttribVertex("vertexUV");


	//法線
	attrib = getAttribLocation("vertexNorm");
	glEnableVertexAttribArray(attrib);
	glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(VertexUV), rectangleVertex, GL_DYNAMIC_DRAW);
	glVertexAttribPointer(attrib, 3, GL_FLOAT, GL_FALSE, 7 * sizeof(GLfloat), (GLvoid*)(sizeof(GLfloat) * 3));
	setBindAttribVertex("vertexNorm");




	//アルファブレンド有効
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}

```

メモリアクセス違反が発生する原因がどうしてもわからない。

### 実現したいこと

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

### 前提
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で四角形が表示されない

### 概要

VisualStudio2022上でGLUTを用いてOpenGLを動かそうとしたところ、GLUTの.dllファイルと.libファイルが参照できず失敗してしまいました。
### 詳細
こちらの動画([https://www.youtube.com/watch?v=wtC03LR3VFo])を参考にGLUTの導入を行いました。

まず、空のプロジェクトとその中にソースファイルを作成し、ヘッダファイルインクルードしてから描画用のウィンドウを出力するプログラムを書きました。最後にローカルwindowsデバッガーで実行したところ、エラーコードLNK2019を吐いてビルドに失敗してしまいました。

LNK2019は「未解決の外部シンボルの参照」の際に出るエラーコードであり、恐らくGLUTのヘッダファイルglut.hが参照するライブラリ"glut32.bin"と"glut32.dll"が正しく参照できていないことが原因であると考えられます。
### 実現したいこと

ライブラリを参照できるようにし、OpenGLを動かしたい。

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

LNK2019	未解決の外部シンボル __imp___glutInitWithExit が関数 glutInit_ATEXIT_HACK で参照されました	

↑これと同様のエラーが複数出ている感じです。

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

#include "glut.h"

void display(void) {

}
int main(int argc, char* argv[]) {
	glutInit(
		&argc,
		argv
	);
	glutInitWindowPosition(640, 0);
	glutInitWindowSize(640, 640);
	glutCreateWindow("title");
	glutDisplayFunc(display);
	glutMainLoop();
};

### 試したこと

https://corgi-lab.com/windows/vs-external-library/
こちらのサイトに書いてある方法を試しましたが、それでもうまくいきませんでした。具体的には、以下のような3ステップを行いました。

**①**プロジェクトの「プロパティ」→「リンカー」→「全般」にある「追加のライブラリディレクトリ」から、.libファイルが置いてある場所を指定。

**②**プロジェクトの「プロパティ」→「全般」にある「出力ディレクトリ」から、.dllファイルの置いてある場所を指定。

**③**プロジェクトの「プロパティ」→「C/C++」→「全般」にある「追加のインクルードディレクトリ」から、.hファイルが置いてある場所を指定。（おそらく.hファイルのインクルードには成功している？）
### 補足情報（FW/ツールのバージョンなど）

使用した環境：VisualStudio2022


.libファイルと.dllファイルが参照できない

提示コードなのですが画像を読み込むコードで以下のコンソール画面の実行時エラーが発生します。なぜ`invalid size`になるのでしょうか？`prite = FrameWork::LoadTexture("asset/texture/brickChip.png");` をコメントアウトすると実行できるためこの関数が原因なのでは事実です。メモリ確保エラーのメッセージと思われます。



##### 確認したこと
逐次実行でFrameWork::LoadTexture()関数が原因であることが判明　※コメントアウトして実行して確認
画像ファイルが読み込まれていること。画像ファイルが存在していることを確認
参考サイトAより
日本語訳
```
エラーを検索すると、Cプログラミングでよくあるエラーであることがわかります。プログラムが割り当てられたメモリ（文字列や動的配列、または自分で割り当てたもの）で範囲外になっていることを意味しているようです。（ただし、-exxがキャッチしない場合は、おそらく配列ではありません。）

gdbなどのデバッガーで詳細を確認できるはずです。
-gを指定してコンパイルし、gdbにロードしてプログラムを「実行」すると、その時点で停止し、行番号が表示されるか、バックトレース（「bt」）してどの関数を確認できるかがわかります。コードが実行されていました。
```
とあるのですがbtコマンドでトレースしました。
LoadTexture()関数の//stbi_image_free(texture.data);のコメントアウトを解除してDeleteTexture() 関数の//stbi_image_free(texture.data);をコメントアウトすると`double free or corruption (!prev)` というエラーが出ます。



参考サイトA：https://www.freebasic.net/forum/viewtopic.php?t=29372#:~:text=Re%3A%20malloc()%3A%20invalid%20size%20(unsorted)&text=It%20looks%20like%20it%20means,able%20to%20tell%20you%20more.
参考サイトB：　https://stackoverflow.com/questions/2902064/how-to-track-down-a-double-free-or-corruption-error

#####  コンソール画面
```
$ ./Game
ああ
ああ
malloc(): invalid size (unsorted)
中止 (コアダンプ)

```

##### gdbデバッグ画面
```
(gdb) run
Starting program: /home/shigurechan/prg/2D_GameProject/Game/Game 
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
[New Thread 0x7fffece88700 (LWP 37573)]
[New Thread 0x7fffe7fff700 (LWP 37574)]
ああ
ああ
malloc(): invalid size (unsorted)

Thread 1 "Game" received signal SIGABRT, Aborted.
__GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:50
50	../sysdeps/unix/sysv/linux/raise.c: そのようなファイルやディレクトリはありません.
(gdb) bt
#0  __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:50
#1  0x00007ffff79ab859 in __GI_abort () at abort.c:79
#2  0x00007ffff7a1629e in __libc_message (action=action@entry=do_abort, fmt=fmt@entry=0x7ffff7b40298 "%s\n")
    at ../sysdeps/posix/libc_fatal.c:155
#3  0x00007ffff7a1e32c in malloc_printerr (str=str@entry=0x7ffff7b42a50 "malloc(): invalid size (unsorted)")
    at malloc.c:5347
#4  0x00007ffff7a210e4 in _int_malloc (av=av@entry=0x7ffff7b75b80 <main_arena>, bytes=bytes@entry=10048)
    at malloc.c:3736
#5  0x00007ffff7a232c9 in __GI___libc_malloc (bytes=10048) at malloc.c:3066
#6  0x00007ffff7db4b39 in operator new(unsigned long) () from /lib/x86_64-linux-gnu/libstdc++.so.6
#7  0x0000555555578a97 in __gnu_cxx::new_allocator<std::_Sp_counted_ptr_inplace<Generate_Dungeon, std::allocator<Generate_Dungeon>, (__gnu_cxx::_Lock_policy)2> >::allocate (this=<optimized out>, __n=1)
    at /usr/include/c++/9/ext/new_allocator.h:102
#8  std::allocator_traits<std::allocator<std::_Sp_counted_ptr_inplace<Generate_Dungeon, std::allocator<Generate_Dungeon>, (__gnu_cxx::_Lock_policy)2> > >::allocate (__a=..., __n=1) at /usr/include/c++/9/bits/alloc_traits.h:443
#9  std::__allocate_guarded<std::allocator<std::_Sp_counted_ptr_inplace<Generate_Dungeon, std::allocator<Generate_Dungeon>, (__gnu_cxx::_Lock_policy)2> > > (__a=...) at /usr/include/c++/9/bits/allocated_ptr.h:97
#10 std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<Generate_Dungeon, std::allocator<Generate_Dungeon>>(Generate_Dungeon*&, std::_Sp_alloc_shared_tag<std::allocator<Generate_Dungeon> >) (__a=..., __p=<optimized out>, 
    this=<optimized out>) at /usr/include/c++/9/bits/shared_ptr_base.h:677
#11 std::__shared_ptr<Generate_Dungeon, (__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<Generate_Dungeon>>(std::_Sp_alloc_shared_tag<std::allocator<Generate_Dungeon> >) (__tag=..., this=<optimized out>)
    at /usr/include/c++/9/bits/shared_ptr_base.h:1344
#12 std::shared_ptr<Generate_Dungeon>::shared_ptr<std::allocator<Generate_Dungeon>>(std::_Sp_alloc_shared_tag<std::allocator<Generate_Dungeon> >) (__tag=..., this=<optimized out>) at /usr/include/c++/9/bits/shared_ptr.h:359
#13 std::allocate_shared<Generate_Dungeon, std::allocator<Generate_Dungeon>>(std::allocator<Generate_Dungeon> const&)
    (__a=...) at /usr/include/c++/9/bits/shared_ptr.h:702
#14 std::make_shared<Generate_Dungeon> () at /usr/include/c++/9/bits/shared_ptr.h:718
#15 Stage::Stage (this=0x555555e72a10) at source/Stage.cpp:10
#16 0x000055555557729a in __gnu_cxx::new_allocator<Stage>::construct<Stage> (this=<optimized out>, 
    __p=0x555555e72a10) at /usr/include/c++/9/new:174
#17 std::allocator_traits<std::allocator<Stage> >::construct<Stage> (__a=..., __p=0x555555e72a10)
    at /usr/include/c++/9/bits/alloc_traits.h:483
#18 std::_Sp_counted_ptr_inplace<Stage, std::allocator<Stage>, (__gnu_cxx::_Lock_policy)2>::_Sp_counted_ptr_inplace<>(std::allocator<Stage>) (__a=..., this=0x555555e72a00) at /usr/include/c++/9/bits/shared_ptr_base.h:548
#19 std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<Stage, std::allocator<Stage>>(Stage*&, std::_Sp_alloc_shared_tag<std::allocator<Stage> >) (__a=..., __p=<optimized out>, this=<optimized out>)
    at /usr/include/c++/9/bits/shared_ptr_base.h:679
#20 std::__shared_ptr<Stage, (__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<Stage>>(std::_Sp_alloc_shared_tag<std::allocator<Stage> >) (__tag=..., this=<optimized out>) at /usr/include/c++/9/bits/shared_ptr_base.h:1344
#21 std::shared_ptr<Stage>::shared_ptr<std::allocator<Stage>>(std::_Sp_alloc_shared_tag<std::allocator<Stage> >) (
    __tag=..., this=<optimized out>) at /usr/include/c++/9/bits/shared_ptr.h:359
#22 std::allocate_shared<Stage, std::allocator<Stage>>(std::allocator<Stage> const&) (__a=...)
--Type <RET> for more, q to quit, c to continue without paging--
    at /usr/include/c++/9/bits/shared_ptr.h:702
#23 std::make_shared<Stage> () at /usr/include/c++/9/bits/shared_ptr.h:718
#24 Game::Game (this=0x55555578d2c0) at source/Game.cpp:9
#25 0x0000555555576f47 in __gnu_cxx::new_allocator<Game>::construct<Game> (this=<optimized out>, __p=0x55555578d2c0)
    at /usr/include/c++/9/new:174
#26 std::allocator_traits<std::allocator<Game> >::construct<Game> (__a=..., __p=0x55555578d2c0)
    at /usr/include/c++/9/bits/alloc_traits.h:483
#27 std::_Sp_counted_ptr_inplace<Game, std::allocator<Game>, (__gnu_cxx::_Lock_policy)2>::_Sp_counted_ptr_inplace<>(std::allocator<Game>) (__a=..., this=0x55555578d2b0) at /usr/include/c++/9/bits/shared_ptr_base.h:548
#28 std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<Game, std::allocator<Game>>(Game*&, std::_Sp_alloc_shared_tag<std::allocator<Game> >) (__a=..., __p=<optimized out>, this=<optimized out>)
    at /usr/include/c++/9/bits/shared_ptr_base.h:679
#29 std::__shared_ptr<Game, (__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<Game>>(std::_Sp_alloc_shared_tag<std::allocator<Game> >) (__tag=..., this=<optimized out>) at /usr/include/c++/9/bits/shared_ptr_base.h:1344

(gdb) 


```




```cpp
Stage::Stage()
{
    sprite = FrameWork::LoadTexture("asset/texture/brickChip.png");

    dungeon = std::make_shared<Generate_Dungeon>();
    dungeon->GetStage(grid);    //ダンジョン生成
}

```

```cpp
// ##################################### テクスチャをロード ##################################### 
FrameWork::Texture FrameWork::LoadTexture(const char* fileName)
{
    Texture texture;

    glm::ivec2 size;
    int channel;

    unsigned char* data = NULL;
    data = stbi_load(fileName, &size.x, &size.y, &channel, 0);
    texture.size = size;

    if (data == NULL)
    {
        std::cerr << "画像が見つかりません: " << fileName << std::endl;
        assert(0);
    }

    glGenTextures(1, &texture.ID);            //テクスチャIDの生成
    glBindTexture(GL_TEXTURE_2D, texture.ID); // IDバインド

    //テクスチャ生成

    if (channel == 4)
    {
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size.x, size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
    }
    else if (channel == 3)
    {
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, size.x, size.y, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
    }
    else if (channel == 2)
    {
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RG, size.x, size.y, 0, GL_RG, GL_UNSIGNED_BYTE, data);
    }
    else if (channel == 1)
    {
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, size.x, size.y, 0, GL_RED, GL_UNSIGNED_BYTE, data);
    }
    else
    {
        std::cerr << "未対応の形式のチャンネル数です: " << fileName <<"    "<< "チャンネル数: "<<channel<< std::endl;
        assert(0);
    }

    // テクスチャの補間設定
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glBindTexture(GL_TEXTURE_2D, 0);

    texture.data = data;

    printf("ああ\n");


    //stbi_image_free(texture.data);
    return texture;

}



// ##################################### テクスチャを削除 ##################################### 
void FrameWork::DeleteTexture(FrameWork::Texture texture)
{
    glDeleteTextures(1,&texture.ID);
    //stbi_image_free(texture.data);
    //texture.data = NULL;
}



```

##### Genrate_Dungeon.cpp
```cpp

Generate_Dungeon::Generate_Dungeon()
{
    area.resize(0);
    area.push_back(Area { 100 * 100,glm::ivec2(0,0),glm::ivec2(100,100) });

}
/*
文字数の関係で省略

*/
```

