Virtuelle Objekte in einer Szene realistisch beleuchten

Informationen zur Verwendung der Beleuchtungsschätzung in Ihren eigenen Apps

Vorbereitung

Bevor Sie fortfahren, sollten Sie sich mit den grundlegenden AR-Konzepten und der Konfiguration einer ARCore-Sitzung vertraut machen.

API einmal pro Sitzung mit dem entsprechenden Modus konfigurieren

Konfigurieren Sie die Beleuchtungsschätzung einmal pro Sitzung für den gewünschten Modus.

Umgebungs-HDR

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

Umgebungsintensität

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

Deaktiviert

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

Werte aus der Beleuchtungsschätzung verwenden

Wenn Sie Werte aus der Beleuchtungsschätzung verwenden möchten, müssen Sie die Beleuchtung für jeden Frame schätzen.

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

Rufen Sie dann die HDR-Beleuchtungskomponenten für die aktuelle Konfiguration ab:

Umgebungs-HDR

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

Umgebungsintensität

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

Energie sparen mit Environmental HDR APIs

Energieerhaltung ist das Prinzip, dass Licht, das von einer Oberfläche reflektiert wird, niemals intensiver sein kann als vor dem Auftreffen auf die Oberfläche. Diese Regel wird beim physikalisch basierten Rendern durchgesetzt, wird aber in der Regel in den alten Rendering-Pipelines, die in Videospielen und mobilen Apps verwendet werden, weggelassen.

Wenn Sie eine Pipeline für physikalisch basiertes Rendern mit HDR-Lichtschätzung (Environmental HDR) verwenden, müssen Sie nur dafür sorgen, dass in Ihren virtuellen Objekten physikalisch basierte Materialien verwendet werden.

Wenn Sie keine physikalisch basierte Pipeline verwenden, haben Sie jedoch einige Optionen:

• Die beste Lösung ist, zu einer physikalisch basierten Pipeline zu migrieren.

• Wenn das nicht möglich ist, können Sie den Albedowert eines nicht physikalisch basierten Materials mit einem Faktor für die Energieerhaltung multiplizieren. So kann zumindest das BRDF-Shading-Modell in ein physikalisch basiertes Modell konvertiert werden. Jede BRDF hat einen anderen Faktor, z. B. 1/Pi für eine diffuse Reflexion.