DNA_lightprobe_types.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "DNA_ID.h"
#include "DNA_defs.h"
#include "DNA_listBase.h"
 
#include "BLI_assert.h"
 
struct AnimData;
struct Object;
 
typedef struct LightProbe {
#ifdef __cplusplus
  static constexpr ID_Type id_type = ID_LP;
#endif
 
  ID id;
  struct AnimData *adt;

  char type;
  char flag;
  char attenuation_type;
  char parallax_type;
  char grid_flag;
  char _pad0[3];

  float distinf;
  float distpar;
  float falloff;
 
  float clipsta, clipend;

  float vis_bias, vis_bleedbias;
  float vis_blur;

  float intensity;

  int grid_resolution_x;
  int grid_resolution_y;
  int grid_resolution_z;
  int grid_bake_samples;
  float grid_surface_bias;
  float grid_escape_bias;
  float grid_normal_bias;
  float grid_view_bias;
  float grid_facing_bias;
  float grid_validity_threshold;
  float grid_dilation_threshold;
  float grid_dilation_radius;

  float grid_clamp_direct;
  float grid_clamp_indirect;

  int grid_surfel_density;

  struct Collection *visibility_grp;

  float data_display_size;
  char _pad1[4];
} LightProbe;
 
/* Probe->type */
enum {
  LIGHTPROBE_TYPE_SPHERE = 0,
  LIGHTPROBE_TYPE_PLANE = 1,
  LIGHTPROBE_TYPE_VOLUME = 2,
};
 
/* Probe->flag */
enum {
  LIGHTPROBE_FLAG_CUSTOM_PARALLAX = (1 << 0),
  LIGHTPROBE_FLAG_SHOW_INFLUENCE = (1 << 1),
  LIGHTPROBE_FLAG_SHOW_PARALLAX = (1 << 2),
  LIGHTPROBE_FLAG_SHOW_CLIP_DIST = (1 << 3),
  LIGHTPROBE_FLAG_SHOW_DATA = (1 << 4),
  LIGHTPROBE_FLAG_INVERT_GROUP = (1 << 5),
  LIGHTPROBE_DS_EXPAND = (1 << 6),
};
 
/* Probe->grid_flag */
enum {
  LIGHTPROBE_GRID_CAPTURE_WORLD = (1 << 0),
  LIGHTPROBE_GRID_CAPTURE_INDIRECT = (1 << 1),
  LIGHTPROBE_GRID_CAPTURE_EMISSION = (1 << 2),
};
 
/* Probe->display */
enum {
  LIGHTPROBE_DISP_WIRE = 0,
  LIGHTPROBE_DISP_SHADED = 1,
  LIGHTPROBE_DISP_DIFFUSE = 2,
  LIGHTPROBE_DISP_REFLECTIVE = 3,
};
 
/* Probe->parallax && Probe->attenuation_type. */
enum {
  LIGHTPROBE_SHAPE_ELIPSOID = 0,
  LIGHTPROBE_SHAPE_BOX = 1,
};
 
/* ------- Eevee LightProbes ------- */
/* Needs to be there because written to file with the light-cache. */
 
/* IMPORTANT Padding in these structs is essential. It must match
 * GLSL struct definition in lightprobe_lib.glsl. */
 
/* Must match CubeData. */
typedef struct LightProbeCache {
  float position[3], parallax_type;
  float attenuation_fac;
  float attenuation_type;
  float _pad3[2];
  float attenuationmat[4][4];
  float parallaxmat[4][4];
} LightProbeCache;
 
/* Must match GridData. */
typedef struct LightGridCache {
  float mat[4][4];
  int resolution[3], offset;
  float corner[3], attenuation_scale;
  float increment_x[3], attenuation_bias;
  float increment_y[3], level_bias;
  float increment_z[3], _pad4;
  float visibility_bias, visibility_bleed, visibility_range, _pad5;
} LightGridCache;
 
/* These are used as UBO data. They need to be aligned to size of vec4. */
BLI_STATIC_ASSERT_ALIGN(LightProbeCache, 16)
BLI_STATIC_ASSERT_ALIGN(LightGridCache, 16)
 
/* ------ Eevee Lightcache ------- */
 
typedef struct LightCacheTexture {
  struct GPUTexture *tex;
  char *data;
  int tex_size[3];
  char data_type;
  char components;
  char _pad[2];
} LightCacheTexture;
 
typedef struct LightCache {
  int flag;
  int version;
  int type;
  /* only a single cache for now */
  int cube_len, grid_len;
  int mips_len;
  int vis_res, ref_res;
  char _pad[4][2];
  /* In the future, we could create a bigger texture containing
   * multiple caches (for animation) and interpolate between the
   * caches overtime to another texture. */
  LightCacheTexture grid_tx;
  LightCacheTexture cube_tx;
  LightCacheTexture *cube_mips;
  /* All light-probes data contained in the cache. */
  LightProbeCache *cube_data;
  LightGridCache *grid_data;
} LightCache;
 
/* Bump the version number for lightcache data structure changes. */
#define LIGHTCACHE_STATIC_VERSION 2
 
/* LightCache->type */
enum {
  LIGHTCACHE_TYPE_STATIC = 0,
};
 
/* LightCache->flag */
enum {
  LIGHTCACHE_BAKED = (1 << 0),
  LIGHTCACHE_BAKING = (1 << 1),
  LIGHTCACHE_CUBE_READY = (1 << 2),
  LIGHTCACHE_GRID_READY = (1 << 3),
  /* Update tagging */
  LIGHTCACHE_UPDATE_CUBE = (1 << 4),
  LIGHTCACHE_UPDATE_GRID = (1 << 5),
  LIGHTCACHE_UPDATE_WORLD = (1 << 6),
  LIGHTCACHE_UPDATE_AUTO = (1 << 7),
  LIGHTCACHE_INVALID = (1 << 8),
  LIGHTCACHE_NOT_USABLE = (1 << 9),
};
 
/* EEVEE_LightCacheTexture->data_type */
enum {
  LIGHTCACHETEX_BYTE = (1 << 0),
  LIGHTCACHETEX_FLOAT = (1 << 1),
  LIGHTCACHETEX_UINT = (1 << 2),
};
 
/* -------------------------------------------------------------------- */

typedef struct LightProbeBakingData {
  float (*L0)[4];
  float (*L1_a)[4];
  float (*L1_b)[4];
  float (*L1_c)[4];
  float *validity;
  /* Capture offset. Only for debugging. */
  float (*virtual_offset)[4];
} LightProbeBakingData;

typedef struct LightProbeIrradianceData {
  float (*L0)[3];
  float (*L1_a)[3];
  float (*L1_b)[3];
  float (*L1_c)[3];
} LightProbeIrradianceData;

typedef struct LightProbeVisibilityData {
  float *L0;
  float *L1_a;
  float *L1_b;
  float *L1_c;
} LightProbeVisibilityData;

typedef struct LightProbeConnectivityData {
  uint8_t *validity;
} LightProbeConnectivityData;

typedef struct LightProbeBlockData {
  /* Offset inside the level-of-detail this block starts. */
  int offset[3];
  /* Level-of-detail this block is from. */
  int level;
} LightProbeBlockData;

 
/* -------------------------------------------------------------------- */

typedef struct LightProbeGridCacheFrame {
  int size[3];
  int data_layout;

  int block_len;
  int block_size;
  LightProbeBlockData *block_infos;

  LightProbeBakingData baking;
  LightProbeIrradianceData irradiance;
  LightProbeVisibilityData visibility;
  LightProbeConnectivityData connectivity;
 
  char _pad[4];

  int surfels_len;
  void *surfels;
} LightProbeGridCacheFrame;

enum {
  LIGHTPROBE_CACHE_UNIFORM_GRID = 0,
  LIGHTPROBE_CACHE_ADAPTIVE_RESOLUTION = 1,
};

typedef struct LightProbeObjectCache {
  int cache_type;
  char shared;
  char dirty;
 
  char _pad0[2];
 
  struct LightProbeGridCacheFrame *grid_static_cache;
} LightProbeObjectCache;

enum {
  LIGHTPROBE_CACHE_TYPE_NONE = 0,
  LIGHTPROBE_CACHE_TYPE_STATIC = 1,
};