常連

テラテイラー

回答者

ベストアンサー

拍手喝采

先生

有名人

以下のコードですがシェーダーにて回転、スケール、平行移動の行列を実装してそれとビュー行列も用意してすべてを計算してると思うのですがなぜ画面に何も表示されなのでしょうか？glVertex3f();関数にて頂点の座標は正しいです。何か忘れているのでしょうか？

回転、スケール、平行移動の行列を実装
ビュー行列を実装
シェーダで値を渡す
シェーダーで計算
描画するglDrawArrays();




※ コメント部/////で囲ってあるコードが該当コードです。
参考サイト: https://tokoik.github.io/GLFWdraft.pdf (163ページに数式を移しました(ビュー行列))
Github: https://github.com/Shigurechan/project




```GLSL
#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;
}

```


```hpp
#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

```




```cpp
#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();

};
```

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

float型だと手計算と一致せず、double型だと手計算と一致したのでdouble型にしました。
でも、三回目の計算がまったくあたらないので注意です。

後、計算が遅いです。


**数値**は、なんでも言いわけではなさそうだった。で、現状方程式で解いてる。（3Dグラフィックスのための数学では普通に４ｘ４の計算をしている。）


```c
double a[16]={
1.000000,0.000000,0.000000,0.000000,
0.000000,1.000000,0.000000,0.000000,
0.000000,0.000000,1.000000,0.000000,
0.000000,0.000000,0.000000,1.000000};


double ｂ[16]={
1.000000,0.000000,0.000000,0.000000,
0.000000,1.000000,0.000000,0.000000,
0.000000,0.000000,1.000000,0.000000,
0.000000,0.000000,0.000000,1.000000};

```

で数値は何でもいいとして
**a×bの
4×4の行列(間違えたら嫌なので強調)**を算出する簡単な方法がありましたら、教えてください。