常連

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

### 実現したいこと

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

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

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

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

##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ですりガラスのようなテクスチャを実装する方法

この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を削除しても発生しました。

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

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