常連

### はじめに

現在、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レンダリング高速化について。

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

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

提示コードですが `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に対応する方法が知りたい。

##Three.jsのPlaneBufferGeometryにすりガラスのようなテクスチャを実装したいです。
イメージはCSSの
```css
filter: blur(20px);
```
のように、重なっている領域がぼやけるような状態です。
参考：[https://codepen.io/kylewetton/pen/bGbaazX](https://codepen.io/kylewetton/pen/bGbaazX)


[公式ドキュメント](https://threejs.org/docs/#api/en/materials/MeshPhongMaterial)で、MeshPhongMaterialのemvMapにテクスチャキューブを適用してガラスのような表現ができることは分かったのですが、すりガラスのように奥がぼやける処理の方法がわかりません。

もしくは自分でシェーダーを書くことで実装できると予想しているのですが、「こうすれば良い」といった最低限のサンプルが見つからず、どなたかご教示いただけますと幸いです。

Three.jsですりガラスのようなテクスチャを実装する方法

```GLSL
// valueを5回累乗する
pow(value, 5.0);
```
フラグメントシェーダー(ピクセルカラーを司る様分割したシェーダーファイル)にて光の加減などを調整するためにpow関数を使用して累乗しているコードがありました。
それと同時になぜかフラグメントシェーダー部位における描画パフォーマンスが著しく不安定となる症状に悩まされてました。

フラグメントシェーダー部位にて軽量化のためコードを見直し、pow関数を使用せず必要な回数分だけ乗算していくスタイルへと書き換えました。

すると描画が著しく安定しました。

GLSLっというよりOpenGLという規格から見てどの関数においても各々のGPUにて処理が最適かされるという先入観を持っていたのですが、どうやらそういうわけでもないのかもしれません。

---
長い前置きでしたが質問です。
##### GLSLにおいてpow関数は不安定化しやすい関数という認識は正しいでしょうか？それともたまたま私のGPUがpow関数の最適化を行えていないのでしょうか？

このパフォーマンスの改善についての根拠が知りたいので、もしわかる方がいましたら教えてください。


---
※__ちなみに描画が安定しないというのはFPS値が著しく上がったり下がったりを繰り返すという意味です。__

GLSL pow関数は不安定な関数なのでしょうか

### 実現したいこと

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

### 前提・実現したいこと

OpenGLとGLFWを使ってシェーダープログラミングをしています。
シェーダのソースファイルを読み込んでコンパイル、リンクする関数を作成しているのですが、フラグメントシェーダのコンパイルで失敗してしまいます。
glslはversion 120を使用しています。

### 発生している問題・エラーメッセージ
実行結果の全文です。

`glGetShaderInfoLog()`を使用してフラグメントシェーダのコンパイルログを取得した結果、`0:1: '<' : syntax error: syntax error`と表示されています。
```
read vertex file succeeded !
vertex shader compile succeeded !
read fragment file succeeded !
ERROR::SHADER::FRAGMENT::COMPILATION_FAILEDERROR: 0:1: '<' : syntax error: syntax error

ERROR::SHADER::PROGRAM::LINKAGE_FAILEDERROR: One or more attached shaders not successfully compiled

1 2 shader program: 3
```
こちらは、シェーダのソースプログラムを読み込んで表示した結果です。
```
read vrt_shader: 
#version 120

varying vec3 normal;

void main(){
    gl_Position = ftransform();
    normal = vec3(gl_NormalMatrix * gl_Normal);
}

read frg_shader: 
#version 120

varying vec3 normal;
void main(){
    gl_FragColor = vec4(0.5*normal + 0.5, 1);
}
```

### 該当のソースコード

```C++
std::string read_shader_file(std::string &f)
{
    std::string source;
    source.clear();

    std::ifstream fin;
    fin.open(f);
    if(fin.fail())
        std::cout << "shader source file open failed" << std::endl;
    
    const int BUFF_SIZE = 1024;
    char buff[BUFF_SIZE];
    
    while (!fin.eof()){
        fin.getline(buff, BUFF_SIZE);
        source += buff;
        source += "\n";
    }
    source.pop_back();
    source += "\0";

    return source;
}

int use_shader(std::string &vrt_path,
               std::string &frg_path)
{
    const char *glslvrt = (read_shader_file(vrt_path)).c_str();
    const char *glslfrg = (read_shader_file(frg_path)).c_str();
    
    std::cout << "read vrt_shader: " << std::endl;
    std::cout << read_shader_file(vrt_path) << std::endl;
    std::cout << "read frg_shader: " << std::endl;
    std::cout << read_shader_file(frg_path) << std::endl;
    
    if (glslvrt == NULL){
        std::cout << "Could not read file: " << vrt_path << std::endl;
        return -1;
    }
    else std::cout << "read vertex file succeeded !" << std::endl;
    int vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &glslvrt, nullptr);
    glCompileShader(vertexShader);
    int success;
    char infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(vertexShader, 512, nullptr, infoLog);
        std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED" << infoLog << std::endl;
    }
    else std::cout << "vertex shader compile succeeded !" << std::endl;
    
    
    if (glslfrg == NULL){
        std::cout << "Could not read file: " << frg_path << std::endl;
        return -1;
    }
    else std::cout << "read fragment file succeeded !" << std::endl;
    int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &glslfrg, nullptr);
    glCompileShader(fragmentShader);
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(fragmentShader, 512, nullptr, infoLog);
        std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED" << infoLog << std::endl;
    }
    else std::cout << "fragment shader compile succeeded !" << std::endl;

    shaderProgram = glCreateProgram(); //プログラムのIDを取得
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if(!success){
        glGetProgramInfoLog(shaderProgram, 512, nullptr, infoLog);
        std::cout << "ERROR::SHADER::PROGRAM::LINKAGE_FAILED" << infoLog << std::endl;
    }
    else std::cout << "shader program linkage succeeded !" << std::endl;
    std::cout << vertexShader << " " << fragmentShader << " shader program: " << shaderProgram << std::endl;
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);
    
    glUseProgram(shaderProgram);
    return -1;
}
```

### 試したこと

フラグメント、バーテックスシェーダプログラム含めて全てmain関数に直接書いていた時には正しくシェーダをコンパイルできていましたが、シェーダソースプログラムを別ファイルに分け、シェーダ関連の操作を関数に分けたところ、コンパイルがうまくいかなくなってしまいました。

コンパイルできていた時も同じフラグメントシェーダを書いていたので、シェーダプログラムの中身自体ではなく読み込みなどの段階で問題があると思うのですが、エラーメッセージなどを調べても解決には至りませんでした。

### 補足情報（FW/ツールのバージョンなど）
glslは "version 120" を使っています。