Ta strona została przetłumaczona przez Cloud Translation API.

Konfigurowanie grafiki za pomocą OpenGL ES

Aby narysować obiekty i sprite’y w grze, musisz skonfigurować zmienne wyświetlania, powierzchni i kontekstu, ustawić renderowanie w pętli gry oraz narysować wszystkie sceny i obiekty.

W przypadku gier w językach C lub C++ obrazy można dodawać na ekranie na 2 sposoby: za pomocą OpenGL ES lub Vulkan.

OpenGL ES jest częścią specyfikacji Open Graphics Library (OpenGL®) przeznaczonej dla urządzeń mobilnych, takich jak Android. Z tego artykułu dowiesz się, jak skonfigurować platformę OpenGL ES w grze.
Jeśli używasz interfejsu Vulkan w grze, przeczytaj przewodnik Pierwsze kroki z platformą Vulkan.

Zanim rozpoczniesz

Skonfiguruj obiekt GameActivity w projekcie Androida, jeśli jeszcze go nie masz.

Konfigurowanie zmiennych OpenGL ES

Do renderowania gry będą potrzebne wyświetlacz, powierzchnia, kontekst i konfiguracja. Dodaj te zmienne OpenGL ES do pliku nagłówka silnika gry:

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

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

  int mSurfWidth, mSurfHeight;
}

W konstruktorze silnika gier zainicjuj wartości domyślne zmiennych.

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;
}

Zainicjuj wyświetlacz do renderowania.

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;
}

Powierzchnią może być bufor poza ekranem (pbuffer) przydzielony przez EGL lub okno przydzielone przez system operacyjny Android. Zainicjuj ten panel:

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;
}

Zainicjuj kontekst renderowania. W tym przykładzie tworzony jest kontekst 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;
}

Przed rysowaniem skonfiguruj ustawienia OpenGL ES. Ten przykład jest wykonywany na początku każdej klatki. Umożliwia przeprowadzanie testów głębi, ustawia czarny kolor oraz usuwa bufory kolorów i głębi.
```
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);
}
```

Renderowanie za pomocą pętli gry

Pętla gry renderuje ramkę i powtarza ją bez końca, dopóki użytkownik nie zamknie urządzenia. Między klatkami gra może:

Zdarzenia przetwarzania, takie jak dane wejściowe, wyjścia audio i zdarzenia związane z siecią.
Zaktualizuj logikę gry i interfejs.
Renderowanie ramki na wyświetlaczu.

Aby renderować ramkę na wyświetlaczu, metoda DoFrame jest wywoływana bezterminowo w pętli gry:

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

W metodzie DoFrame wyślij zapytanie o bieżące wymiary powierzchni, wyślij żądanie SceneManager o wyrenderowanie ramki i zamień bufory wyświetlania.

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

Renderuj sceny i obiekty

Pętla gry przetwarza hierarchię widocznych scen i obiektów do wyrenderowania. W tym przykładzie tunel bez końca SceneManager śledzi wiele scen z aktywną tylko jedną z nich. W tym przykładzie bieżąca scena jest renderowana:
```
void SceneManager::DoFrame() {
  if (mSceneToInstall) {
    InstallScene(mSceneToInstall);
    mSceneToInstall = NULL;
  }

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

W zależności od gry scena może zawierać tło, tekst, sprite’y i obiekty w grze. Renderuj je w kolejności odpowiedniej do Twojej gry. Ten przykład renderuje tło, tekst i widżety:

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);
}

Zasoby

Więcej informacji o platformach OpenGL ES i Vulkan znajdziesz poniżej:

OpenGL ES – obrazy i grafika na Androidzie.
OpenGL ES – przegląd w źródle Androida.
Vulkan – pierwsze kroki w NDK.
Vulkan – przegląd w Androidzie Source.
Poznaj pętle gry na Androida – naucz się tempa klatek, buforować kolejki, obsługiwać wywołania zwrotne VSYNC i zarządzać wątkami.