diff options
Diffstat (limited to 'source/blender/draw/engines/eevee/eevee_private.h')
| -rw-r--r-- | source/blender/draw/engines/eevee/eevee_private.h | 934 |
1 files changed, 934 insertions, 0 deletions
diff --git a/source/blender/draw/engines/eevee/eevee_private.h b/source/blender/draw/engines/eevee/eevee_private.h new file mode 100644 index 00000000000..b9d1fa884e5 --- /dev/null +++ b/source/blender/draw/engines/eevee/eevee_private.h @@ -0,0 +1,934 @@ +/* + * Copyright 2016, Blender Foundation. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Institute + * + */ + +/** \file eevee_private.h + * \ingroup DNA + */ + +#ifndef __EEVEE_PRIVATE_H__ +#define __EEVEE_PRIVATE_H__ + +struct Object; +struct EEVEE_BoundSphere; +struct EEVEE_ShadowCasterBuffer; + +extern struct DrawEngineType draw_engine_eevee_type; + +/* Minimum UBO is 16384 bytes */ +#define MAX_PROBE 128 /* TODO : find size by dividing UBO max size by probe data size */ +#define MAX_GRID 64 /* TODO : find size by dividing UBO max size by grid data size */ +#define MAX_PLANAR 16 /* TODO : find size by dividing UBO max size by grid data size */ +#define MAX_LIGHT 128 /* TODO : find size by dividing UBO max size by light data size */ +#define MAX_CASCADE_NUM 4 +#define MAX_SHADOW 256 /* TODO : Make this depends on GL_MAX_ARRAY_TEXTURE_LAYERS */ +#define MAX_SHADOW_CASCADE 8 +#define MAX_SHADOW_CUBE (MAX_SHADOW - MAX_CASCADE_NUM * MAX_SHADOW_CASCADE) +#define MAX_BLOOM_STEP 16 + +/* Only define one of these. */ +// #define IRRADIANCE_SH_L2 +// #define IRRADIANCE_CUBEMAP +#define IRRADIANCE_HL2 + +#if defined(IRRADIANCE_SH_L2) +# define SHADER_IRRADIANCE "#define IRRADIANCE_SH_L2\n" +#elif defined(IRRADIANCE_CUBEMAP) +# define SHADER_IRRADIANCE "#define IRRADIANCE_CUBEMAP\n" +#elif defined(IRRADIANCE_HL2) +# define SHADER_IRRADIANCE "#define IRRADIANCE_HL2\n" +#endif + +#define SHADER_DEFINES \ + "#define EEVEE_ENGINE\n" \ + "#define MAX_PROBE " STRINGIFY(MAX_PROBE) "\n" \ + "#define MAX_GRID " STRINGIFY(MAX_GRID) "\n" \ + "#define MAX_PLANAR " STRINGIFY(MAX_PLANAR) "\n" \ + "#define MAX_LIGHT " STRINGIFY(MAX_LIGHT) "\n" \ + "#define MAX_SHADOW " STRINGIFY(MAX_SHADOW) "\n" \ + "#define MAX_SHADOW_CUBE " STRINGIFY(MAX_SHADOW_CUBE) "\n" \ + "#define MAX_SHADOW_CASCADE " STRINGIFY(MAX_SHADOW_CASCADE) "\n" \ + "#define MAX_CASCADE_NUM " STRINGIFY(MAX_CASCADE_NUM) "\n" \ + SHADER_IRRADIANCE + +#define SWAP_DOUBLE_BUFFERS() { \ + if (effects->swap_double_buffer) { \ + SWAP(struct GPUFrameBuffer *, fbl->main, fbl->double_buffer); \ + SWAP(GPUTexture *, txl->color, txl->color_double_buffer); \ + effects->swap_double_buffer = false; \ + } \ +} ((void)0) + +#define SWAP_BUFFERS() { \ + if (effects->target_buffer != fbl->main) { \ + SWAP_DOUBLE_BUFFERS(); \ + effects->source_buffer = txl->color_post; \ + effects->target_buffer = fbl->main; \ + } \ + else { \ + SWAP_DOUBLE_BUFFERS(); \ + effects->source_buffer = txl->color; \ + effects->target_buffer = fbl->effect_fb; \ + } \ +} ((void)0) + +/* World shader variations */ +enum { + VAR_WORLD_BACKGROUND = 0, + VAR_WORLD_PROBE = 1, + VAR_WORLD_VOLUME = 2, +}; + +/* Material shader variations */ +enum { + VAR_MAT_MESH = (1 << 0), + VAR_MAT_PROBE = (1 << 1), + VAR_MAT_HAIR = (1 << 2), + VAR_MAT_FLAT = (1 << 3), + VAR_MAT_BLEND = (1 << 4), + VAR_MAT_VSM = (1 << 5), + VAR_MAT_ESM = (1 << 6), + /* Max number of variation */ + /* IMPORTANT : Leave it last and set + * it's value accordingly. */ + VAR_MAT_MAX = (1 << 7), + /* These are options that are not counted in VAR_MAT_MAX + * because they are not cumulative with the others above. */ + VAR_MAT_CLIP = (1 << 8), + VAR_MAT_HASH = (1 << 9), + VAR_MAT_MULT = (1 << 10), + VAR_MAT_SHADOW = (1 << 11), + VAR_MAT_REFRACT = (1 << 12), + VAR_MAT_VOLUME = (1 << 13), + VAR_MAT_SSS = (1 << 14), + VAR_MAT_TRANSLUC = (1 << 15), + VAR_MAT_SSSALBED = (1 << 16), +}; + +/* Shadow Technique */ +enum { + SHADOW_ESM = 1, + SHADOW_VSM = 2, + SHADOW_METHOD_MAX = 3, +}; + +typedef struct EEVEE_BoundSphere { + float center[3], radius; +} EEVEE_BoundSphere; + +typedef struct EEVEE_BoundBox { + float center[3], halfdim[3]; +} EEVEE_BoundBox; + +typedef struct EEVEE_PassList { + /* Shadows */ + struct DRWPass *shadow_pass; + struct DRWPass *shadow_cube_pass; + struct DRWPass *shadow_cube_copy_pass; + struct DRWPass *shadow_cube_store_pass; + struct DRWPass *shadow_cascade_pass; + struct DRWPass *shadow_cascade_copy_pass; + struct DRWPass *shadow_cascade_store_pass; + + /* Probes */ + struct DRWPass *probe_background; + struct DRWPass *probe_glossy_compute; + struct DRWPass *probe_diffuse_compute; + struct DRWPass *probe_visibility_compute; + struct DRWPass *probe_grid_fill; + struct DRWPass *probe_display; + struct DRWPass *probe_planar_downsample_ps; + + /* Effects */ + struct DRWPass *ao_horizon_search; + struct DRWPass *ao_horizon_search_layer; + struct DRWPass *ao_horizon_debug; + struct DRWPass *ao_accum_ps; + struct DRWPass *mist_accum_ps; + struct DRWPass *motion_blur; + struct DRWPass *bloom_blit; + struct DRWPass *bloom_downsample_first; + struct DRWPass *bloom_downsample; + struct DRWPass *bloom_upsample; + struct DRWPass *bloom_resolve; + struct DRWPass *dof_down; + struct DRWPass *dof_scatter; + struct DRWPass *dof_resolve; + struct DRWPass *volumetric_world_ps; + struct DRWPass *volumetric_objects_ps; + struct DRWPass *volumetric_scatter_ps; + struct DRWPass *volumetric_integration_ps; + struct DRWPass *volumetric_resolve_ps; + struct DRWPass *ssr_raytrace; + struct DRWPass *ssr_resolve; + struct DRWPass *sss_blur_ps; + struct DRWPass *sss_resolve_ps; + struct DRWPass *sss_accum_ps; + struct DRWPass *color_downsample_ps; + struct DRWPass *color_downsample_cube_ps; + struct DRWPass *taa_resolve; + + /* HiZ */ + struct DRWPass *minz_downlevel_ps; + struct DRWPass *maxz_downlevel_ps; + struct DRWPass *minz_downdepth_ps; + struct DRWPass *maxz_downdepth_ps; + struct DRWPass *minz_downdepth_layer_ps; + struct DRWPass *maxz_downdepth_layer_ps; + struct DRWPass *minz_copydepth_ps; + struct DRWPass *maxz_copydepth_ps; + + struct DRWPass *depth_pass; + struct DRWPass *depth_pass_cull; + struct DRWPass *depth_pass_clip; + struct DRWPass *depth_pass_clip_cull; + struct DRWPass *refract_depth_pass; + struct DRWPass *refract_depth_pass_cull; + struct DRWPass *refract_depth_pass_clip; + struct DRWPass *refract_depth_pass_clip_cull; + struct DRWPass *default_pass[VAR_MAT_MAX]; + struct DRWPass *sss_pass; + struct DRWPass *material_pass; + struct DRWPass *refract_pass; + struct DRWPass *transparent_pass; + struct DRWPass *background_pass; + struct DRWPass *update_noise_pass; +} EEVEE_PassList; + +typedef struct EEVEE_FramebufferList { + /* Effects */ + struct GPUFrameBuffer *gtao_fb; + struct GPUFrameBuffer *gtao_debug_fb; + struct GPUFrameBuffer *downsample_fb; + struct GPUFrameBuffer *effect_fb; + struct GPUFrameBuffer *bloom_blit_fb; + struct GPUFrameBuffer *bloom_down_fb[MAX_BLOOM_STEP]; + struct GPUFrameBuffer *bloom_accum_fb[MAX_BLOOM_STEP - 1]; + struct GPUFrameBuffer *sss_blur_fb; + struct GPUFrameBuffer *sss_clear_fb; + struct GPUFrameBuffer *sss_accum_fb; + struct GPUFrameBuffer *dof_down_fb; + struct GPUFrameBuffer *dof_scatter_far_fb; + struct GPUFrameBuffer *dof_scatter_near_fb; + struct GPUFrameBuffer *volumetric_fb; + struct GPUFrameBuffer *volumetric_scat_fb; + struct GPUFrameBuffer *volumetric_integ_fb; + struct GPUFrameBuffer *screen_tracing_fb; + struct GPUFrameBuffer *refract_fb; + struct GPUFrameBuffer *mist_accum_fb; + struct GPUFrameBuffer *ao_accum_fb; + + struct GPUFrameBuffer *update_noise_fb; + + struct GPUFrameBuffer *planarref_fb; + + struct GPUFrameBuffer *main; + struct GPUFrameBuffer *double_buffer; + struct GPUFrameBuffer *depth_double_buffer_fb; +} EEVEE_FramebufferList; + +typedef struct EEVEE_TextureList { + /* Effects */ + struct GPUTexture *color_post; /* R16_G16_B16 */ + struct GPUTexture *dof_down_near; /* R16_G16_B16_A16 */ + struct GPUTexture *dof_down_far; /* R16_G16_B16_A16 */ + struct GPUTexture *dof_coc; /* R16_G16 */ + struct GPUTexture *dof_near_blur; /* R16_G16_B16_A16 */ + struct GPUTexture *dof_far_blur; /* R16_G16_B16_A16 */ + struct GPUTexture *bloom_blit; /* R16_G16_B16 */ + struct GPUTexture *bloom_downsample[MAX_BLOOM_STEP]; /* R16_G16_B16 */ + struct GPUTexture *bloom_upsample[MAX_BLOOM_STEP - 1]; /* R16_G16_B16 */ + struct GPUTexture *mist_accum; + struct GPUTexture *ao_accum; + struct GPUTexture *sss_dir_accum; + struct GPUTexture *sss_col_accum; + struct GPUTexture *ssr_normal_input; + struct GPUTexture *ssr_specrough_input; + struct GPUTexture *ssr_hit_output; + struct GPUTexture *refract_color; + + struct GPUTexture *volume_prop_scattering; + struct GPUTexture *volume_prop_extinction; + struct GPUTexture *volume_prop_emission; + struct GPUTexture *volume_prop_phase; + struct GPUTexture *volume_scatter; + struct GPUTexture *volume_transmittance; + struct GPUTexture *volume_scatter_history; + struct GPUTexture *volume_transmittance_history; + + struct GPUTexture *planar_pool; + struct GPUTexture *planar_depth; + + struct GPUTexture *gtao_horizons; + + struct GPUTexture *sss_data; + struct GPUTexture *sss_albedo; + struct GPUTexture *sss_blur; + struct GPUTexture *sss_stencil; + + struct GPUTexture *maxzbuffer; + + struct GPUTexture *color; /* R16_G16_B16 */ + struct GPUTexture *color_double_buffer; + struct GPUTexture *depth_double_buffer; +} EEVEE_TextureList; + +typedef struct EEVEE_StorageList { + /* Effects */ + struct EEVEE_EffectsInfo *effects; + + struct EEVEE_PrivateData *g_data; +} EEVEE_StorageList; + +/* ************ LIGHT UBO ************* */ +typedef struct EEVEE_Light { + float position[3], dist; + float color[3], spec; + float spotsize, spotblend, radius, shadowid; + float rightvec[3], sizex; + float upvec[3], sizey; + float forwardvec[3], lamptype; +} EEVEE_Light; + +typedef struct EEVEE_Shadow { + float near, far, bias, exp; + float shadow_start, data_start, multi_shadow_count, shadow_blur; + float contact_dist, contact_bias, contact_spread, contact_thickness; +} EEVEE_Shadow; + +typedef struct EEVEE_ShadowCube { + float position[3], pad; +} EEVEE_ShadowCube; + +typedef struct EEVEE_ShadowCascade { + float shadowmat[MAX_CASCADE_NUM][4][4]; /* World->Lamp->NDC->Tex : used for sampling the shadow map. */ + float split_start[4]; + float split_end[4]; +} EEVEE_ShadowCascade; + +typedef struct EEVEE_ShadowRender { + float shadowmat[6][4][4]; /* World->Lamp->NDC : used to render the shadow map. 6 frustum for cubemap shadow */ + float viewmat[6][4][4]; /* World->Lamp : used to render the shadow map. 6 viewmat for cubemap shadow */ + float position[3], pad; + float cube_texel_size; + float stored_texel_size; + float clip_near; + float clip_far; + int shadow_samples_ct; + float shadow_inv_samples_ct; +} EEVEE_ShadowRender; + +/* This is just a really long bitflag with special function to access it. */ +#define MAX_LIGHTBITS_FIELDS (MAX_LIGHT / 8) +typedef struct EEVEE_LightBits { + unsigned char fields[MAX_LIGHTBITS_FIELDS]; +} EEVEE_LightBits; + +typedef struct EEVEE_ShadowCaster { + struct EEVEE_LightBits bits; + struct EEVEE_BoundBox bbox; +} EEVEE_ShadowCaster; + +typedef struct EEVEE_ShadowCasterBuffer { + struct EEVEE_ShadowCaster *shadow_casters; + char *flags; + unsigned int alloc_count; + unsigned int count; +} EEVEE_ShadowCasterBuffer; + +/* ************ LIGHT DATA ************* */ +typedef struct EEVEE_LampsInfo { + int num_light, cache_num_light; + int num_layer, cache_num_layer; + int gpu_cube_ct, gpu_cascade_ct, gpu_shadow_ct; + int cpu_cube_ct, cpu_cascade_ct; + int update_flag; + int shadow_size, shadow_method; + bool shadow_high_bitdepth; + int shadow_cube_target_size; + int current_shadow_cascade; + int current_shadow_face; + float filter_size; + /* List of lights in the scene. */ + /* XXX This is fragile, can get out of sync quickly. */ + struct Object *light_ref[MAX_LIGHT]; + struct Object *shadow_cube_ref[MAX_SHADOW_CUBE]; + struct Object *shadow_cascade_ref[MAX_SHADOW_CASCADE]; + /* UBO Storage : data used by UBO */ + struct EEVEE_Light light_data[MAX_LIGHT]; + struct EEVEE_ShadowRender shadow_render_data; + struct EEVEE_Shadow shadow_data[MAX_SHADOW]; + struct EEVEE_ShadowCube shadow_cube_data[MAX_SHADOW_CUBE]; + struct EEVEE_ShadowCascade shadow_cascade_data[MAX_SHADOW_CASCADE]; + /* Lights tracking */ + int new_shadow_id[MAX_LIGHT]; /* To be able to convert old bitfield to new bitfield */ + struct EEVEE_BoundSphere shadow_bounds[MAX_LIGHT]; /* Tighly packed light bounds */ + /* Pointers only. */ + struct EEVEE_ShadowCasterBuffer *shcaster_frontbuffer; + struct EEVEE_ShadowCasterBuffer *shcaster_backbuffer; +} EEVEE_LampsInfo; + +/* EEVEE_LampsInfo->shadow_casters_flag */ +enum { + SHADOW_CASTER_PRUNED = (1 << 0), + SHADOW_CASTER_UPDATED = (1 << 1), +}; + +/* EEVEE_LampsInfo->update_flag */ +enum { + LIGHT_UPDATE_SHADOW_CUBE = (1 << 0), +}; + +/* ************ PROBE UBO ************* */ +typedef struct EEVEE_LightProbe { + float position[3], parallax_type; + float attenuation_fac; + float attenuation_type; + float pad3[2]; + float attenuationmat[4][4]; + float parallaxmat[4][4]; +} EEVEE_LightProbe; + +typedef struct EEVEE_LightGrid { + float mat[4][4]; + int resolution[3], offset; + float corner[3], attenuation_scale; + float increment_x[3], attenuation_bias; /* world space vector between 2 opposite cells */ + float increment_y[3], level_bias; + float increment_z[3], pad4; + float visibility_bias, visibility_bleed, visibility_range, pad5; +} EEVEE_LightGrid; + +typedef struct EEVEE_PlanarReflection { + float plane_equation[4]; + float clip_vec_x[3], attenuation_scale; + float clip_vec_y[3], attenuation_bias; + float clip_edge_x_pos, clip_edge_x_neg; + float clip_edge_y_pos, clip_edge_y_neg; + float facing_scale, facing_bias, pad[2]; + float reflectionmat[4][4]; +} EEVEE_PlanarReflection; + +/* ************ PROBE DATA ************* */ +typedef struct EEVEE_LightProbesInfo { + int num_cube, cache_num_cube; + int num_grid, cache_num_grid; + int num_planar, cache_num_planar; + int total_irradiance_samples; /* Total for all grids */ + int cache_irradiance_size[3]; + int update_flag; + int updated_bounce; + int num_bounce; + int cubemap_res; + int target_size; + int grid_initialized; + struct World *prev_world; + bool do_cube_update; + /* For rendering probes */ + float probemat[6][4][4]; + int layer; + float texel_size; + float padding_size; + float samples_ct; + float invsamples_ct; + float near_clip; + float far_clip; + float roughness; + float lodfactor; + float lod_rt_max, lod_cube_max, lod_planar_max; + float visibility_range; + float visibility_blur; + float intensity_fac; + int shres; + /* List of probes in the scene. */ + /* XXX This is fragile, can get out of sync quickly. */ + struct Object *probes_cube_ref[MAX_PROBE]; + struct Object *probes_grid_ref[MAX_GRID]; + struct Object *probes_planar_ref[MAX_PLANAR]; + /* UBO Storage : data used by UBO */ + struct EEVEE_LightProbe probe_data[MAX_PROBE]; + struct EEVEE_LightGrid grid_data[MAX_GRID]; + struct EEVEE_PlanarReflection planar_data[MAX_PLANAR]; +} EEVEE_LightProbesInfo; + +/* EEVEE_LightProbesInfo->update_flag */ +enum { + PROBE_UPDATE_CUBE = (1 << 0), + PROBE_UPDATE_GRID = (1 << 1), + PROBE_UPDATE_ALL = 0xFFFFFF, +}; + +/* ************ EFFECTS DATA ************* */ +typedef struct EEVEE_EffectsInfo { + int enabled_effects; + bool swap_double_buffer; + /* SSSS */ + int sss_sample_count; + bool sss_separate_albedo; + /* Volumetrics */ + int volume_current_sample; + /* SSR */ + bool reflection_trace_full; + int ssr_neighbor_ofs; + int ssr_halfres_ofs[2]; + /* Temporal Anti Aliasing */ + int taa_current_sample; + int taa_render_sample; + int taa_total_sample; + float taa_alpha; + bool prev_drw_support; + float prev_drw_persmat[4][4]; + float overide_persmat[4][4]; + float overide_persinv[4][4]; + float overide_winmat[4][4]; + float overide_wininv[4][4]; + /* Ambient Occlusion */ + int ao_depth_layer; + struct GPUTexture *ao_src_depth; /* pointer copy */ + /* Motion Blur */ + float current_ndc_to_world[4][4]; + float past_world_to_ndc[4][4]; + int motion_blur_samples; + /* Depth Of Field */ + float dof_near_far[2]; + float dof_params[3]; + float dof_bokeh[4]; + float dof_layer_select[2]; + int dof_target_size[2]; + /* Bloom */ + int bloom_iteration_ct; + float source_texel_size[2]; + float blit_texel_size[2]; + float downsamp_texel_size[MAX_BLOOM_STEP][2]; + float bloom_color[3]; + float bloom_clamp; + float bloom_sample_scale; + float bloom_curve_threshold[4]; + float unf_source_texel_size[2]; + struct GPUTexture *unf_source_buffer; /* pointer copy */ + struct GPUTexture *unf_base_buffer; /* pointer copy */ + /* Not alloced, just a copy of a *GPUtexture in EEVEE_TextureList. */ + struct GPUTexture *source_buffer; /* latest updated texture */ + struct GPUFrameBuffer *target_buffer; /* next target to render to */ + struct GPUTexture *final_tx; /* Final color to transform to display color space. */ + struct GPUFrameBuffer *final_fb; /* Framebuffer with final_tx as attachement. */ +} EEVEE_EffectsInfo; + +enum { + EFFECT_MOTION_BLUR = (1 << 0), + EFFECT_BLOOM = (1 << 1), + EFFECT_DOF = (1 << 2), + EFFECT_VOLUMETRIC = (1 << 3), + EFFECT_SSR = (1 << 4), + EFFECT_DOUBLE_BUFFER = (1 << 5), /* Not really an effect but a feature */ + EFFECT_REFRACT = (1 << 6), + EFFECT_GTAO = (1 << 7), + EFFECT_TAA = (1 << 8), + EFFECT_POST_BUFFER = (1 << 9), /* Not really an effect but a feature */ + EFFECT_NORMAL_BUFFER = (1 << 10), /* Not really an effect but a feature */ + EFFECT_SSS = (1 << 11), +}; + +/* ***************** COMMON DATA **************** */ + +/* Common uniform buffer containing all "constant" data over the whole drawing pipeline. */ +/* !! CAUTION !! + * - [i]vec3 need to be paded to [i]vec4 (even in ubo declaration). + * - Make sure that [i]vec4 start at a multiple of 16 bytes. + * - Arrays of vec2/vec3 are padded as arrays of vec4. + * - sizeof(bool) == sizeof(int) in GLSL so use int in C */ +typedef struct EEVEE_CommonUniformBuffer { + float prev_persmat[4][4]; /* mat4 */ + float view_vecs[2][4]; /* vec4[2] */ + float mip_ratio[10][4]; /* vec2[10] */ + /* Ambient Occlusion */ + /* -- 16 byte aligned -- */ + float ao_dist, pad1, ao_factor, pad2; /* vec4 */ + float ao_offset, ao_bounce_fac, ao_quality, ao_settings; /* vec4 */ + /* Volumetric */ + /* -- 16 byte aligned -- */ + int vol_tex_size[3], pad3; /* ivec3 */ + float vol_depth_param[3], pad4; /* vec3 */ + float vol_inv_tex_size[3], pad5; /* vec3 */ + float vol_jitter[3], pad6; /* vec3 */ + float vol_coord_scale[2], pad7[2]; /* vec2 */ + /* -- 16 byte aligned -- */ + float vol_history_alpha; /* float */ + float vol_light_clamp; /* float */ + float vol_shadow_steps; /* float */ + int vol_use_lights; /* bool */ + /* Screen Space Reflections */ + /* -- 16 byte aligned -- */ + float ssr_quality, ssr_thickness, ssr_pixelsize[2]; /* vec4 */ + float ssr_border_fac; /* float */ + float ssr_max_roughness; /* float */ + float ssr_firefly_fac; /* float */ + float ssr_brdf_bias; /* float */ + int ssr_toggle; /* bool */ + /* SubSurface Scattering */ + float sss_jitter_threshold; /* float */ + int sss_toggle; /* bool */ + /* Specular */ + int spec_toggle; /* bool */ + /* Lamps */ + int la_num_light; /* int */ + /* Probes */ + int prb_num_planar; /* int */ + int prb_num_render_cube; /* int */ + int prb_num_render_grid; /* int */ + int prb_irradiance_vis_size; /* int */ + float prb_lod_cube_max; /* float */ + float prb_lod_planar_max; /* float */ +} EEVEE_CommonUniformBuffer; + +/* ************** SCENE LAYER DATA ************** */ +typedef struct EEVEE_ViewLayerData { + /* Lamps */ + struct EEVEE_LampsInfo *lamps; + + struct GPUUniformBuffer *light_ubo; + struct GPUUniformBuffer *shadow_ubo; + struct GPUUniformBuffer *shadow_render_ubo; + struct GPUUniformBuffer *shadow_samples_ubo; + + struct GPUFrameBuffer *shadow_target_fb; + struct GPUFrameBuffer *shadow_store_fb; + + struct GPUTexture *shadow_cube_target; + struct GPUTexture *shadow_cube_blur; + struct GPUTexture *shadow_cascade_target; + struct GPUTexture *shadow_cascade_blur; + struct GPUTexture *shadow_pool; + + struct EEVEE_ShadowCasterBuffer shcasters_buffers[2]; + + /* Probes */ + struct EEVEE_LightProbesInfo *probes; + + struct GPUUniformBuffer *probe_ubo; + struct GPUUniformBuffer *grid_ubo; + struct GPUUniformBuffer *planar_ubo; + + struct GPUFrameBuffer *probe_fb; + struct GPUFrameBuffer *probe_filter_fb; + + struct GPUTexture *probe_rt; + struct GPUTexture *probe_depth_rt; + struct GPUTexture *probe_pool; + struct GPUTexture *irradiance_pool; + struct GPUTexture *irradiance_rt; + + /* Common Uniform Buffer */ + struct EEVEE_CommonUniformBuffer common_data; + struct GPUUniformBuffer *common_ubo; +} EEVEE_ViewLayerData; + +/* ************ OBJECT DATA ************ */ +typedef struct EEVEE_LightData { + short light_id, shadow_id; +} EEVEE_LightData; + +typedef struct EEVEE_ShadowCubeData { + short light_id, shadow_id, cube_id, layer_id; +} EEVEE_ShadowCubeData; + +typedef struct EEVEE_ShadowCascadeData { + short light_id, shadow_id, cascade_id, layer_id; + float viewprojmat[MAX_CASCADE_NUM][4][4]; /* World->Lamp->NDC : used for rendering the shadow map. */ + float radius[MAX_CASCADE_NUM]; +} EEVEE_ShadowCascadeData; + +/* Theses are the structs stored inside Objects. + * It works with even if the object is in multiple layers + * because we don't get the same "Object *" for each layer. */ +typedef struct EEVEE_LampEngineData { + ObjectEngineData engine_data; + + bool need_update; + /* This needs to be out of the union to avoid undefined behaviour. */ + short prev_cube_shadow_id; + union { + struct EEVEE_LightData ld; + struct EEVEE_ShadowCubeData scd; + struct EEVEE_ShadowCascadeData scad; + } data; +} EEVEE_LampEngineData; + +typedef struct EEVEE_LightProbeEngineData { + ObjectEngineData engine_data; + + /* NOTE: need_full_update is set by dependency graph when the probe or it's + * object is updated. This triggers full probe update, including it's + * "progressive" GI refresh. + * + * need_update is always set to truth when need_full_update is tagged, but + * might also be forced to be kept truth during GI refresh stages. + * + * TODO(sergey): Is there a way to avoid two flags here, or at least make + * it more clear what's going on here? + */ + bool need_full_update; + bool need_update; + + bool ready_to_shade; + int updated_cells; + int updated_lvl; + int num_cell; + int max_lvl; + int probe_id; /* Only used for display data */ + float probe_size; /* Only used for display data */ + /* For planar reflection rendering */ + float viewmat[4][4]; + float persmat[4][4]; + float planer_eq_offset[4]; + struct ListBase captured_object_list; +} EEVEE_LightProbeEngineData; + +typedef struct EEVEE_ObjectEngineData { + ObjectEngineData engine_data; + + bool need_update; + unsigned int shadow_caster_id; +} EEVEE_ObjectEngineData; + +/* *********************************** */ + +typedef struct EEVEE_Data { + void *engine_type; + EEVEE_FramebufferList *fbl; + EEVEE_TextureList *txl; + EEVEE_PassList *psl; + EEVEE_StorageList *stl; +} EEVEE_Data; + +typedef struct EEVEE_PrivateData { + struct DRWShadingGroup *shadow_shgrp; + struct DRWShadingGroup *depth_shgrp; + struct DRWShadingGroup *depth_shgrp_cull; + struct DRWShadingGroup *depth_shgrp_clip; + struct DRWShadingGroup *depth_shgrp_clip_cull; + struct DRWShadingGroup *refract_depth_shgrp; + struct DRWShadingGroup *refract_depth_shgrp_cull; + struct DRWShadingGroup *refract_depth_shgrp_clip; + struct DRWShadingGroup *refract_depth_shgrp_clip_cull; + struct DRWShadingGroup *cube_display_shgrp; + struct DRWShadingGroup *planar_display_shgrp; + struct DRWShadingGroup *planar_downsample; + struct GHash *material_hash; + struct GHash *hair_material_hash; + struct GPUTexture *minzbuffer; + struct GPUTexture *ssr_pdf_output; + struct GPUTexture *gtao_horizons_debug; + float background_alpha; /* TODO find a better place for this. */ + /* For planar probes */ + float planar_texel_size[2]; + /* For double buffering */ + bool view_updated; + bool valid_double_buffer; + /* Render Matrices */ + float persmat[4][4], persinv[4][4]; + float viewmat[4][4], viewinv[4][4]; + float winmat[4][4], wininv[4][4]; + /* Mist Settings */ + float mist_start, mist_inv_dist, mist_falloff; +} EEVEE_PrivateData; /* Transient data */ + +/* eevee_data.c */ +EEVEE_ViewLayerData *EEVEE_view_layer_data_get(void); +EEVEE_ViewLayerData *EEVEE_view_layer_data_ensure(void); +EEVEE_ObjectEngineData *EEVEE_object_data_get(Object *ob); +EEVEE_ObjectEngineData *EEVEE_object_data_ensure(Object *ob); +EEVEE_LightProbeEngineData *EEVEE_lightprobe_data_get(Object *ob); +EEVEE_LightProbeEngineData *EEVEE_lightprobe_data_ensure(Object *ob); +EEVEE_LampEngineData *EEVEE_lamp_data_get(Object *ob); +EEVEE_LampEngineData *EEVEE_lamp_data_ensure(Object *ob); + +/* eevee_materials.c */ +struct GPUTexture *EEVEE_materials_get_util_tex(void); /* XXX */ +void EEVEE_materials_init(EEVEE_ViewLayerData *sldata, EEVEE_StorageList *stl, EEVEE_FramebufferList *fbl); +void EEVEE_materials_cache_init(EEVEE_Data *vedata); +void EEVEE_materials_cache_populate(EEVEE_Data *vedata, EEVEE_ViewLayerData *sldata, Object *ob); +void EEVEE_materials_cache_finish(EEVEE_Data *vedata); +struct GPUMaterial *EEVEE_material_world_lightprobe_get(struct Scene *scene, struct World *wo); +struct GPUMaterial *EEVEE_material_world_background_get(struct Scene *scene, struct World *wo); +struct GPUMaterial *EEVEE_material_world_volume_get(struct Scene *scene, struct World *wo); +struct GPUMaterial *EEVEE_material_mesh_get( + struct Scene *scene, Material *ma, EEVEE_Data *vedata, + bool use_blend, bool use_multiply, bool use_refract, bool use_sss, bool use_translucency, int shadow_method); +struct GPUMaterial *EEVEE_material_mesh_volume_get(struct Scene *scene, Material *ma); +struct GPUMaterial *EEVEE_material_mesh_depth_get(struct Scene *scene, Material *ma, bool use_hashed_alpha, bool is_shadow); +struct GPUMaterial *EEVEE_material_hair_get(struct Scene *scene, Material *ma, int shadow_method); +void EEVEE_materials_free(void); +void EEVEE_draw_default_passes(EEVEE_PassList *psl); +void EEVEE_update_noise(EEVEE_PassList *psl, EEVEE_FramebufferList *fbl, double offsets[3]); + +/* eevee_lights.c */ +void EEVEE_lights_init(EEVEE_ViewLayerData *sldata); +void EEVEE_lights_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_PassList *psl); +void EEVEE_lights_cache_add(EEVEE_ViewLayerData *sldata, struct Object *ob); +void EEVEE_lights_cache_shcaster_add( + EEVEE_ViewLayerData *sldata, EEVEE_PassList *psl, struct Gwn_Batch *geom, float (*obmat)[4]); +void EEVEE_lights_cache_shcaster_material_add( + EEVEE_ViewLayerData *sldata, EEVEE_PassList *psl, + struct GPUMaterial *gpumat, struct Gwn_Batch *geom, struct Object *ob, + float (*obmat)[4], float *alpha_threshold); +void EEVEE_lights_cache_shcaster_object_add(EEVEE_ViewLayerData *sldata, struct Object *ob); +void EEVEE_lights_cache_finish(EEVEE_ViewLayerData *sldata); +void EEVEE_lights_update(EEVEE_ViewLayerData *sldata); +void EEVEE_draw_shadows(EEVEE_ViewLayerData *sldata, EEVEE_PassList *psl); +void EEVEE_lights_free(void); + +/* eevee_lightprobes.c */ +bool EEVEE_lightprobes_all_probes_ready(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_lightprobes_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_lightprobes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_lightprobes_cache_add(EEVEE_ViewLayerData *sldata, Object *ob); +void EEVEE_lightprobes_cache_finish(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_lightprobes_refresh(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_lightprobes_refresh_planar(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_lightprobes_free(void); + +/* eevee_depth_of_field.c */ +int EEVEE_depth_of_field_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, Object *camera); +void EEVEE_depth_of_field_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_depth_of_field_draw(EEVEE_Data *vedata); +void EEVEE_depth_of_field_free(void); + +/* eevee_bloom.c */ +int EEVEE_bloom_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_bloom_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_bloom_draw(EEVEE_Data *vedata); +void EEVEE_bloom_free(void); + +/* eevee_occlusion.c */ +int EEVEE_occlusion_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_occlusion_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_occlusion_output_accumulate(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_occlusion_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_occlusion_compute(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, struct GPUTexture *depth_src, int layer); +void EEVEE_occlusion_draw_debug(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_occlusion_free(void); + +/* eevee_screen_raytrace.c */ +int EEVEE_screen_raytrace_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_screen_raytrace_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_refraction_compute(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_reflection_compute(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_screen_raytrace_free(void); + +/* eevee_subsurface.c */ +int EEVEE_subsurface_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_subsurface_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_subsurface_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_subsurface_add_pass( + EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, unsigned int sss_id, struct GPUUniformBuffer *sss_profile); +void EEVEE_subsurface_data_render(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_subsurface_compute(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_subsurface_output_accumulate(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_subsurface_free(void); + +/* eevee_motion_blur.c */ +int EEVEE_motion_blur_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, Object *camera); +void EEVEE_motion_blur_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_motion_blur_draw(EEVEE_Data *vedata); +void EEVEE_motion_blur_free(void); + +/* eevee_mist.c */ +void EEVEE_mist_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_mist_output_accumulate(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);; +void EEVEE_mist_free(void); + +/* eevee_temporal_sampling.c */ +int EEVEE_temporal_sampling_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_temporal_sampling_matrices_calc( + EEVEE_EffectsInfo *effects, float viewmat[4][4], float persmat[4][4], double ht_point[2]); +void EEVEE_temporal_sampling_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_temporal_sampling_draw(EEVEE_Data *vedata); +void EEVEE_temporal_sampling_free(void); + +/* eevee_volumes.c */ +int EEVEE_volumes_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_volumes_set_jitter(EEVEE_ViewLayerData *sldata, unsigned int current_sample); +void EEVEE_volumes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_volumes_cache_object_add(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, struct Scene *scene, Object *ob); +void EEVEE_volumes_compute(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_volumes_resolve(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_volumes_free_smoke_textures(void); +void EEVEE_volumes_free(void); + +/* eevee_effects.c */ +void EEVEE_effects_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, Object *camera); +void EEVEE_effects_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_create_minmax_buffer(EEVEE_Data *vedata, struct GPUTexture *depth_src, int layer); +void EEVEE_downsample_buffer(EEVEE_Data *vedata, struct GPUFrameBuffer *fb_src, struct GPUTexture *texture_src, int level); +void EEVEE_downsample_cube_buffer(EEVEE_Data *vedata, struct GPUFrameBuffer *fb_src, struct GPUTexture *texture_src, int level); +void EEVEE_effects_do_gtao(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_draw_effects(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata); +void EEVEE_effects_free(void); + +/* eevee_render.c */ +void EEVEE_render_init(EEVEE_Data *vedata, struct RenderEngine *engine, struct Depsgraph *depsgraph); +void EEVEE_render_cache(void *vedata, struct Object *ob, struct RenderEngine *engine, struct Depsgraph *depsgraph); +void EEVEE_render_draw(EEVEE_Data *vedata, struct RenderEngine *engine, struct Depsgraph *depsgraph); +void EEVEE_render_update_passes(struct RenderEngine *engine, struct Scene *scene, struct ViewLayer *view_layer); + +/* Shadow Matrix */ +static const float texcomat[4][4] = { /* From NDC to TexCo */ + {0.5f, 0.0f, 0.0f, 0.0f}, + {0.0f, 0.5f, 0.0f, 0.0f}, + {0.0f, 0.0f, 0.5f, 0.0f}, + {0.5f, 0.5f, 0.5f, 1.0f} +}; + +/* Cubemap Matrices */ +static const float cubefacemat[6][4][4] = { + /* Pos X */ + {{0.0f, 0.0f, -1.0f, 0.0f}, + {0.0f, -1.0f, 0.0f, 0.0f}, + {-1.0f, 0.0f, 0.0f, 0.0f}, + {0.0f, 0.0f, 0.0f, 1.0f}}, + /* Neg X */ + {{0.0f, 0.0f, 1.0f, 0.0f}, + {0.0f, -1.0f, 0.0f, 0.0f}, + {1.0f, 0.0f, 0.0f, 0.0f}, + {0.0f, 0.0f, 0.0f, 1.0f}}, + /* Pos Y */ + {{1.0f, 0.0f, 0.0f, 0.0f}, + {0.0f, 0.0f, -1.0f, 0.0f}, + {0.0f, 1.0f, 0.0f, 0.0f}, + {0.0f, 0.0f, 0.0f, 1.0f}}, + /* Neg Y */ + {{1.0f, 0.0f, 0.0f, 0.0f}, + {0.0f, 0.0f, 1.0f, 0.0f}, + {0.0f, -1.0f, 0.0f, 0.0f}, + {0.0f, 0.0f, 0.0f, 1.0f}}, + /* Pos Z */ + {{1.0f, 0.0f, 0.0f, 0.0f}, + {0.0f, -1.0f, 0.0f, 0.0f}, + {0.0f, 0.0f, -1.0f, 0.0f}, + {0.0f, 0.0f, 0.0f, 1.0f}}, + /* Neg Z */ + {{-1.0f, 0.0f, 0.0f, 0.0f}, + {0.0f, -1.0f, 0.0f, 0.0f}, + {0.0f, 0.0f, 1.0f, 0.0f}, + {0.0f, 0.0f, 0.0f, 1.0f}}, +}; + +#endif /* __EEVEE_PRIVATE_H__ */ |