常連

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

### 実現したいこと

GLSLを使用して行列を設定し、三角形を描画したい。

### 前提

Rust言語を使用してOpenGLの学習をしています。 
こちらの[サイト](http://www.opengl-tutorial.org/jp/beginners-tutorials/tutorial-3-matrices/)を参考にして、行列を設定し、三角形を描画するコードを書いたのですが、三角形が描画されませんでした。（行列を設定する前は正しく三角形が描画されていました）


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

main.rs
```Rust
mod program;
mod shader;

use std::ffi::{c_void, CString};
use std::mem::size_of_val;
use gl::types::{GLchar, GLenum, GLfloat, GLint, GLsizei, GLsizeiptr, GLuint};
use gldk::{GLConfig, GLVersion};
use gldk::window::{GLDKWindow, WindowEvent};
use nalgebra_glm::TVec3;
use crate::program::Program;
use crate::shader::Shader;

extern crate nalgebra_glm as glm;

const VS_SRC:&str = include_str!("res/shader.vert");
const FS_SRC:&str = include_str!("res/shader.frag");


pub struct Object {
    vao: GLuint,
    vbo: GLuint
}

impl Object {
    pub fn new(size: u32,count: u32,vertex: &[TVec3<GLfloat>]) -> Self {
        let mut vao = 0;
        let mut vbo = 0;

        unsafe {
            gl::GenVertexArrays(1,&mut vao);
            gl::BindVertexArray(vao);

            gl::GenBuffers(1,&mut vbo);
            gl::BindBuffer(gl::ARRAY_BUFFER,vbo);
            gl::BufferData(gl::ARRAY_BUFFER, (count * size_of_val(vertex) as u32) as GLsizeiptr, vertex.as_ptr() as *const c_void, gl::STATIC_DRAW);

            gl::VertexAttribPointer(0, size as GLint, gl::FLOAT, gl::FALSE, 0, 0 as *const c_void);
            gl::EnableVertexAttribArray(0);
        }

        Self {
            vao,
            vbo
        }
    }

    pub fn bind(&self) {
        unsafe {
            gl::BindVertexArray(self.vao);
        }
    }
}

impl Drop for Object {
    fn drop(&mut self) {
        unsafe {
            gl::DeleteVertexArrays(1,&mut self.vao);
            gl::DeleteBuffers(1,&mut self.vbo)
        }
    }
}

pub struct Shape {
    obj: Object,
    count: u32
}

impl Shape {
    pub fn new(size: u32,count: u32,vertex: &[TVec3<GLfloat>]) -> Self {
        let obj = Object::new(size,count,vertex);
        Self {
            obj,
            count
        }
    }

    pub fn draw(&self,operation:GLenum) {
        self.obj.bind();
        unsafe {
            gl::DrawArrays(operation, 0, self.count as GLsizei);
        }
    }
}


fn main() {
     ~~~
    ウィンドウの作成とコンテキストの作成
     ~~~

    let rectangle = [
        glm::vec3(0.0,0.5,0.0),
        glm::vec3(-0.5,-0.5,0.0),
        glm::vec3(0.5,-0.5,0.0),
    ];

    let vs = Shader::compile(VS_SRC,gl::VERTEX_SHADER);
    let fs = Shader::compile(FS_SRC,gl::FRAGMENT_SHADER);
    let program = Program::new(vs,fs);
    program.use_program();

    let triangle = Shape::new(3, rectangle.len() as u32, &rectangle);

    let projection = glm::perspective(glm::radians(&glm::vec1(45.0)).x,  4.0 / 3.0, 0.1, 100.0);
    let view = glm::look_at(&glm::vec3(4.0,3.0,3.0),
                            &glm::vec3(0.0,0.0,0.0),
                            &glm::vec3(0.0,1.0,0.0) );
    let model = glm::mat4(1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0);

    unsafe {
        let model_id = gl::GetUniformLocation(program.raw(),CString::new("Model").unwrap().as_ptr() as *const GLchar);

        gl::UniformMatrix4fv(model_id,1,gl::FALSE,glm::value_ptr(&model).as_ptr() as *const GLfloat);

        let view_id = gl::GetUniformLocation(program.raw(),CString::new("View").unwrap().as_ptr() as *const GLchar);
        gl::UniformMatrix4fv(view_id,1,gl::FALSE,glm::value_ptr(&view).as_ptr() as *const GLfloat);

        let projection_id = gl::GetUniformLocation(program.raw(),CString::new("Projection").unwrap().as_ptr() as *const GLchar);
        gl::UniformMatrix4fv(projection_id,1,gl::FALSE,glm::value_ptr(&projection).as_ptr() as *const GLfloat);
    }

    ~~~
    // 描画処理
   gl::ClearColor(0.0,0.0,0.0,1.0);
   gl::Clear(gl::COLOR_BUFFER_BIT);
   triangle.draw(gl::TRIANGLES);
    ~~~
}
```

program.rs
```Rust
use std::ffi::CString;
use std::ptr;
use std::ptr::null;
use gl::types::{GLchar, GLint, GLuint};
use crate::shader::Shader;

pub struct Program {
    program: GLuint
}

impl Program {
    pub fn new(vs: Shader,fs: Shader) -> Self {
        unsafe {
            let program = gl::CreateProgram();
            gl::AttachShader(program, vs.inner);
            gl::AttachShader(program, fs.inner);
            gl::LinkProgram(program);
            // Get the link status
            let mut status = gl::FALSE as GLint;
            gl::GetProgramiv(program, gl::LINK_STATUS, &mut status);

            // Fail on error
            if status != (gl::TRUE as GLint) {
                let mut len: GLint = 0;
                gl::GetProgramiv(program, gl::INFO_LOG_LENGTH, &mut len);
                let mut buf = Vec::with_capacity(len as usize);
                buf.set_len((len as usize) - 1); // subtract 1 to skip the trailing null character
                gl::GetProgramInfoLog(
                    program,
                    len,
                    ptr::null_mut(),
                    buf.as_mut_ptr() as *mut GLchar,
                );
                panic!(
                    "{}",
                    std::str::from_utf8(&buf)
                        .ok()
                        .expect("ProgramInfoLog not valid utf8")
                );
            }

            Self {
                program
            }
        }
    }

    pub fn raw(&self) -> GLuint {
        self.program
    }

    pub fn use_program(&self) {
        unsafe {
            gl::UseProgram(self.program);
        }
    }
}
```

shader.rs
```Rust
use std::ffi::CString;
use std::ptr;
use gl::types::{GLchar, GLenum, GLint, GLuint};

pub struct Shader {
    pub(crate) inner: GLuint
}

impl Shader {
    pub fn compile(src: &str, ty: GLenum) -> Self {
        let shader;
        unsafe {
            shader = gl::CreateShader(ty);
            // Attempt to compile the shader
            let c_str = CString::new(src.as_bytes()).unwrap();
            gl::ShaderSource(shader, 1, &c_str.as_ptr(), ptr::null());
            gl::CompileShader(shader);

            // Get the compile status
            let mut status = gl::FALSE as GLint;
            gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut status);

            // Fail on error
            if status != (gl::TRUE as GLint) {
                let mut len = 0;
                gl::GetShaderiv(shader, gl::INFO_LOG_LENGTH, &mut len);
                let mut buf = Vec::with_capacity(len as usize);
                buf.set_len((len as usize) - 1); // subtract 1 to skip the trailing null character
                gl::GetShaderInfoLog(
                    shader,
                    len,
                    ptr::null_mut(),
                    buf.as_mut_ptr() as *mut GLchar,
                );
                panic!(
                    "{}",
                    std::str::from_utf8(&buf)
                        .ok()
                        .expect("ShaderInfoLog not valid utf8")
                );
            }
        }

        Self {
            inner: shader
        }
    }
}
```

shader.vert
```GLSL
#version 150 core
in vec4 position;
out vec4 vs_color;

uniform mat4 Model;
uniform mat4 View;
uniform mat4 Projection;

void main() {
    const vec4 colors[] = vec4[3](vec4(1.0, 0.0, 0.0, 1.0),
    vec4(0.0, 1.0, 0.0, 1.0),
    vec4(0.0, 0.0, 1.0, 1.0));

    vs_color = colors[gl_VertexID];

    gl_Position = Projection * View * Model * position;
}
```

shader.frag
```GLSL
#version 150

out vec4 color;
in vec4 vs_color;

void main(void)
{
    color = vs_color;
}
```

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

使用クレート
gl = "0.14.0"
nalgebra-glm = "0.18.0"


よろしくお願いいたします


GLSLで行列を設定できない

提示コードですが下記のコメント部内部の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

### 概要

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ファイルが参照できない

提示画像ですが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);
}

```

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

### 実現したいこと
stdarg.hによって定義された関数va_startを正しく実行するために、エラーコードC2338を解消したい。


### 前提

現在VisualStudioにて、Youtube上にアップされた動画でOpenGLを学習しています。エラーが出てしまったのはこちらの動画（https://www.youtube.com/watch?v=mnH_w0rkndY&list=PL8_ASIpg7ciG3btmV6RElRjmWrfAL0q2P&index=7&t=941s）の12:20からのfontDrawという関数を書く部分になります。私自身が初心者なこともあり、どうやって解決すればいいのか分からずに詰まってしまっています。是非お力添えをいただきたいです。

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

```

エラーコード：C2338
説明：static_assert failed: 'va_start argument must not have reference type and must not be parenthesized'	

この説明文はvades.hというヘッダファイルに入っているメッセージで、エラーを読み取ると出てくる仕組みになっているようです。以下がそのヘッダファイル中の該当部分です。

struct __vcrt_assert_va_start_is_not_reference
        {
            static_assert(!__vcrt_va_list_is_reference<_Ty>::__the_value,
                "va_start argument must not have reference type and must not be parenthesized");
        };

```

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

```
void fontDraw(const char *format, ...) {
	va_list argList;
	va_start(argList, *format);
	char str[256];
	vsprintf_s(str, format, argList);
	va_end(argList); 
};

```



### 補足情報
使用ツール：Visual Studio Community 2022

可変長引数を含む関数va_startについてのエラーを解消したい

提示コードなのですが画像を読み込むコードで以下のコンソール画面の実行時エラーが発生します。なぜ`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) });

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

*/
```

