質問をすることでしか得られない、回答やアドバイスがある。

15分調べてもわからないことは、質問しよう!

ただいまの
回答率

87.49%

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

解決済

回答 1

投稿 編集

  • 評価
  • クリップ 1
  • VIEW 701
退会済みユーザー

退会済みユーザー

以下のコードですがシェーダーにて回転、スケール、平行移動の行列を実装してそれとビュー行列も用意してすべてを計算してると思うのですがなぜ画面に何も表示されなのでしょうか?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();

};
  • 気になる質問をクリップする

    クリップした質問は、後からいつでもマイページで確認できます。

    またクリップした質問に回答があった際、通知やメールを受け取ることができます。

    クリップを取り消します

  • 良い質問の評価を上げる

    以下のような質問は評価を上げましょう

    • 質問内容が明確
    • 自分も答えを知りたい
    • 質問者以外のユーザにも役立つ

    評価が高い質問は、TOPページの「注目」タブのフィードに表示されやすくなります。

    質問の評価を上げたことを取り消します

  • 評価を下げられる数の上限に達しました

    評価を下げることができません

    • 1日5回まで評価を下げられます
    • 1日に1ユーザに対して2回まで評価を下げられます

    質問の評価を下げる

    teratailでは下記のような質問を「具体的に困っていることがない質問」、「サイトポリシーに違反する質問」と定義し、推奨していません。

    • プログラミングに関係のない質問
    • やってほしいことだけを記載した丸投げの質問
    • 問題・課題が含まれていない質問
    • 意図的に内容が抹消された質問
    • 過去に投稿した質問と同じ内容の質問
    • 広告と受け取られるような投稿

    評価が下がると、TOPページの「アクティブ」「注目」タブのフィードに表示されにくくなります。

    質問の評価を下げたことを取り消します

    この機能は開放されていません

    評価を下げる条件を満たしてません

    評価を下げる理由を選択してください

    詳細な説明はこちら

    上記に当てはまらず、質問内容が明確になっていない質問には「情報の追加・修正依頼」機能からコメントをしてください。

    質問の評価を下げる機能の利用条件

    この機能を利用するためには、以下の事項を行う必要があります。

回答 1

checkベストアンサー

+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();

}

投稿

編集

  • 回答の評価を上げる

    以下のような回答は評価を上げましょう

    • 正しい回答
    • わかりやすい回答
    • ためになる回答

    評価が高い回答ほどページの上位に表示されます。

  • 回答の評価を下げる

    下記のような回答は推奨されていません。

    • 間違っている回答
    • 質問の回答になっていない投稿
    • スパムや攻撃的な表現を用いた投稿

    評価を下げる際はその理由を明確に伝え、適切な回答に修正してもらいましょう。

  • 2020/09/16 08:38

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

    キャンセル

  • 2020/09/16 08:47

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

    キャンセル

  • 2020/09/16 09:35 編集

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

    キャンセル

15分調べてもわからないことは、teratailで質問しよう!

  • ただいまの回答率 87.49%
  • 質問をまとめることで、思考を整理して素早く解決
  • テンプレート機能で、簡単に質問をまとめられる

関連した質問

同じタグがついた質問を見る