常連

GLSL初心者です。
フラグメントシェーダー というものが、描画領域を1pxずつ処理する、ということは
理解できるのですが、以下のコードで、白いグラデーションの玉が２つ描画される理由がよくわかりません。
結局gl_FragColorにセットされるのはひとつのvec4なのに、
なぜループすると２つの玉が描画されるのでしょうか....。

```GLSL
precision mediump float;
uniform vec2  r; // resolution

void main(void){
    vec2 p = (gl_FragCoord.xy * 2.0 - r) / min(r.x, r.y);
    vec3 destColor = vec3(0.0);
    for(float i = 0.0; i < 2.0; i++){
        float j = i + 1.0;
        vec2 q = p + vec2(cos(j), sin(j)) * 0.5;
        destColor += 0.01 / length(q);
    }
    gl_FragColor = vec4(destColor, 1.0);
}
```

わかりやすい説明をお願いしたいです。

GLSLのループについて

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

レイマーチングを勉強しており、以下を参考にコードを写経しています。
https://neort.io/product/bvcrf5s3p9f7gigeevf0

その中で、以下のようなコードが書かれていました。

```
float map(vec3 p){
  ...
}

void main() {
  ...
  float d=1.,i;
  for(;++i<99.&&d>.001;)p+=rd*(d=map(p));
  ...
}

```

この `for(;++i<99.&&d>.001;)p+=rd*(d=map(p));` について何をしているか分からず調べてみたのですが、参考になりそうなドキュメントを見つけることができませんでした。

想像で「こんなことをしているのかな」とコードを適当に書き換えてみたのですが、書き換える前とは異なる結果になりました。

```
for( float i=0.; i<99.&&d>.001; i++) {
  p+=rd*(d=map(p));
}
```

このfor文ではどのようなことが起きているのか、分かる方がいましたら教えていただけますでしょうか。


GLSLのfor文が読めない -> for(;++i<99.&&d>.001;)

提示コードですが`Mesh::Draw()`関数の`shader.setUniformMatrix4fv("uTranslate",getMatTranslation());`関数で下記のエラーが出ます。これはなぜでしょうか？`Mesh`クラスのコンストラクタでシェーダーをロードして`Draw()`関数で使っているのですが
なぜ-1のエラーが返ってくるのか原因がわりません。

##### 確認したこと
その他の2Dで円や矩形などの描画はこのクラスで行えるので`shader`クラスは問題ないです。


Github: https://github.com/Shigurechan/GL

```command
$ ./GL
this->vertex: 24
this->index: 0
this->texture: 0

あああ
GL: source/Shader.cpp:295: void FrameWork::Shader::setUniformMatrix4fv(const char*, glm::mat4): Assertion `0' failed.

```

```Shader.cpp
// ##################################### mat4 ##################################### 
void FrameWork::Shader::setUniformMatrix4fv(const char* name, const glm::mat4 m)
{
	const GLuint object = glGetUniformLocation(program, name);
	if (object == -1) { assert(0); }	//エラー処理
	glUniformMatrix4fv(object, 1, false, glm::value_ptr(m));
}
```

```vert
/*#########################################################################
# 
###########################################################################*/
#version 420
//#extension GL_ARB_explicit_uniform_location : require


layout(location = 0) in vec3 vertexPosition;	
//layout(location = 1) in vec2 vertexUV;	
//layout(location = 2) in vec3 vertexNormal;	


//layout(location = 3) out vec2 vUV;	
layout(location = 1) out vec4 vFragment;	
//layout(location = 4) out vec3 vNormal;	



uniform mat4 uTranslate;	
uniform mat4 uRotate;		
uniform mat4 uScale;		
uniform mat4 uViewProjection;	

uniform vec4 uFragment;


void main()
{
	vec4 vertex = vec4(vertexPosition,1.0);
	mat4 model = uTranslate * uRotate * uScale;		
	gl_Position = (uViewProjection * model) * vertex;
	


//	vUV = vertexUV;		
	vFragment = uFragment;
//	vNormal = vertexNormal;		
}
```


```.frag
/*#########################################################################
# 
###########################################################################*/
#version 420
//#extension GL_ARB_explicit_uniform_location : require


//layout(location = 3) in vec2 vUV;	
layout(location = 1) in vec4 vfragment;	

//layout(location = 4) in vec3 vNormal;	



//uniform sampler2D uImage;	
out vec4 fragment;

void main()
{
	fragment = vfragment;
//	fragment = texture(uImage,vUV);
}
```


```Mode.cpp
#include "../header/Model.hpp"

#include <iostream>
#include <assert.h>
#include <vector>
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>
#include <glm/glm.hpp>
#include <GL/glew.h>
#include "../lib/stb/stb_image.h"

#include "../header/Resource.hpp"
#include "../header/Camera.hpp"


FrameWork::D3::Mesh::Mesh(std::vector<VertexAttribute> ver, std::vector<unsigned int> idx, std::vector<Texture> tex) : Transform()
{
      this->vertex = ver;     //頂点
      this->index = idx;      //インデックス
      this->texture = tex;    //テクスチャ

      printf("this->vertex: %d\n",this->vertex.size());
      printf("this->index: %d\n",this->index.size());
      printf("this->texture: %d\n\n",this->texture.size());

	if ( shader.Input(FrameWork::LoadShader("Shader/3D/BasicMono_3D.vert")->data(), FrameWork::LoadShader("Shader/3D/BasicMono_3D.frag")->data()) == false)
      {
            printf("シェーダーロード失敗\n");
      }



	glGenVertexArrays(1, &VAO);
	glGenBuffers(1, &VBO);
	
      glBindVertexArray(VAO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);

      //glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);

      //glBufferData(GL_ELEMENT_ARRAY_BUFFER, index.size() * sizeof(unsigned int),index.data(), GL_DYNAMIC_DRAW);
      glBufferData(GL_ARRAY_BUFFER, vertex.size() * sizeof(VertexAttribute), vertex.data(), GL_DYNAMIC_DRAW);  

      GLint attrib = shader.getAttribLocation("vertexPosition");
      glEnableVertexAttribArray(attrib);
      glVertexAttribPointer(attrib, 1, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
      shader.setBindAttribLocation("vertexPosition");


      //printf("あああ\n");

      // vertex texture coords
      //attrib = shader.getAttribLocation("vertexUV");
      //glEnableVertexAttribArray(attrib);	
      //glVertexAttribPointer(attrib, 2, GL_FLOAT, GL_FALSE, sizeof(VertexAttribute), (void*)(sizeof(GLfloat) * 3));
//printf("ららら\n");
      // vertex normals
      //attrib = shader.getAttribLocation("vertexNormal");
      //glEnableVertexAttribArray(attrib);	
      //glVertexAttribPointer(attrib, 3, GL_FLOAT, GL_FALSE, sizeof(VertexAttribute), (void*)(sizeof(GLfloat) * 5));


      glBindVertexArray(0);
      glBindBuffer(GL_ARRAY_BUFFER, 0);


}



void FrameWork::D3::Mesh::Draw()
{
      shader.setEnable();

	glBindVertexArray(VAO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);

	glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(VertexAttribute) * vertex.size(), vertex.data());

	//Transform	
	setPosition(glm::vec3(0,0,-20));    //座標
	setScale(glm::vec3(10,10,10));      //スケール
	setRotate(glm::vec3(0,0,0),0);	//回転

	//描画
	shader.setUniformMatrix4fv("uTranslate",getMatTranslation());
	shader.setUniformMatrix4fv("uRotate", getMatRotate());
	shader.setUniformMatrix4fv("uScale", getMatScale());
	shader.setUniform4f("uFragment", FrameWork::GetGlColor(glm::vec4(0,0,255,255)));
	shader.setUniformMatrix4fv("uViewProjection", FrameWork::Camera::getViewProjection());

      for(unsigned int i = 0; i < texture.size(); i++)
      {
            //glBindTexture(GL_TEXTURE_2D, texture[i].id);
            //glActiveTexture(GL_TEXTURE0 + i);
      }

      //glDrawElements(GL_TRIANGLES, index.size(), GL_UNSIGNED_INT, 0);
      glDrawArrays(GL_TRIANGLES,0,vertex.size());

	//バインド解除
	glBindVertexArray(0);
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	//glBindTexture(GL_TEXTURE_2D, 0);

	shader.setDisable();
}

void FrameWork::D3::Model::processNode(aiNode *node, const aiScene *scene)
{

      for(unsigned int i = 0;  i< node->mNumMeshes; i++)
      {
            //printf("push_back\n");

            aiMesh *m = scene->mMeshes[node->mMeshes[i]];
            mesh.push_back(processMesh(m,scene));
      }

      for(unsigned int i = 0;  i< node->mNumChildren; i++)
      {
            //printf("再帰的\n");
            processNode(node->mChildren[i],scene);
      }
}

void FrameWork::D3::Model::loadModel(const char *path)
{
      Assimp::Importer import;
      //const aiScene *scene = import.ReadFile(path,aiProcess_Triangulate);
      const aiScene *scene = import.ReadFile(path,aiProcess_Triangulate | aiProcess_FlipUVs);

      if(scene == NULL)
      {
            std::cerr<<"ERROR::ASIMP: " << import.GetErrorString() <<std::endl;
            assert(0);
      }

      std::string str(path);

      directory = str.substr(0,str.find_last_of('/'));

      processNode(scene->mRootNode, scene);      
}



FrameWork::D3::Mesh FrameWork::D3::Model::processMesh(aiMesh *m, const aiScene *scene)
{
      // data to fill
      std::vector<VertexAttribute> ver(0);
      std::vector<unsigned int> idx(0);
      std::vector<Texture> tex(0);
      

      for(unsigned int i = 0; i < m->mNumVertices; i++)
      {
            VertexAttribute vert;
            glm::vec3 vector; 
            vert.position[0] = m->mVertices[i].x;
            vert.position[1] = m->mVertices[i].y;
            vert.position[2] = m->mVertices[i].z;

            // normals
            if (m->HasNormals() == true)
            {
                  //vert.normal[0] = m->mNormals[i].x;
                  //vert.normal[1] = m->mNormals[i].y;
                  //vert.normal[2] = m->mNormals[i].z;
                  
            }

            // texture coordinates
            if(m->mTextureCoords != NULL)
            {
                  glm::vec2 vec;
                  //vert.uv[0] = m->mTextureCoords[0][i].x; 

            }
            else
            {
                  //vert.uv[0] = 0.0f;
                  //vert.uv[1] = 0.0f;

            }
            ver.push_back(vert);
      }
     
 
     return Mesh(ver, idx, tex);
      
}

```

GLSL 変数を使っているのにglGetUniformLocation()関数で-1が返ってくる理由が知りたい。

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

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

https://takap-tech.com/entry/2019/09/14/003915
こちらのサイトに記載されている
pattern_trans_alpha.fragのフラグメントシェーダ―が分かりません
【1】texture2D(CC_Texture0, v_texCoord)が返す値は
あるテクスチャのある座標の色を示すvec4型という認識で良いですか？
【2】1の説が正しい場合v_fragmentColor * texture2D(***);
vec4型変数*vec4型変数というのはどうやって計算しますか？
【3】color.xというのは0.0f~1.0fまでの値ですか？
【4】u_stlengthを0.5、u_percentを0、color.xを0.5とした場合
1.0 - (((u_percent / color.x) - u_stlength) * a))
は2.0になるのですが
gl_FragColor の 各成分の値は
0.0f~1.0fの範囲に収まっていなくても良いのですか？

以下コードです
```GLSL
varying vec4 v_fragmentColor;
varying vec2 v_texCoord;
uniform float u_percent;
uniform float u_stlength;
void main(void)
{
    vec4 color = v_fragmentColor * texture2D(CC_Texture0, v_texCoord);
    float a = 1.0 / u_stlength;
    gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0 - (((u_percent / color.x) - u_stlength) * a));
    }
);
```

GLSLの構文がわからない

### はじめに

現在、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()等を使って、法線やアンビエントオクルージョン等はシェーダで行っています


いったいどうすれば早く出来るのでしょうか。。