常連

### 実現したいこと
A-FrameでParallax Occulusion Mappingのシェーダーを実装しています。
しかし、作成したコードの出力は期待する結果とは異なっているように見えます。
コードのどの部分が良くないのかわかりません。
どの部分に問題があり、描画がうまくいかないのでしょうか？
動作するコードはこちらに共有しました。
https://glitch.com/edit/#!/a-frame-parallax-occulusion-mapping

作成したコードによる描画結果
![シェーダーの描画結果](https://ddjkaamml8q8x.cloudfront.net/questions/2024-05-05/d47a95d1-e050-4c10-b987-a6823b118c7f.png)

実現したいこと
- [ ] Parallax Occulusion Mappingが適切に描画されるようにする

### 前提

以下のWebサイトを参考にParallax Occulusion Mappingのシェーダーを実装しました。
https://learnopengl.com/Advanced-Lighting/Parallax-Mapping


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

```html
<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <script src="https://aframe.io/releases/1.2.0/aframe.min.js"></script>
    <script src="https://unpkg.com/aframe-environment-component/dist/aframe-environment-component.min.js"></script>
    <script src="./main.js"></script>
    <script>
      AFRAME.registerShader("parallax-occulusion-mapping", {
        schema: {
          uTexture: { type: "map", is: "uniform" }, // テクスチャ
          uDepth: { type: "map", is: "uniform" }, // 深度マップ
          reverse: { type: "bool", is: "uniform", default: true }, // 高さマップを反転するか
          numLayers: {
            type: "float",
            is: "uniform",
            default: 8.0,
            min: 4.0,
            max: 256.0,
          }, // number of depth layers
        },
        vertexShader: `
          varying vec2 vUv;
          varying vec3 vViewPosition;  // ビュー座標系での頂点座標
          void main() {
            // fragment shaderのための変数を計算
            vUv = uv;
            vec4 modelViewPosition = modelViewMatrix * vec4(position, 1.0);
            vViewPosition = modelViewPosition.xyz;
            // vertex shaderの出力を計算
            gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
          }
        `,
        fragmentShader: `
          precision highp float;
          varying vec2 vUv;
          varying vec3 vViewPosition;
          uniform sampler2D uTexture;
          uniform sampler2D uDepth;
          uniform float numLayers;
          uniform bool reverse;
          float getDepth(vec2 xy) { 
            float v = texture2D(uDepth, xy).r;
            if(reverse) return 1.0-v;
            else        return v;
          }
          void main() {
            // 初期化 --------------------------------
            vec3 viewDir = normalize(vViewPosition); // 頂点からカメラへのベクトル
            float STEP_DEPTH = 1.0 / numLayers;  // 各レイヤのサイズ
            vec2 STEP_POS = (viewDir.xy / viewDir.z) * STEP_DEPTH; // レイヤごとのテクスチャ軸方向の、ベクトルPからの移動量

            // deltaを探索 ----------------------------------
            // 探索の初期値
            float currentLayerDepth = 0.0; // レイヤ深さ
            vec2  currentPos     = vUv.xy;  // 衝突後のテクスチャ座標のための変数
            float currentMapDepth = getDepth(currentPos);  // マップ深さ
            float i=0.0;
            for (i = 0.0; i < numLayers; i++)
            {
              currentPos -= STEP_POS;  // P方向にテクスチャ座標を移動
              currentMapDepth = getDepth(currentPos); // 更新した座標で深度値を取得
              currentLayerDepth += STEP_DEPTH;  // 次のレイヤの深度を取得する
              if(currentLayerDepth > currentMapDepth) break;
            }              
            // 線形補完 --------------------------------
            vec2 prevPos = currentPos + STEP_POS; // 衝突前のテクスチャ座標
            float prevLayerDepth = currentLayerDepth - STEP_DEPTH;
            float prevMapDepth = getDepth(prevPos);
            float currentDepthDiff  = currentLayerDepth - currentMapDepth;
            float prevDepthDiff = prevMapDepth - prevLayerDepth;

            // テクスチャ軸の線形補完
            float weight = prevDepthDiff / (prevDepthDiff + currentDepthDiff);
            vec2 finalPos = currentPos + (1.0 - weight) * STEP_POS;

            // 視差マッピングの計算 ------------------------
            // テクスチャを取得
            vec4 color = texture2D(uTexture, finalPos);
            gl_FragColor = color;
          }
        `,
      });
    </script>
  </head>
  <body>
    <a-scene stats loading-screen="dotsColor: gray; backgroundColor: lightgray">
      <a-assets timeout="30000">
        <img
          id="img1"
          src="https://cdn.glitch.global/07ec46d7-6f8d-4aba-88c7-9f2074e79760/ganges_river_pebbles_diff_480p.jpg?v=1714894399240"
        />
        <img
          id="img1_D"
          src="https://cdn.glitch.global/07ec46d7-6f8d-4aba-88c7-9f2074e79760/ganges_river_pebbles_disp_480p.png?v=1714894398359"
        />
      </a-assets>
      <a-camera id="my_camera">
        <a-cursor></a-cursor>
      </a-camera>
      <a-entity environment="preset: default;"></a-entity>
      <a-image
        id="aimg1"
        position="0 1.2 -1"
        scale="1 1 1"
        material="shader:parallax-occulusion-mapping; uTexture:#img1; uDepth:#img1_D;"
      ></a-image>
    </a-scene>
  </body>
</html>
```

### 補足情報（FW/ツールのバージョンなど）
- html5
- A-Frame 1.2.0



A-FrameでParallax Occulusion Mappingのシェーダーを実装したが適切な描画がされない

### 実現したいこと

- [ ] 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のシェーダープログラムを使いたい

### はじめに

現在、Unityでシェーダーに関して勉強中なのですが、Unityでシェーダーを記述する際に用いるシェーダー言語は
HLSL/CG/GLSLの三つがあり、主に使用されているのがHLSL/CGで、GLSLは扱えるものの向いていない（？）という認識です。



### 知りたい事

勉強を進めていく中で、CGは既に開発が終了しているという事を知りました。
また、UnityのUniversalRPの記事ではCGではなくHLSLで記述してあるという内容がありました。

本題ですが上記のことから、今後シェーダーを学び、作成していくならCGではなく、
HLSLを使って記述するべきなのかな？と思っているのですが、多くのお手本と出来そうなシェーダーはCGで記述されている為、勉強して実践する際に上手く置換できるか不安です。

----
**１、HLSLとCGはどの程度互換性があるのか？**

どちらの開発にもNVIDIAが携わっていると書いてあったので、互換性は高いのかなと思っているのですが、
GLSLとHLSLの違いについての記事は見つけたのですが、CGとHLSLの違いについてまとめてある記事は見つかりませんでした。

----
**2、CGでできて、HLSLでできないことはあるのか？（逆もしかり）**

私が見てきた記事では大抵CGとHLSLはひとくくりで紹介されていたのですが、両者の違いは何かしらあると思います。
私が調べた中ではCGはグラフィックスのためのC言語、HLSLはDirectX用、という程度の違いしか分かりませんでした。
そのため、機能的にCGではこんなことが出来るが、HLSLではできないない。（どちらかというと逆かもしれませんが）
という事はあるのでしょうか？

私の調べ不足があるかもしれませんが、この二点に関して教えていただけますでしょうか。

【Unity】【Shader】Shader言語について　HLSL/GLSL/CG

最近のPCゲームは本物と同じくらいリアルなものが増えていますが、拡散色や法線から始まり、フレームバッファや遅延シェーディング等の内部処理をしている事には変わりはないですよね
あらかじめ用意されたテクスチャによるオブジェクト表現やライトマップもあるとしても、格納されるバッファの数だけ高速な処理が必要かと思います

OpenGlで似たような処理をしてみようとしてみたのですが、重くなってしまいます。（ゲームのようなキャラクターの動きやゲームイベントではなく、レンダリング周りの話です。）

おそらくバッファの使い方がまだ甘いのだろうな、とは思っています

glBindBuffer()glBindBufferBase()等を使って、法線やアンビエントオクルージョン等はシェーダで行っています


いったいどうすれば早く出来るのでしょうか。。

３Dレンダリング高速化について。

提示コードですが `error: GLSL 4.20 is not supported. Supported versions are: 1.10, 1.20, 1.30, 1.00 ES, and 3.00 ES` 表示されてしまいます。どうすればに対応できるのでしょうか？その他のバージョン3.3 4.2等を試しましたがどれも対応していません。また1.○○バージョンだとコンパイルエラーになるので使いたくありませんこれはどうやって対応するのでしょうか？
自分の環境は現在4.2まで対応しているのですがどうすればGLSLを4.2に対応できるのでしょうか？


参考サイト： [https://stackoverflow.com/questions/27407774/get-supported-glsl-versions/27410925](https://stackoverflow.com/questions/27407774/get-supported-glsl-versions/27410925)

参考サイト： [https://01.org/linuxgraphics/downloads/stack](https://01.org/linuxgraphics/downloads/stack)


##### 試したこと
別のバージョンで試した。




```
$ glxinfo | grep OpenGL
OpenGL vendor string: Intel Open Source Technology Center
OpenGL renderer string: Mesa DRI Intel(R) HD Graphics 4000 (IVB GT2)
OpenGL core profile version string: 4.2 (Core Profile) Mesa 21.1.5
OpenGL core profile shading language version string: 4.20
OpenGL core profile context flags: (none)
OpenGL core profile profile mask: core profile
OpenGL core profile extensions:
OpenGL version string: 3.0 Mesa 21.1.5
OpenGL shading language version string: 1.30
OpenGL context flags: (none)
OpenGL extensions:
OpenGL ES profile version string: OpenGL ES 3.0 Mesa 21.1.5
OpenGL ES profile shading language version string: OpenGL ES GLSL ES 3.00
OpenGL ES profile extensions:
```

```
$ ./GL
Complie Error: Vertex Shader
0:4(10): error: GLSL 4.20 is not supported. Supported versions are: 1.10, 1.20, 1.30, 1.00 ES, and 3.00 ES
Complie Error: Fragment Shader
0:4(10): error: GLSL 4.20 is not supported. Supported versions are: 1.10, 1.20, 1.30, 1.00 ES, and 3.00 ES
Program Info Log: error: linking with uncompiled/unspecialized shadererror: linking with uncompiled/unspecialized shader
Complie Error: Vertex Shader
0:4(10): error: GLSL 3.30 is not supported. Supported versions are: 1.10, 1.20, 1.30, 1.00 ES, and 3.00 ES
Complie Error: Fragment Shader
0:4(10): error: GLSL 3.30 is not supported. Supported versions are: 1.10, 1.20, 1.30, 1.00 ES, and 3.00 ES
Program Info Log: error: linking with uncompiled/unspecialized shadererror: linking with uncompiled/unspecialized shader
setBindAttribVertex(): -1
setBindAttribVertex(): -1

	glGetError(): 0x502
GL: source/Shader.cpp:261: void FrameWork::Shader::setUniform4f(const char*, glm::vec4): Assertion `0' failed.
中止 (コアダンプ)

```

```
#include "../header/FrameWork.hpp"

#include <iostream>
#include "../header/FrameWork.hpp"
#include "../header/Camera.hpp"


int main()
{
	FrameWork::Init(glm::ivec2(48 * 26, 48 * 18), glm::ivec2(3,3), "Dungeon");	//　初期化
	FrameWork::Camera_2D::Init();	//カメラ初期化

	FrameWork::Circle circle;
	FrameWork::Text text;
	text.setString(30,glm::vec4(255,0,0,255),"Hello World");

	while (*FrameWork::windowContext)
	{
		FrameWork::windowContext->FrameUpdate(glm::vec4(0,0,0,255));

		//circle.Draw(glm::vec2(100,100),glm::vec4(0,255,0,255),100,100,20);
		text.DrawString(glm::vec2(100,100));

		FrameWork::windowContext->Wait();
		FrameWork::windowContext->SwapBuffers();
	}

	return 0;
}

```

```
/*#########################################################################
#
###########################################################################*/
#version 330
#extension GL_ARB_explicit_uniform_location : require

// ######################  ###################### 
layout(location = 0) in vec2 vertexPosition;	
layout(location = 1) in vec2 vertexUV;		


// ###################### ###################### 
layout(location = 1) out vec2 texCoord;

// ###################### Uniform ###################### 
uniform mat4 uViewProjection;	

void main()
{

	vec4 vertex = vec4(vertexPosition.x,vertexPosition.y,0.0,1.0);	
	gl_Position =  (uViewProjection * vertex);
	
	texCoord = vertexUV;

}
```

```
/*#########################################################################
# 
###########################################################################*/
#version 330
#extension GL_ARB_explicit_uniform_location : require

// ###################### ###################### 
layout(location = 1 ) in vec2 texCoord;

// ######################  ###################### 
out vec4 color;

// ###################### Unifrom ###################### 
uniform sampler2D text;   
uniform vec4 uFragment;   

void main()
{    
    vec4 sampled = vec4(1.0, 1.0, 1.0, texture(text, texCoord).r);
    color = uFragment * sampled;
}  
```

GLSLを4.2に対応する方法が知りたい。

この2つのシェーダーはfloat4(u,v,0,1)を返すだけの同じものです。
しかし制作中のプロジェクトでは左、空のプロジェクトでは右のように表示されます。
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-04-10/11c46ecc-2acb-49dd-a3d4-74c3dd128ffd.png)

右はおそらく期待される出力です。左は色の推移が明らかに線形ではありません。
(UVの入力は正常です。float4(0.1.xxx,1)などを返しても、明るい灰色が出力されます。)
この影響のため、ポストプロセスシェーダーが変に明るい色を出力して困っています。
シェーダーは以下のものです。
```
Shader "_Test"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
                return float4(i.uv,0,1);
            }
            ENDCG
        }
    }
}
```
これをreturn col;と置き換えると以下のようになります。
![イメージ説明](https://ddjkaamml8q8x.cloudfront.net/questions/2023-04-10/a6126d0e-8938-45a4-9b46-1cdd04631cdf.png)
こちらはテクスチャの色をそのまま出力するため、値がフラグメントシェーダーに渡される前後になにかの処理が挟まっているんじゃないかと考えています。
この理由と解決策をご存知ないでしょうか。

・両方ともUnity2012.2.11f1 Personal<DX11>、URP 12.1.4です。
・このシェーダーはGLSLですがHLSLでも同じことが起きます。
・ProjectSettings...からSRPSettingsを新規のURPAssetに置き換えるなどを試しましたが、効果ありませんでした。
<追記>
・Package ManagerからURPを削除しても発生しました。

フラグメントシェーダーの色の入出力異常

Unity上の画像を縁取りするための簡単なShaderを書きたいです。
https://mike-neko.github.io/blog/sprite-shader/
上記URLのような2Dのオブジェクトのアウトラインを取りたいのですが、これは影を付け足したりと難易度が高いです。
よりシンプルにアウトラインだけを取るための参考コードとか、指針とかを教えていただきたいです。

Shaderで画像の縁取りをしたい

### 実現したいこと

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"


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