Objets virtuels lumineux de manière réaliste dans une scène

Découvrez comment utiliser Lighting Estimation dans vos propres applications.

Prérequis

Avant de continuer, assurez-vous de bien comprendre les concepts fondamentaux de la RA et de savoir comment configurer une session ARCore.

Configurer l'API une fois par session avec le mode approprié

Configurez l'estimation de l'éclairage une fois par session pour le mode que vous souhaitez utiliser.

HDR environnemental

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

Intensité ambiante

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

Désactivé

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

Utiliser les valeurs obtenues à partir de l'estimation de l'éclairage

Pour utiliser les valeurs obtenues à partir de l'estimation de l'éclairage, obtenez l'estimation de la lumière pour chaque frame.

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

Obtenez ensuite les composants d'éclairage HDR de l'environnement pour la configuration actuelle :

HDR environnemental

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

Intensité ambiante

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

Assurer l'économie d'énergie avec les API HDR environnementales

La conservation de l'énergie est le principe selon lequel la lumière réfléchie par une surface ne sera jamais plus intense qu'avant d'atteindre la surface. Cette règle est appliquée dans le rendu basé sur la physique, mais elle est généralement omise des anciens pipelines de rendu utilisés dans les jeux vidéo et les applications mobiles.

Si vous utilisez un pipeline de rendu basé sur la physique avec l'estimation de la lumière HDR environnementale, assurez-vous simplement que des matériaux basés sur la physique sont utilisés dans vos objets virtuels.

Si vous n'utilisez pas de pipeline basé sur la physique, vous avez deux options :

• La solution idéale consiste à migrer vers un pipeline basé sur la physique.

• Si ce n'est pas possible, une bonne solution de contournement consiste à multiplier la valeur d'albédo d'un matériau non basé sur la physique par un facteur de conservation de l'énergie. Cela permet de s'assurer qu'au moins le modèle d'ombrage BRDF peut être converti en modèle basé sur la physique. Chaque BRDF a un facteur différent (par exemple, pour une réflexion diffuse, il s'agit de 1/Pi).