GLSLを使った描画ができない理由が知りたい。Github全ソースあり

Question

以下のコードですがシェーダーにて回転、スケール、平行移動の行列を実装してそれとビュー行列も用意してすべてを計算してると思うのですがなぜ画面に何も表示されなのでしょうか？glVertex3f();関数にて頂点の座標は正しいです。何か忘れているのでしょうか？

回転、スケール、平行移動の行列を実装
ビュー行列を実装
シェーダで値を渡す
シェーダーで計算
描画するglDrawArrays();

※ コメント部/////で囲ってあるコードが該当コードです。
参考サイト: https://tokoik.github.io/GLFWdraft.pdf (163ページに数式を移しました(ビュー行列))
Github: https://github.com/Shigurechan/project

#version 400 
//頂点シェーダー

in vec3  position;//頂点座標

uniform mat4 scale;//スケール行列
uniform mat4 rotate;//回転行列
uniform mat4 move;//平行移動行列

uniform mat4 MP;


void main()
{
	vec4 t = vec4(position,1.0);
	mat4 M = scale * rotate * move;


	gl_Position = MP * M * t;
}

#ifndef ___GMAE_H_
#define ___GMAE_H_

#define WIDTH 640
#define HEIGHT 400

#include "stdio.h"
#include <fstream>
#include <sstream>
#include <iostream>



#include "GLEW/include/GL/glew.h"

#include "gl/GL.h"
#include "GLFW/include/GLFW/glfw3.h"
#include "Vector.hpp"
//#include "Vector.hpp"



class Game
{
public:
	Vector3 cv;

	Game();

	bool Initialization();

	bool RunLoop();

	void Update();
	void GenerateOutput();


private:
	bool mIsRunLoop;//メインループ


	Vector3 pos;

/////////////////////////////////////////////////////////////////////////////////////////////////////////
	//ビュー行列
	GLfloat view[4][4] = {
		{1,2,6,0},
		{0,0,0,0},

		{0,0,0,0},
		{0,0,0,1}

	};

	//プロジェクション
	GLfloat projection[4][4] = {
		{ 0,0,0,0 },
		{ 0,0,0,0 },

		{ 0,0,0,0 },
		{ 0,0,0,0 },
	};






	GLfloat vet[6][3] = { 0 };

	Vector3 v[6] = { 0 };


	//頂点バッファー
	GLfloat Vertex[6][3] =
	{
		{-0.5, 0.5, 1.0},
		{-0.5, -0.5, 1.0},
		{0.5, -0.5, 1.0},

		{-0.5, 0.5, 1.0},
		{0.5, 0.5, 1.0},
		{0.5, -0.5, 1.0}
	};
	





	 //スケール行列
	 const GLfloat scale[4][4] = {
		 {1,0,0,0},
		 {0,1,0,0},
		 {0,0,1,0},
		 {0,0,0,1}
	 };


	 //回転
	 float r = 1;
	 const GLfloat rotate[4][4] = {
			 (pos.x * pos.x +(1 - cos(r)) + cos(r)),
			 (pos.x * pos.y +(1 - cos(r)) + pos.z * sin(r))
			,(pos.x * pos.z +(1 - cos(r)) - pos.y * sin(r)),0,


			 (pos.x * pos.x +(1 - cos(r)) + sin(r)),
			 (pos.y * pos.y +(1 - cos(r)) + cos(r)),
			 (pos.y * pos.z +(1 - cos(r)) + pos.x * sin(r)),0,


			 (pos.x * pos.z + (1 - cos(r)) - pos.z * sin(r)),
			 (pos.y * pos.z +(1 - cos(r)) - pos.x * sin(r)),
			 (pos.z * pos.z + (1 - cos(r)) + cos(r)),0,
	 };


	 //平行移動
	 float mx = 0;
	 float my = 0;
	 float mz = 0;
	 const GLfloat move[4][4] =
	 {
		 1,0,0,mx,
		 0,1,0,my,
		 0,0,1,mz,
		 0,0,0,1,
	 };



	
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	GLuint vbo = 0;//頂点配列バッファオブジェクト名
	GLuint vao = 0;//頂点バッファオブジェクト名
	
	GLFWwindow* Window = nullptr;//OpenGLコンテキスト

	GLuint program = 0;
	bool Shader();//シェーダ読み込み
	void Compile_log(GLuint Shader);//シェーダーコンパイルログ
	void Link_log(GLuint Shader);//シェーダーリンクログ

	void GetShader_Log(GLuint shader_type,GLuint Log_type);

		
	void create_maxtri_mp(float top, float bottom, float left, float right,
											float far, float near, float result[4][4]);

	

};



#endif

#include "Game.hpp"
#include <iostream>
//#include "stdafx.h"
#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include "Vector.hpp"


//透視投影変換行列を作る
void Game::create_maxtri_mp(float top, float bottom, float left, float right,
	float near, float far, float result[4][4])
{
	result[0][0] = (2 * near) / (right - left);
	result[0][1] = 0;
	result[0][2] = (right + left) / (right - left);
	result[0][3] = 0;

	result[1][0] = 0;
	result[1][1] = (2 * near) / (top - bottom);
	result[1][2] = (top + bottom) / (top - bottom);
	result[1][3] = 0;

	result[2][0] = 0;
	result[2][1] = 0;
	result[2][2] = -(far + near) / (far - near);
	result[2][3] = -(2 * far + near) / (far - near);

	result[3][0] = 0;
	result[3][1] = 0;
	result[3][2] = -1;
	result[3][3] = 0;
}


//コンストラクタ
Game::Game()
{
	mIsRunLoop = true;
	
}

//メインループ
bool Game::RunLoop()
{
	if (mIsRunLoop == true)
	{
		Update();
		GenerateOutput();
	}
	else {
		return false;
	}
	return true;

}


//シェーダー関係のログを取得
void Game::GetShader_Log(GLuint shader_type, GLuint Log_type)
{
	GLint bufferSize = 0;
	GLchar* infoLog = nullptr;

	//成功したかどうか？
	glGetShaderiv(shader_type, Log_type, &bufferSize);
	if (bufferSize == GL_FALSE)
	{
		//printf("");
	}
	//ログの長さを取得する
	glGetShaderiv(shader_type, GL_INFO_LOG_LENGTH, &bufferSize);
	
	infoLog = (GLchar*)malloc(bufferSize);
	
	if (infoLog != NULL)
	{
		GLsizei length;//ログの長さ	
		glGetShaderInfoLog(shader_type, bufferSize, &length, infoLog);

		if (length > 1)//null文字を含むため一文字以上の場合ログ出力
		{
			fprintf(stderr, "InfoLog:   %s\n\n", infoLog);
		}

		free(infoLog);//メモリ開放
		infoLog = NULL;
	}

	//return true;
}

//シェーダを実装する
bool Game::Shader()
{

	program = glCreateProgram();
	GLuint out_vert = glCreateShader(GL_VERTEX_SHADER);
	GLuint out_frag = glCreateShader(GL_FRAGMENT_SHADER);

	//頂点シェーダーを読み込み
	std::string fileName = "Basic.vert";
	std::ifstream shaderfile(fileName);
	if (shaderfile.is_open())
	{
		std::stringstream sstream;
		sstream << shaderfile.rdbuf();
		std::string str = sstream.str();
		const char* cc = str.c_str();

		out_vert = glCreateShader(GL_VERTEX_SHADER);
		glShaderSource(out_vert, 1, &cc, nullptr);
		glCompileShader(out_vert);
		//printf("Basic.vert ファイル読み込み\n");

		GetShader_Log(out_vert, GL_COMPILE_STATUS);
		glAttachShader(program, out_vert);
		shaderfile.close();

	}
	else {
		shaderfile.close();
		printf("ファイル: %s が読み込めませんでした。", fileName.c_str());
	}


	//バーティックスシェーダーを読み込み
	fileName = "Basic.frag";
	shaderfile.open(fileName);
	if (shaderfile.is_open())
	{

		std::stringstream sstream;
		sstream << shaderfile.rdbuf();
		std::string str = sstream.str();
		const char* cc = str.c_str();

		out_frag = glCreateShader(GL_FRAGMENT_SHADER);
		glShaderSource(out_frag, 1, &cc, nullptr);
		glCompileShader(out_frag);
		GetShader_Log(out_frag, GL_COMPILE_STATUS);
		glAttachShader(program, out_frag);
		shaderfile.close();

		//    printf("Basic.frag ファイル読み込み\n");
	}
	else {
		shaderfile.close();
		printf("ファイル: %s が読み込めませんでした。", fileName.c_str());
	}



	glLinkProgram(program);
	//使わなくなったシェーダーオブジェクトを削除
	glDeleteShader(out_frag);
	glDeleteShader(out_vert);
	glUseProgram(program);


	//シェーダーに値を渡す
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//*****************************************************************************
	float mp[4][4];
	create_maxtri_mp(HEIGHT, -HEIGHT, -WIDTH, WIDTH, 0.1, 0.0000000001, mp);//透視行列を作成

	//フラグメントシェーダー
	glBindAttribLocation(program, 0, "Vertex");


	//頂点シェーダー
	glBindAttribLocation(program, 0, "Vertex");
	glUniformMatrix4fv(glGetUniformLocation(program, "scale"), 0, GL_TRUE, &scale[0][0]);
	glUniformMatrix4fv(glGetUniformLocation(program, "rotate"), 1, GL_TRUE, &rotate[0][0]);
	glUniformMatrix4fv(glGetUniformLocation(program, "move"), 2, GL_TRUE, &move[0][0]);


	glUniformMatrix4fv(glGetUniformLocation(program, "MP"), 3, GL_TRUE, &mp[0][0]);
	//*****************************************************************************
	////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	glUseProgram(program);



	return true;
}




//初期化
bool Game::Initialization()
{
	//画面初期化 関係
	///////////////////////////////////////////////////////////////////////////////////////////////////////////
	//glfwの初期化に失敗
	if (glfwInit() != GL_TRUE)
	{
		printf("glfwInit()失敗\n");
		int _c = getchar();

		return 0;
	}

	//コンテキストを作成
	Window = glfwCreateWindow(640, 400, "Hello", NULL, NULL);

	//OpenGLコンテキストの作成に失敗
	if (Window == NULL)
	{
		printf("glfCreateWindow()失敗\n");
		int c = getchar();

		return 0;
	}

	//コンテキストをOpenGLの描画対象にする。
	glfwMakeContextCurrent(Window);

	//glewを初期化する。
	glewExperimental = GL_TRUE;
	if (glewInit() != GLEW_OK)
	{
		printf("glewInit()　の初期化に失敗しました。");
		return 0;
	}

	//OpenGLバージョン指定
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 0);

	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	//垂直同期のタイミングを待つ
	glfwSwapInterval(1);
	///////////////////////////////////////////////////////////////////////////////////////////////////////////



	if (Shader() == true)//シェーダーを読み込む
	{
		printf("シェーダーを読み込む\n");
	}


	glGenVertexArrays(1, &vbo);
	glBindVertexArray(vbo);
	glGenBuffers(1, &vbo);
	glBindBuffer(GL_ARRAY_BUFFER, vbo);
	glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex), Vertex, GL_STATIC_DRAW);///////
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
	glEnableVertexAttribArray(0);
	//glEnableClientState(GL_VERTEX_ARRAY);//クライアントで頂点を有効にする。	
	




	mIsRunLoop = true;
	return mIsRunLoop;
}

//アップデート
void Game::Update()
{
	if (glfwGetKey(Window, GLFW_KEY_ESCAPE) == GLFW_PRESS  || glfwWindowShouldClose(Window) != GL_FALSE)
	{
		mIsRunLoop = false;
	}


}

//描画アップデート
void Game::GenerateOutput()
{
	glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glUseProgram(program);



	glDrawArrays(GL_POLYGON,0,18);






	glViewport(0, 0, WIDTH, HEIGHT);
	glfwSwapBuffers(Window);
	glfwWaitEvents();

};

Answer 1

• create_maxtri_mpの引数を調整。
• glUniformMatrix4fvの第2引数は個数なので1を指定
• 並行移動の行列を調整して奥に移動

とりあえず上記を修正したら表示はされました。

あとは、回転行列の部分は元が何をしようとしているかが不明なので、
とりあえず画面の更新で回転するようにしてみました。

     //平行移動
     float mx = 0;
     float my = 0;
     float mz = -3; // 奥へ移動
     const GLfloat move[4][4] =
     {
         1,0,0,mx,
         0,1,0,my,
         0,0,1,mz,
         0,0,0,1,
     };

#include "Game.hpp"
#include <iostream>
//#include "stdafx.h"
#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include "Vector.hpp"


//透視投影変換行列を作る
void Game::create_maxtri_mp(float top, float bottom, float left, float right,
    float near, float far, float result[4][4])
{
    result[0][0] = (2 * near) / (right - left);
    result[0][1] = 0;
    result[0][2] = (right + left) / (right - left);
    result[0][3] = 0;

    result[1][0] = 0;
    result[1][1] = (2 * near) / (top - bottom);
    result[1][2] = (top + bottom) / (top - bottom);
    result[1][3] = 0;

    result[2][0] = 0;
    result[2][1] = 0;
    result[2][2] = -(far + near) / (far - near);
    result[2][3] = -(2 * far + near) / (far - near);

    result[3][0] = 0;
    result[3][1] = 0;
    result[3][2] = -1;
    result[3][3] = 0;
}


//コンストラクタ
Game::Game()
{
    mIsRunLoop = true;

}

//メインループ
bool Game::RunLoop()
{
    if (mIsRunLoop == true)
    {
        Update();
        GenerateOutput();
    }
    else {
        return false;
    }
    return true;

}


//シェーダー関係のログを取得
void Game::GetShader_Log(GLuint shader_type, GLuint Log_type)
{
    GLint bufferSize = 0;
    GLchar* infoLog = nullptr;

    //成功したかどうか？
    glGetShaderiv(shader_type, Log_type, &bufferSize);
    if (bufferSize == GL_FALSE)
    {
        //printf("");
    }
    //ログの長さを取得する
    glGetShaderiv(shader_type, GL_INFO_LOG_LENGTH, &bufferSize);

    infoLog = (GLchar*)malloc(bufferSize);

    if (infoLog != NULL)
    {
        GLsizei length;//ログの長さ    
        glGetShaderInfoLog(shader_type, bufferSize, &length, infoLog);

        if (length > 1)//null文字を含むため一文字以上の場合ログ出力
        {
            fprintf(stderr, "InfoLog:   %s\n\n", infoLog);
        }

        free(infoLog);//メモリ開放
        infoLog = NULL;
    }

    //return true;
}

//シェーダを実装する
bool Game::Shader()
{

    program = glCreateProgram();
    GLuint out_vert = glCreateShader(GL_VERTEX_SHADER);
    GLuint out_frag = glCreateShader(GL_FRAGMENT_SHADER);

    //頂点シェーダーを読み込み
    std::string fileName = "Basic.vert";
    std::ifstream shaderfile(fileName);
    if (shaderfile.is_open())
    {
        std::stringstream sstream;
        sstream << shaderfile.rdbuf();
        std::string str = sstream.str();
        const char* cc = str.c_str();

        out_vert = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(out_vert, 1, &cc, nullptr);
        glCompileShader(out_vert);
        //printf("Basic.vert ファイル読み込み\n");

        GetShader_Log(out_vert, GL_COMPILE_STATUS);
        glAttachShader(program, out_vert);
        shaderfile.close();

    }
    else {
        shaderfile.close();
        printf("ファイル: %s が読み込めませんでした。", fileName.c_str());
    }


    //バーティックスシェーダーを読み込み
    fileName = "Basic.frag";
    shaderfile.open(fileName);
    if (shaderfile.is_open())
    {

        std::stringstream sstream;
        sstream << shaderfile.rdbuf();
        std::string str = sstream.str();
        const char* cc = str.c_str();

        out_frag = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(out_frag, 1, &cc, nullptr);
        glCompileShader(out_frag);
        GetShader_Log(out_frag, GL_COMPILE_STATUS);
        glAttachShader(program, out_frag);
        shaderfile.close();

        //    printf("Basic.frag ファイル読み込み\n");
    }
    else {
        shaderfile.close();
        printf("ファイル: %s が読み込めませんでした。", fileName.c_str());
    }

    glBindAttribLocation(program, 0, "position");


    glLinkProgram(program);
    //使わなくなったシェーダーオブジェクトを削除
    glDeleteShader(out_frag);
    glDeleteShader(out_vert);
    glUseProgram(program);


    //シェーダーに値を渡す
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//*****************************************************************************
    float mp[4][4];
    create_maxtri_mp(1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 10.0f, mp);//透視行列を作成

    const GLfloat rot[4][4] = {
        {1,0,0,0},
        {0,1,0,0},
        {0,0,1,0},
        {0,0,0,1}
    };

    //頂点シェーダー
    glUniformMatrix4fv(glGetUniformLocation(program, "scale"), 1, GL_TRUE, &scale[0][0]);
    glUniformMatrix4fv(glGetUniformLocation(program, "rotate"), 1, GL_TRUE, &rot[0][0]);
    glUniformMatrix4fv(glGetUniformLocation(program, "move"), 1, GL_TRUE, &move[0][0]);


    glUniformMatrix4fv(glGetUniformLocation(program, "MP"), 1, GL_TRUE, &mp[0][0]);
    //*****************************************************************************
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    glUseProgram(program);



    return true;
}




//初期化
bool Game::Initialization()
{
    //画面初期化 関係
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////
    //glfwの初期化に失敗
    if (glfwInit() != GL_TRUE)
    {
        printf("glfwInit()失敗\n");
        int _c = getchar();

        return 0;
    }

    //コンテキストを作成
    Window = glfwCreateWindow(640, 400, "Hello", NULL, NULL);

    //OpenGLコンテキストの作成に失敗
    if (Window == NULL)
    {
        printf("glfCreateWindow()失敗\n");
        int c = getchar();

        return 0;
    }

    //コンテキストをOpenGLの描画対象にする。
    glfwMakeContextCurrent(Window);

    //glewを初期化する。
    glewExperimental = GL_TRUE;
    if (glewInit() != GLEW_OK)
    {
        printf("glewInit()　の初期化に失敗しました。");
        return 0;
    }

    //OpenGLバージョン指定
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 0);

    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    //垂直同期のタイミングを待つ
    glfwSwapInterval(1);
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////



    if (Shader() == true)//シェーダーを読み込む
    {
        printf("シェーダーを読み込む\n");
    }


    glGenVertexArrays(1, &vbo);
    glBindVertexArray(vbo);
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex), Vertex, GL_STATIC_DRAW);///////
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
    glEnableVertexAttribArray(0);
    //glEnableClientState(GL_VERTEX_ARRAY);//クライアントで頂点を有効にする。    





    mIsRunLoop = true;
    return mIsRunLoop;
}

//アップデート
void Game::Update()
{
    if (glfwGetKey(Window, GLFW_KEY_ESCAPE) == GLFW_PRESS || glfwWindowShouldClose(Window) != GL_FALSE)
    {
        mIsRunLoop = false;
    }


}

static void rotateX(GLfloat radian, GLfloat m[])
{
    float s = sin(radian);
    float c = cos(radian);
    m[0] = 1.0; m[1] = 0.0; m[2] = 0.0; m[3] = 0.0;
    m[4] = 0.0; m[5] = c;  m[6] = -s;  m[7] = 0.0;
    m[8] = 0.0; m[9] = s;   m[10] = c;   m[11] = 0.0;
    m[12] = 0.0; m[13] = 0.0; m[14] = 0.0; m[15] = 1.0;
}

//描画アップデート
void Game::GenerateOutput()
{
    glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glUseProgram(program);

    static float rotX = 0;
    float rot[16];
    rotateX(rotX, rot);
    rotX += 0.01f;

    glUniformMatrix4fv(glGetUniformLocation(program, "rotate"), 1, GL_FALSE, rot);


    glDrawArrays(GL_POLYGON, 0, 18);






    glViewport(0, 0, WIDTH, HEIGHT);
    glfwSwapBuffers(Window);
    glfwPollEvents();

}

Comments

[退会済みユーザー]

いえ、正しいみたいです。 //使わなくなったシェーダーオブジェクトを削除
glDeleteShader(out_frag);
glDeleteShader(out_vert);
のあとにシェーダーの値渡しコードを置いて見ましたが同じでした。

[mah]

glUseProgram(program);が抜けているのは確認しましたか？
こちらでは回答のソースで四角形が描画されました。

[退会済みユーザー]

表示されません。一様ですがその関数すべてのコードを回答欄に乗せてくれますでしょうか？ｗお手数かけます

[mah]

すいません、シェーダーのソースを確認用に変えていたのを忘れていました。
で、元のソースに戻したら表示されなくなったので、原因がわかったら回答に追記します。

[退会済みユーザー]

わかりました。でも順序はどちらにせよ変なのでそこは修正します

[退会済みユーザー]

Githubに全文のソースファイルがあるのでそちらを御覧ください。

[mah]

回答を更新しました。

[退会済みユーザー]

質問ですが。moveの部分を全部0にすると表示されないのですが何もしないでただ画面に表示するだけの場合moveはどうしたらいいのでしょうか？

[mah]

moveを全部0にしたい理由がわかりませんが、ただ画面に表示するだけでも頂点がnear～farの範囲に収まっていないと表示されないのでなんらかの方法で移動させる必要があります。
頂点のZ座標が1.0なので最初から-2.0とかにしておけば、とりあえずmoveをいじらなくても表示はされます。

[退会済みユーザー]

なるほど。rotateX関数に行列がありますが自分は自分で用意した行列を使いましたがこれでも実装できましたがどうなのでしょうか？move行列配列のconstを外し自分でmove[2][3] += 0.01f;などとして

[mah]

質問の意味がわからないです。とりあえずいろいろ値をいじってみればいいんではないでしょうか。