Java 3D LWJGL GitBook: Chapter01〜環境構築 ハローワールド 〜

イントロダクション

Javaで3Dモデルを操作することができ、ゲーム作成のためのAPI(ライブラリ)、LEJGL(Light Weight Java Game Library)を
使用して、３Dモデルを表示させようと思います。
＜参照するもの＞

注意

このドキュメントは英語なのでそれをブラウザで翻訳して読んでいます。

早い話が。。。

OBJファイルを読み込んで3DモデルをJavaで表示するためにLWJGLを使用することにしました。

LWJGLは下のような特徴があります。

  1. OBJファイルは、3Dモデルを作成したときにできるファイルです。
  2. OpenGLというライブラリも使用しているので、3Dモデルや通常の２Dイメージも表示できるのがLWJGLです。
  3. やはり、プログラムなのでゲームを作成するのでなくても、部分的に、例えば3Dモデルの表示のみでも使える

Blenderなどで作成した3Dモデル(Objファイル)を表示するのが目的です。
JOGL(他のライブラリ)でやろうと思ったけど、チュートリアルや、ドキュメントが少ないので、やはり今回も使わない方向でいきます。

参考

LWJGLのGitbookです、合わせてプログラムソースもGithubにアップされているので、そちらも参考にします。

LWJGL GitBook Chapter-01

今回は、LWJGLを起動することを確認するプログラムコードを動かしましょう。というものです。
はじめのプログラム「ハローワールド」のLWJGL版です。基本的にハローワルドはDB接続、フレームワークの使用をするときにそれらがちゃんと動かせるかどうか確認するために実行するプログラムです。

今回の学習内容

学習を始めるのに参考にするもののリンクを張っておきます。

IntelliJ IDEAを使用して、環境構築(プログラムを動かす設定)をおこない、ハローワールドを実行するということが今回の目的になります。
早い話が、LWJGLが動く確認をします

環境構築

参考サイトにあるように、環境構築を行います。下の文言を参考にします。

。IntelliJ は無​​料のオープン ソース バージョンであるコミュニティ バージョンを提供しており、 https ://www.jetbrains.com/idea/download/ からダウンロードできます。

このリンクから、IntelliJをダウンロードして、インストールしたら、早速必要なライブラリ(依存関係)をダウンロードします。
Mavenで実行しているようなので、Maven(メイベン)を使用します。

Mavenの使用

用途としては、必要なライブラリをダウンロードしてくることです。そのためにビルドツールとしてMavenを使用します。他にもGradleが有名です。
まずは、IntelliJ起動してください。そしたらGithubからGitbookのプロジェクトをチェックアウトします。

プロジェクトのチェックアウト（クローン)

起動した、IntelliJのプロジェクトを未選択の状態で開きます。初回の軌道であればそのままで大丈夫です。

ここで、赤枠の部分Get from VCSをクリックします。「VCS」は バージョンコントロールシステムのことです。つまり、バージョン管理を行うアプリケーションのことです。

そして、下の項目を入力します。

URLに関しては、Githubのページを開いたら、したのようなボタンがあるのでそれをクリックします。

必要なライブラリのダウンロード

クローンしてきたプロジェクトにはpom.xmlというファイルがあると思います。これを右クリックして次のようにします。

  1. Mavenを選択
  2. Reload Projectをクリック

これで必要なライブラリがダウンロードされます。
早速、ハローワールドを実行してみましょう。下のような実行結果が見れると思います。

Gitbookの内容

まずは、環境構築のために必要なリポジトリ、依存関係のダウンロードを行うためのPOMファイルへの記述内容の説明があります。

POMファイル（pom.xml)の概要

参考にしたページには書いていませんが、pom.xmlでは、次のようなものを定義しています。

  • project: 作成するプロジェクト
  • parent: 親プロジェクト
  • artifactId: このファイルの定義するプロジェクトのID
  • dependencies: 依存関係
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.lwjglb</groupId>
        <artifactId>book</artifactId>
        <version>1.0</version>
        <relativePath>../pom.xml</relativePath>
    </parent>

    <artifactId>chapter-01</artifactId>
    <version>1.0</version>

    <dependencies>
        <dependency>
            <groupId>org.lwjgl</groupId>
            <artifactId>lwjgl</artifactId>
            <version>${lwjgl.version}</version>
        </dependency>
        <dependency>
            <groupId>org.lwjgl</groupId>
            <artifactId>lwjgl-glfw</artifactId>
            <version>${lwjgl.version}</version>
        </dependency>
        <dependency>
            <groupId>org.lwjgl</groupId>
            <artifactId>lwjgl-opengl</artifactId>
            <version>${lwjgl.version}</version>
        </dependency>

        <!-- Natives -->
        <dependency>
            <groupId>org.lwjgl</groupId>
            <artifactId>lwjgl</artifactId>
            <version>${lwjgl.version}</version>
            <classifier>${native.target}</classifier>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.lwjgl</groupId>
            <artifactId>lwjgl-opengl</artifactId>
            <version>${lwjgl.version}</version>
            <classifier>${native.target}</classifier>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.lwjgl</groupId>
            <artifactId>lwjgl-glfw</artifactId>
            <version>${lwjgl.version}</version>
            <classifier>${native.target}</classifier>
            <scope>runtime</scope>
        </dependency>
    </dependencies>
</project>

この本では、 OpenGLを使用して 3D ゲームを開発する際の主なテクニックを学びます。Java でサンプルを開発し、Lightweight Java Game Library LWJGLを使用します。LWJGL ライブラリを使用すると、Java から OpenGL などの低レベル API (アプリケーション プログラミング インターフェイス) にアクセスできます。

LWJGL は、OpenGL のラッパーのように機能する低レベル API です。したがって、短期間で 3D ゲームの作成を開始することを考えている場合は、jMonkeyEngineやUnityなどの他の代替手段を検討する必要があります。この低レベルの API を使用すると、結果を確認する前に、多くの概念を調べ、多くのコード行を記述する必要があります。このようにすることの利点は、3D グラフィックスをよりよく理解できるようになり、常にコントロールできるようになることです。

Java に関しては、少なくとも Java 18 が必要です。したがって、そのバージョンがインストールされていない場合の最初のステップは、Java SDK をダウンロードすることです。ここからOpenJDK バイナリをダウンロードするか、Windows および macOS 用のインストーラーがあるAdoptiumからダウンロードできます。Adoptium ビルドをダウンロードするときは、「JRE」ではなく「JDK」をダウンロードしてください。お使いのオペレーティング システムに適したインストーラーを選択してインストールするだけです。いずれにせよ、この本は Java 言語についてある程度理解していることを前提としています。そうでない場合は、まずその言語について適切な知識を得る必要があります。

サンプルを実行するために必要な Java IDE を使用できます。Java を適切にサポートする IntelliJ IDEA をダウンロードできます。IntelliJ は無​​料のオープン ソース バージョンであるコミュニティ バージョンを提供しており、 https ://www.jetbrains.com/idea/download/ からダウンロードできます。

IDE でソース コードを開くと、すべての章 (親プロジェクト) を含むルート フォルダーを開くか、各章を個別に開くことができます。最初のケースでは、各章の作業ディレクトリを章のルート フォルダに適切に設定することを忘れないでください。サンプルは、ルート フォルダーがチャプター ベース フォルダーであると想定して、相対パスを使用してファイルにアクセスしようとします。

サンプルのビルドにはMavenを使用します。Maven はほとんどの IDE に既に統合されており、それらのさまざまなサンプルを直接開くことができます。章のサンプルを含むフォルダーを開くだけで、IntelliJ はそれが Maven プロジェクトであることを検出します。

Maven は、(プロジェクト オブジェクト モデル) という名前の XML ファイルに基づいてプロジェクトをビルドします。このファイルは、pom.xmlプロジェクトの依存関係 (使用する必要があるライブラリ) と、ビルド プロセス中に実行する手順を管理します。Maven は、構成よりも規則の原則に従います。つまり、標準のプロジェクト構造と命名規則に固執する場合、構成ファイルは、ソース ファイルの場所やコンパイルされたクラスの場所を明示的に指定する必要はありません。

この本は Maven のチュートリアルを意図したものではないので、必要に応じて Web で情報を見つけてください。ソース コード フォルダーは、使用するプラグインを定義し、使用するライブラリのバージョンを収集する親プロジェクトを定義します。

LWJGL 3.1 では、プロジェクトのビルド方法にいくつかの変更が導入されました。現在、ベース コードはよりモジュール化されており、巨大なモノリシック jar ファイルを使用する代わりに、使用するパッケージをより選択することができます。これには代償が伴います。依存関係を 1 つずつ慎重に指定する必要があります。ただし、ダウンロードページには、pom ファイルを生成する優れたツールが含まれています。この場合、最初に GLFW と OpenGL バインディングを使用します。ソースコードでpomファイルがどのように見えるかを確認できます。

LWJGL プラットフォームの依存関係は、プラットフォームのネイティブ ライブラリの展開を既に処理しているため、他のプラグイン ( などmavennatives) を使用する必要はありません。LWJGL プラットフォームを構成するプロパティを設定するために、3 つのプロファイルを設定するだけです。プロファイルは、Windows、Linux、および Mac OS ファミリのそのプロパティの正しい値を設定します。

    <profiles>
        <profile>
            <id>windows-profile</id>
            <activation>
                <os>
                    <family>Windows</family>
                </os>
            </activation>
            <properties>
                <native.target>natives-windows</native.target>
            </properties>                
        </profile>
        <profile>
            <id>linux-profile</id>
            <activation>
                <os>
                    <family>Linux</family>
                </os>
            </activation>
            <properties>
                <native.target>natives-linux</native.target>
            </properties>                
        </profile>
        <profile>
            <id>OSX-profile</id>
            <activation>
                <os>
                    <family>mac</family>
                </os>
            </activation>
            <properties>
                <native.target>natives-osx</native.target>
            </properties>
        </profile>
    </profiles>

各プロジェクト内で、LWJGL プラットフォームの依存関係は、現在のプラットフォームのプロファイルで確立された正しいプロパティを使用します。

        <dependency>
            <groupId>org.lwjgl</groupId>
            <artifactId>lwjgl-platform</artifactId>
            <version>${lwjgl.version}</version>
            <classifier>${native.target}</classifier>
        </dependency>

それに加えて、すべてのプロジェクトは実行可能な jar (java -jar name_of_the_jar.jar と入力して実行できるもの) を生成します。MANIFEST.MFこれは、正しい値を持つファイルで jar を作成する maven-jar-plugin を使用して実現されます。そのファイルの最も重要な属性はMain-Class、プログラムのエントリ ポイントを設定する です。さらに、すべての依存関係は、Class-Pathそのファイルの属性のエントリとして設定されます。別のコンピューターで実行するには、ターゲット ディレクトリの下にあるメインの jar ファイルと lib ディレクトリ (そこに含まれるすべての jar ファイルを含む) をコピーするだけです。

LWJGL クラスを含む jar には、ネイティブ ライブラリも含まれています。また、LWJGL はそれらを抽出し、JVM がライブラリを探すパスに追加します。

この章のソース コードは、LWJGL サイトhttp://www.lwjgl.org/guideの入門用サンプルから直接取得したものです。非常によく文書化されていますが、ソース コードを見て、最も関連性の高い部分を説明しましょう。クラスごとにソースコードを貼り付けると読めなくなってしまうので、フラグメントを含めます。特定の各フラグメントが属するクラスをよりよく理解するために、各フラグメントには常にクラス ヘッダーが含まれます。3 つのドット ( ...) を使用して、フラグメントの前後にさらにコードがあることを示します。HelloWorldサンプルは、次のように始まる名前の単一のクラスに含まれています。

ソースコード解析

プログラムの内容を確認します。初回のLWJGL学習なので市登場するクラスは1つです。
ポイントは、OpenGLを使用している処理部分です。
具体的には、以下の通りです。

  1. 赤い四角を描画している処理
  2. 描画の準備をする処理
  3. プログラムの構成

プログラムの構成

  • main: runメソッドを起動。
  • run: init, loopを呼び出す。
  • init: アプリケーションを初期化するメソッド。
  • loop: 基本的にウィンドウにレンダリングする無限ループであるメソッド。

メインメソッド

以下のサンプルコードにあるように、メインメソッドの処理内容が書いてあります。
単純に「HelloWorld#run()」を呼び出しています。
とてもシンプルです。言葉に直すのであれば「『ハローワールド』を起動する」という言い方になります。

package org.lwjglb;

import org.lwjgl.Version;
import org.lwjgl.glfw.*;
import org.lwjgl.opengl.GL;
import org.lwjgl.system.MemoryStack;

import java.nio.IntBuffer;

import static org.lwjgl.glfw.Callbacks.glfwFreeCallbacks;
import static org.lwjgl.glfw.GLFW.*;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.system.MemoryStack.stackPush;
import static org.lwjgl.system.MemoryUtil.NULL;

public class HelloWorld {

    // The window handle
    private long window;

    public static void main(String[] args) {
        new HelloWorld().run();
    }
    ...
}

run()メソッド

mainこのクラスは、メソッドを呼び出すメソッド内に、ウィンドウ ハンドルへの参照を格納するだけです (これが何を意味するかは後で説明します) run。そのメソッドの分析を始めましょう。

このメソッドがプログラムの処理内容を具体的に呼び出している部分です。
具体的に、以下の処理を行っています。正確には「呼び出しています」といったほうが良いかもしれません。

  1. LWJGLのバージョン情報表示。
  2. プログラムの初期処理「init()」を呼び出す。
  3. プログラムの主要部分「loop()」を呼び出す。
  4. プログラムの終了処理。

１～４の各処理に対して、細かい部分は各メソッド(init(), loop())の中身を見ることにして、
この「run()メソッド」では、上記の処理(呼び出し)を行っています。

public class HelloWorld {
    ...
    public void run() {
        System.out.println("Hello LWJGL " + Version.getVersion() + "!");

        init();
        loop();

        // Free the window callbacks and destroy the window
        glfwFreeCallbacks(window);
        glfwDestroyWindow(window);

        // Terminate GLFW and free the error callback
        glfwTerminate();
        glfwSetErrorCallback(null).free();
    }
    ...
}

init()メソッド

このメソッドはinit、アプリケーションを初期化するメソッドを呼び出してから、loop基本的にウィンドウにレンダリングする無限ループであるメソッドを呼び出します。メソッドが終了したら、loop初期化中に作成されたいくつかのリソースを解放する必要があります (GLFW ウィンドウ)。メソッドから始めましょうinit。

public class HelloWorld {
    ...
    private void init() {
        // Setup an error callback. The default implementation
        // will print the error message in System.err.
        GLFWErrorCallback.createPrint(System.err).set();

        // Initialize GLFW. Most GLFW functions will not work before doing this.
        if (!glfwInit())
            throw new IllegalStateException("Unable to initialize GLFW");

        // Configure GLFW
        glfwDefaultWindowHints(); // optional, the current window hints are already the default
        glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); // the window will stay hidden after creation
        glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); // the window will be resizable

        // Create the window
        window = glfwCreateWindow(300, 300, "Hello World!", NULL, NULL);
        if (window == NULL)
            throw new RuntimeException("Failed to create the GLFW window");

        // Setup a key callback. It will be called every time a key is pressed, repeated or released.
        glfwSetKeyCallback(window, (window, key, scancode, action, mods) -> {
            if (key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE)
                glfwSetWindowShouldClose(window, true); // We will detect this in the rendering loop
        });
        ...
    }
    ...
}

GLFWを呼び出すことから始めます。これは、GUI コンポーネント (Windows など) とイベント (キーの押下、マウスの動きなど) を処理するライブラリであり、OpenGL コンテキストが簡単な方法でアタッチされています。現在、Swing または AWT を直接使用して OpenGL をレンダリングすることはできません。AWT を使用したい場合はlwjgl3-awt を確認できますが、この本では GLFW に固執します。最初に、GLFW ライブラリを初期化し、ウィンドウの初期化のためのいくつかのパラメーターを設定することから始めます (サイズ変更可能かどうかなど)。ウィンドウは、glfwCreateWindowウィンドウの幅と高さ、およびウィンドウのタイトルを受け取ります。この関数は、他の GLFW 関連関数で使用できるように保存する必要があるハンドルを返します。その後、キーが押されたときに呼び出される関数であるキーボード コールバックを設定します。ESCこの場合、ウィンドウを閉じるためにキーが押されたかどうかを検出したいだけです。メソッドを続けましょうinit：

public class HelloWorld {
    ...
    private void init() {
        ...
        // Get the thread stack and push a new frame
        try (MemoryStack stack = stackPush()) {
            IntBuffer pWidth = stack.mallocInt(1); // int*
            IntBuffer pHeight = stack.mallocInt(1); // int*

            // Get the window size passed to glfwCreateWindow
            glfwGetWindowSize(window, pWidth, pHeight);

            // Get the resolution of the primary monitor
            GLFWVidMode vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());

            // Center the window
            glfwSetWindowPos(
                    window,
                    (vidmode.width() - pWidth.get(0)) / 2,
                    (vidmode.height() - pHeight.get(0)) / 2
            );
        } // the stack frame is popped automatically

        // Make the OpenGL context current
        glfwMakeContextCurrent(window);
        // Enable v-sync
        glfwSwapInterval(1);

        // Make the window visible
        glfwShowWindow(window);
    }
    ...
}

次の章で説明しますが、ここでは LWJGL の主要なクラスであるMemoryStack. 前に述べたように、LJWGL はネイティブ ライブラリ (C ベースの関数) のラッパーを提供します。Java にはポインターの概念がないため (少なくとも C の用語ではタイヒンク)、C 関数に構造体を渡すのは単純な作業ではありません。これらの構造を共有し、上記の例のように参照パラメーターを渡すには、ネイティブ コードからアクセスできるメモリを割り当てる必要があります。LWJGL は、MemoryStackネイティブ アクセス可能なメモリ/構造を割り当てることができるクラスを提供します。これにより、自動的にクリーンアップされます (実際には、再利用できるように strcuture のようなプールに返されます)。stackPushメソッドが呼び出されます。ネイティブにアクセス可能なすべてのメモリ/構造は、このスタック クラスを通じてインスタンス化されます。上記のサンプルでは、glfwGetWindowSize​​ウィンドウの寸法を取得するために を呼び出す必要があります。値は参照渡しのアプローチを使用して返されるため、2 つの int を (2 の形式でIntBuffer) 割り当てる必要があります。その情報とモニターの寸法を使用して、ウィンドウを中央に配置し、OpenGL をセットアップし、v-sync を有効にして (これについては次の章で詳しく説明します)、最後にウィンドウを表示します。

ここで、何かを継続的にレンダリングするための無限ループが必要です。

まとめると...

次のようになります。前提としてLWJGLはOpenGLを使用しています。

  • 既存のJava Swing(GUI作成をするAPI)、AWT(これもGUIを作成するAPI)などを直接使用してOpenGLをレンダリングはできない。
  • GLFW ライブラリを初期化(glfwInit())ウィンドウの初期化のためのいくつかのパラメーターを設定する「(コメントの)Configure GLFW部分」
  • glfwGetWindowSize()はウィンドウの幅と高さ、およびウィンドウのタイトルを受け取ります。そして、他の GLFW 関連関数で使用できるように保存する必要があるハンドルを返します。「」
  • キーが押されたときに呼び出される関数であるキーボード コールバックを設定します。「glfwSetKeyCallback()」

loop()メソッド

＜行っている処理＞

  • OpenGL コンテキストを作成
  • クリア カラーを設定
  • 各ループで (カラーおよび深度バッファに対して) クリア操作
  • ウィンドウを閉じる必要があるかどうかを検出するためにキーボード イベントをポーリング
public class HelloWorld {
    ...
    private void loop() {
        // This line is critical for LWJGL's interoperation with GLFW's
        // OpenGL context, or any context that is managed externally.
        // LWJGL detects the context that is current in the current thread,
        // creates the GLCapabilities instance and makes the OpenGL
        // bindings available for use.
        GL.createCapabilities();

        // Set the clear color
        glClearColor(1.0f, 0.0f, 0.0f, 0.0f);

        // Run the rendering loop until the user has attempted to close
        // the window or has pressed the ESCAPE key.
        while (!glfwWindowShouldClose(window)) {
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // clear the framebuffer

            glfwSwapBuffers(window); // swap the color buffers

            // Poll for window events. The key callback above will only be
            // invoked during this call.
            glfwPollEvents();
        }
    }
    ...
}

最初に OpenGL コンテキストを作成し、クリア カラーを設定して、各ループで (カラーおよび深度バッファに対して) クリア操作を実行し、ウィンドウを閉じる必要があるかどうかを検出するためにキーボード イベントをポーリングします。これらの概念については、次の章で詳しく説明します。ただし、完全を期すために、レンダリングはターゲットに対して行われます。この場合は、色情報と深度値 (3D の場合) を含むバッファーに対して行われます。これらのバッファーに対するレンダリングが終了したら、GLFW に通知する必要があります。このバッファは、 を呼び出して表示する準備ができていglfwSwapBuffersます。GLFW はいくつかのバッファーを維持するため、1 つのバッファーでレンダリング操作を実行しながら、もう 1 つのバッファーがウィンドウに表示されます (そうでない場合、ちらつきアーティファクトが発生します)。

環境が正しくセットアップされていれば、それを実行して赤い背景のウィンドウを見ることができるはずです。

クラス図

わかりやすいようにクラス図を作成しました。

今回のコードは、クラスが一つですべての処理を行っているので、上記のようになります。

プログラムの実行内容

実行しているコードを説明しています。自分の理解では次のようになります。詳細は次の章(Chapter)で説明するそうです。

  1. メインメソッドの説明
    フィールド変数にwindowというint型の変数があり、runというスタティックメソッドを実行している
  2. run()メソッドの実行している内容の説明
    init()メソッドとloop()メソッドを呼び出している、loop()メソッドは無限ループになっている
  3. init()メソッドの説明
    GLFWを呼び出すことから始めています。GLFWは”GUI コンポーネント (Windows など) とイベント (キーの押下、マウスの動きなど) を処理するライブラリであり、OpenGL コンテキストが簡単な方法でアタッチされています”とあるように、画面コントロールのライブラリのようです。実行内容に関しては本文を参照ください。
  4. loop()メソッドの説明
    本文にありますが、何かを継続的にレンダリングするための無限ループということでした

loop()の処理内容

  1. glClearColor()で画面をクリア
  2. glfwSwapBuffers()でGLFWに通知

上記の処理を行っているようですが、細かいところは、次の章で明らかになると思います。。。

まとめ

環境構築編

Mavenの依存関係をPOMファイルで設定、Mevenによる依存関係の解決(ライブラリのダウンロード)を行い。
LWJGLが実行できるように環境を構築する使用しているIDEはIntelliJ IDEA

実装編

プログラムの実行、処理の内容を解説。

  1. init()で画面コントロール、表示するサイズなどの設定を行う
  2. loop()メソッドで、”何かを継続的にレンダリングするための無限ループ”

を実装するというところを理解した。

今回のハローワールドでは、赤い画面を表示するだけだったが、LWJGLの動作の基本が、おおまかに理解できる。

次回 >>>

Tutorial#1(別途行ったものです)

今回からLWJGLのチュートリアルを進めてきます。
このチュートリアルには、セットアップ(環境構築)手順も載っていました。

まずは、写経から入ります。
この動画で作成しているコードを写経していきます。
作成したコードは、下のようなコードになりました。

２クラスあります。
画面を起動するためのMainクラス自分が作成したものは「GameMainクラス」にしています。

public class GameMain {
    public static void main(String[] args) {
        Window win = new Window(800, 500, "LWJGL Tutorial");
        win.create();
        while (!win.closed()) {
            win.update();
            win.swapBuffers();
        }
    }
}

「Windowクラス」

public class Window {
    private int width;
    private int height;
    private String title;
    private long window;

    public Window(int width, int height, String title) {
        this.width = width;
        this.height = height;
        this.title = title;
    }

    public void create() {
        if (!GLFW.glfwInit()) {
            System.err.println("Error: Coudn not GLFW");
            System.exit(-1);
        }
        window = GLFW.glfwCreateWindow(width, height, title, 0, 0);
        if (window == 0) {
            System.err.println("Error: window coud not be created");
            System.exit(-1);
        }
        GLFWVidMode videoMode = GLFW.glfwGetVideoMode(GLFW.glfwGetPrimaryMonitor());
        GLFW.glfwSetWindowPos(window, (videoMode.width() - width) / 2, (videoMode.height() - height) / 2);
    }

    public boolean closed() {
        return GLFW.glfwWindowShouldClose(window);
    }

    public void update() {
        GLFW.glfwPollEvents();
    }

    public void swapBuffers() {
        GLFW.glfwSwapBuffers(window);
    }
}

今回の作成した２つのクラスは、以下のような役割分担になっています。
GameMain: Windowクラスを起動する
Window: LWJGLで使用しているGLFWクラスを使用して画面を作成する処理を書きます。

今回はGitにあるソースをコピーとか参照することができなかったので、動画を見て写経しました。それで、下のコードを間違えていました、すると表示した時に画面が端っこに行ってしまいました。
GLFW.glfwSetWindowPos(window, (videoMode.width() + width) / 2, (videoMode.height() + height) / 2);

そして、このコードがよくわかりませんでした。
どの値を計算しているか？これがわからなかったという次第です。

なのでちょいと、いじって見ました、
タイトルの部分と、上の計算している部分のコードをチョチョっといじりました。

結局は、上のよくわからなかった部分は画面表示の初期位置を指定するものでした。

次回は、Chapter02をやります。

関連ページ一覧

http://zenryokuservice.com/wp/2018/10/27/java-game-lwjgl-gitbook-chapter5-2%E3%80%9C%E3%83%AC%E3%83%B3%E3%83%80%E3%83%AA%E3%83%B3%E3%82%B0%E8%A9%B3%E7%B4%B0%E3%80%9C/

＜開発準備＞

http://zenryokuservice.com/wp/2018/05/02/set-up-1-eclipse-java/

＜LWJGLのGitBokに関して＞

  1. Chapter1[外枠の表示のみ]
  2. Chapter2-1〜クラスの構成〜
  3. Chapter2-2〜インターフェースの使い方と詳細〜
  4. Chapter2-3〜GameEngineクラス(サンプルクラス)〜/li>
  5. Chapter2-4〜Windowクラス(サンプルクラス)〜
  6. Chapter3〜描画処理を読む〜
  7. Chapter4〜シェーダについて〜
  8. Chapter5-1〜レンダリングについて〜

＜Java Basic＞

  1. Java Basic Level 1 〜Hello Java〜
  2. Java Basic Level2 〜Arithmetic Calculate〜
  3. Java Basic Level3 〜About String class〜
  4. Java Basic Level 4〜Boolean〜
  5. Java Basic Level 5〜If Statement〜
  6. Java Basic Summary from Level1 to 5
  7. Java Basic Level 6 〜Traning of If statement〜
  8. Java Basic Level8 〜How to use for statement〜
  9. Java Basic Level 8.5 〜Array〜
  10. Java Basic Level 8.5 〜Array〜
  11. Java Basic Level 10 〜While statement 〜
  12. Java Basic Swing〜オブジェクト指向〜
  13. Java Basic Swing Level 2〜オブジェクト指向2〜


投稿者:

takunoji

音響、イベント会場設営業界からIT業界へ転身。現在はJava屋としてサラリーマンをやっている。自称ガテン系プログラマー(笑) Javaプログラミングを布教したい、ラスパイとJavaの相性が良いことに気が付く。 Spring framework, Struts, Seaser, Hibernate, Playframework, JavaEE6, JavaEE7などの現場経験あり。 SQL, VBA, PL/SQL, コマンドプロント, Shellなどもやります。

コメントを残す