このページは Cloud Translation API によって翻訳されました。

OpenGL ES によるグラフィックの設定

ゲーム内にオブジェクトやスプライトを描画するには、ディスプレイ変数、サーフェス変数、コンテキスト変数を設定し、ゲームループ内にレンダリングをセットアップして、各シーンと各オブジェクトを描画する必要があります。

C または C++ のゲームの画面に画像を描画するには、OpenGL ES と Vulkan の 2 つの方法があります。

OpenGL ES は、Android などのモバイルデバイス向けの Open Graphics Library（OpenGL®）仕様の一部です。ここでは、ゲームに OpenGL ES を設定する方法について説明します。
ゲームに Vulkan を使用する場合は、 Vulkan のスタートガイドご覧ください

で確認できます。

開始する前に

まだ行っていない場合は、Android プロジェクトで GameActivity オブジェクトをセットアップします。

OpenGL ES 変数をセットアップする

ゲームをレンダリングするには、ディスプレイ、サーフェス、コンテキスト、設定が必要です。次の OpenGL ES 変数をゲームエンジンのヘッダーファイルに追加します。

class NativeEngine {
 //...
 private:
  EGLDisplay mEglDisplay;
  EGLSurface mEglSurface;
  EGLContext mEglContext;
  EGLConfig mEglConfig;

  bool mHasFocus, mIsVisible, mHasWindow;
  bool mHasGLObjects;
  bool mIsFirstFrame;

  int mSurfWidth, mSurfHeight;
}

ゲームエンジンのコンストラクタで、変数をデフォルト値で初期化します。

NativeEngine::NativeEngine(struct android_app *app) {
  //...
  mEglDisplay = EGL_NO_DISPLAY;
  mEglSurface = EGL_NO_SURFACE;
  mEglContext = EGL_NO_CONTEXT;
  mEglConfig = 0;

  mHasFocus = mIsVisible = mHasWindow = false;
  mHasGLObjects = false;
  mIsFirstFrame = true;

  mSurfWidth = mSurfHeight = 0;
}

レンダリングするディスプレイを初期化します。

bool NativeEngine::InitDisplay() {
  if (mEglDisplay != EGL_NO_DISPLAY) {
    return true;
  }

  mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
  if (EGL_FALSE == eglInitialize(mEglDisplay, 0, 0)) {
    LOGE("NativeEngine: failed to init display, error %d", eglGetError());
    return false;
  }
  return true;
}

サーフェスは、EGL によって割り当てられたオフスクリーンバッファ（pbuffer）、または Android OS によって割り当てられたウィンドウのいずれかです。このサーフェスを初期化します。

bool NativeEngine::InitSurface() {
  ASSERT(mEglDisplay != EGL_NO_DISPLAY);
  if (mEglSurface != EGL_NO_SURFACE) {
    return true;
  }

  EGLint numConfigs;
  const EGLint attribs[] = {
    EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, // request OpenGL ES 2.0
    EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
    EGL_BLUE_SIZE, 8,
    EGL_GREEN_SIZE, 8,
    EGL_RED_SIZE, 8,
    EGL_DEPTH_SIZE, 16,
    EGL_NONE
  };

  // Pick the first EGLConfig that matches.
  eglChooseConfig(mEglDisplay, attribs, &mEglConfig, 1, &numConfigs);
  mEglSurface = eglCreateWindowSurface(mEglDisplay, mEglConfig, mApp->window,
                                       NULL);
  if (mEglSurface == EGL_NO_SURFACE) {
    LOGE("Failed to create EGL surface, EGL error %d", eglGetError());
    return false;
  }
  return true;
}

レンダリングコンテキストを初期化します。この例では、OpenGL ES 2.0 のコンテキストを作成します。

bool NativeEngine::InitContext() {
  ASSERT(mEglDisplay != EGL_NO_DISPLAY);
  if (mEglContext != EGL_NO_CONTEXT) {
    return true;
  }

  // OpenGL ES 2.0
  EGLint attribList[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
  mEglContext = eglCreateContext(mEglDisplay, mEglConfig, NULL, attribList);
  if (mEglContext == EGL_NO_CONTEXT) {
    LOGE("Failed to create EGL context, EGL error %d", eglGetError());
    return false;
  }
  return true;
}

描画する前に、OpenGL ES の設定を行います。この例は、すべてのフレームの始まりで実行されます。深度テストを有効にし、クリアカラーを黒に設定して、色と深度のバッファをクリアします。
```
void NativeEngine::ConfigureOpenGL() {
  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  glEnable(GL_DEPTH_TEST);
  glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
}
```

ゲームループでレンダリングする

ゲームループは、ユーザーが終了するまでフレームをレンダリングし、無限に繰り返します。フレーム間では、次のことを行えます。
- 入力、音声出力、ネットワーキングイベントなどのイベントを処理する。
- ゲームロジックとユーザーインターフェースを更新する。
- フレームをディスプレイにレンダリングする。
フレームをディスプレイにレンダリングするために、ゲームループ内で DoFrame メソッドが無限に呼び出されます。
```
void NativeEngine::GameLoop() {
  // Loop indefinitely.
  while (1) {
    int events;
    struct android_poll_source* source;

    // If not animating, block until we get an event.
    while ((ALooper_pollAll(IsAnimating() ? 0 : -1, NULL, &events,
                            (void **) &source)) >= 0) {
      // Process events.
      ...
    }

    // Render a frame.
    if (IsAnimating()) {
        DoFrame();
    }
  }
}
```

DoFrame メソッドで、現在のサーフェスディメンションを照会し、SceneManager にフレームのレンダリングと表示バッファの入れ替えをリクエストします。

void NativeEngine::DoFrame() {
  ...
  // Query the current surface dimension.
  int width, height;
  eglQuerySurface(mEglDisplay, mEglSurface, EGL_WIDTH, &width);
  eglQuerySurface(mEglDisplay, mEglSurface, EGL_HEIGHT, &height);

  // Handle dimension changes.
  SceneManager *mgr = SceneManager::GetInstance();
  if (width != mSurfWidth || height != mSurfHeight) {
    mSurfWidth = width;
    mSurfHeight = height;
    mgr->SetScreenSize(mSurfWidth, mSurfHeight);
    glViewport(0, 0, mSurfWidth, mSurfHeight);
  }
  ...
  // Render scenes and objects.
  mgr->DoFrame();

  // Swap buffers.
  if (EGL_FALSE == eglSwapBuffers(mEglDisplay, mEglSurface)) {
    HandleEglError(eglGetError());
  }
}

シーンとオブジェクトのレンダリング

ゲームループは、レンダリングされる表示可能なシーンとオブジェクトの階層を処理します。エンドレストンネルの例では、SceneManager が複数のシーンを追跡しますが、同時にアクティブにできるシーンは 1 つだけです。この例では、現在のシーンがレンダリングされます。
```
void SceneManager::DoFrame() {
  if (mSceneToInstall) {
    InstallScene(mSceneToInstall);
    mSceneToInstall = NULL;
  }

  if (mHasGraphics && mCurScene) {
    mCurScene->DoFrame();
  }
}
```

ゲームによって、背景、テキスト、スプライト、ゲームオブジェクトがシーンに含まれることもあります。それをゲームに適した順序でレンダリングします。この例では、背景、テキスト、ウィジェットをレンダリングしています。

void UiScene::DoFrame() {
  // clear screen
  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glDisable(GL_DEPTH_TEST);

  RenderBackground();

  // Render the "Please Wait" sign and do nothing else
  if (mWaitScreen) {
    SceneManager *mgr = SceneManager::GetInstance();
    mTextRenderer->SetFontScale(WAIT_SIGN_SCALE);
    mTextRenderer->SetColor(1.0f, 1.0f, 1.0f);
    mTextRenderer->RenderText(S_PLEASE_WAIT, mgr->GetScreenAspect() * 0.5f,
                              0.5f);
    glEnable(GL_DEPTH_TEST);
    return;
  }

  // Render all the widgets.
  for (int i = 0; i < mWidgetCount; ++i) {
    mWidgets[i]->Render(mTrivialShader, mTextRenderer, mShapeRenderer,
          (mFocusWidget < 0) ? UiWidget::FOCUS_NOT_APPLICABLE :
          (mFocusWidget == i) ? UiWidget::FOCUS_YES : UiWidget::FOCUS_NO,tf);
  }
  glEnable(GL_DEPTH_TEST);
}

リソース

OpenGL ES と Vulkan の詳細については、以下をご覧ください。

OpenGL ES - Android の画像とグラフィック。
OpenGL ES - Android ソースの概要。
Vulkan - NDK スタートガイド。
Vulkan - Android ソースの概要。
Android のゲームループを理解する - フレームのペース調整、バッファのキューイング、VSYNC コールバックの処理、スレッドの管理について学びます。