Realistycznie oświetlone wirtualne obiekty w scenie

Dowiedz się, jak używać szacowania oświetlenia w swoich aplikacjach.

Wymagania wstępne

Zanim przejdziesz dalej, upewnij się, że rozumiesz podstawowe pojęcia związane z AR i wiesz, jak skonfigurować sesję ARCore.

Skonfiguruj interfejs API raz na sesję w odpowiednim trybie.

Skonfiguruj szacowanie oświetlenia raz na sesję w przypadku trybu, którego chcesz używać.

HDR środowiskowy

// Configure the session's lighting estimation mode for
// AR_LIGHT_ESTIMATION_MODE_ENVIRONMENTAL_HDR.
ArConfig* config = NULL;
ArConfig_create(session, &config);
ArSession_getConfig(session, config);
ArConfig_setLightEstimationMode(session, config,
                                AR_LIGHT_ESTIMATION_MODE_ENVIRONMENTAL_HDR);
ArSession_configure(session, config);
ArConfig_destroy(config);

Intensywność światła otoczenia

// Configure the session's lighting estimation mode for
// AR_LIGHT_ESTIMATION_MODE_AMBIENT_INTENSITY.
ArConfig* config = NULL;
ArConfig_create(session, &config);
ArSession_getConfig(session, config);
ArConfig_setLightEstimationMode(session, config,
                                AR_LIGHT_ESTIMATION_MODE_AMBIENT_INTENSITY);
ArSession_configure(session, config);
ArConfig_destroy(config);

Wyłączono

// Disable the session's lighting estimation mode.
ArConfig* config = NULL;
ArConfig_create(session, &config);
ArSession_getConfig(session, config);
ArConfig_setLightEstimationMode(session, config,
                                AR_LIGHT_ESTIMATION_MODE_DISABLED);
ArSession_configure(session, config);
ArConfig_destroy(config);

Użyj wartości uzyskanych z szacowania oświetlenia

Aby używać wartości uzyskanych z szacowania oświetlenia, uzyskaj szacunkową wartość oświetlenia dla każdej klatki.

// Get the current frame.
ArFrame* ar_frame = NULL;
if (ArSession_update(session, ar_frame) != AR_SUCCESS) {
  LOGE("ArSession_update error");
  return;
}

// Get the light estimate for the current frame.
ArLightEstimate* ar_light_estimate = NULL;
ArLightEstimate_create(session, &ar_light_estimate);
ArFrame_getLightEstimate(session, ar_frame, ar_light_estimate);

ArLightEstimateState ar_light_estimate_state;
ArLightEstimate_getState(session, ar_light_estimate,
                         &ar_light_estimate_state);

// Check that the light estimate is valid before proceeding.
if (ar_light_estimate_state != AR_LIGHT_ESTIMATE_STATE_VALID) {
  LOGE("ArLightEstimateState is not valid.");
  ArLightEstimate_destroy(ar_light_estimate);
  return;
}

Następnie pobierz komponenty oświetlenia środowiskowego HDR dla bieżącej konfiguracji:

HDR środowiskowy

// Get intensity and direction of the main directional light from the current
// light estimate.
float direction[3];
ArLightEstimate_getEnvironmentalHdrMainLightDirection(
    session, ar_light_estimate, direction);

float intensity[3];
ArLightEstimate_getEnvironmentalHdrMainLightIntensity(
    session, ar_light_estimate, intensity);

// Get ambient lighting as spherical harmonics coefficients.
float ambient_spherical_harmonics[27];
ArLightEstimate_getEnvironmentalHdrAmbientSphericalHarmonics(
    session, ar_light_estimate, ambient_spherical_harmonics);

// Get HDR environmental lighting as a cubemap in linear color space.
ArImageCubemap cubemap_textures;
ArLightEstimate_acquireEnvironmentalHdrCubemap(session, ar_light_estimate,
                                               cubemap_textures);
int width = -1;
int height = -1;
int32_t format = -1;
for (int i = 0; i < 6; ++i) {
  ArImage* image_ptr = cubemap_textures[i];
  // We can access the cubemap texture data through ArImage APIs.
  ArImage_getWidth(session, image_ptr, &width);
  ArImage_getHeight(session, image_ptr, &height);
  ArImage_getFormat(session, image_ptr, &format);
  // Acquired image must be released with ArImage_release once it is no
  // longer needed.
  ArImage_release(image_ptr);
}
ArLightEstimate_destroy(ar_light_estimate);

Intensywność światła otoczenia

// Get the pixel intensity of AR_LIGHT_ESTIMATION_MODE_AMBIENT_INTENSITY mode.
float pixel_intensity;
ArLightEstimate_getPixelIntensity(session, ar_light_estimate,
                                  &pixel_intensity);

// Get the pixel color correction of
// AR_LIGHT_ESTIMATION_MODE_AMBIENT_INTENSITY mode.
float color_correction[4];
ArLightEstimate_getColorCorrection(session, ar_light_estimate,
                                   color_correction);
ArLightEstimate_destroy(ar_light_estimate);

Zapewnianie oszczędzania energii za pomocą interfejsów Environmental HDR API

Zasada zachowania energii mówi, że światło odbite od powierzchni nigdy nie będzie bardziej intensywne niż przed uderzeniem w tę powierzchnię. Ta reguła jest wymuszana w renderowaniu opartym na fizyce, ale zwykle jest pomijana w starszych potokach renderowania używanych w grach wideo i aplikacjach mobilnych.

Jeśli używasz potoku renderowania opartego na fizyce z szacowaniem oświetlenia środowiskowego HDR, po prostu upewnij się, że w wirtualnych obiektach używasz materiałów opartych na fizyce.

Jeśli jednak nie używasz potoku opartego na fizyce, masz kilka opcji:

• Najlepszym rozwiązaniem jest przejście na potok oparty na fizyce.

• Jeśli to niemożliwe, dobrym rozwiązaniem jest pomnożenie wartości albedo z materiału nieopartego na fizyce przez współczynnik zachowania energii. Dzięki temu można mieć pewność, że co najmniej model cieniowania BRDF może zostać przekonwertowany na model fizyczny. Każda funkcja BRDF ma inny współczynnik – na przykład w przypadku odbicia rozproszonego jest to 1/Pi.