dillongoostudios/goo-engine
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert: GOOENGINE: Convert engine to use instance

Browse Source 
Reverts the change to instance.
Breaks viewport sampling. Seems the instance data resets on every sample so if the viewport uses more than 1 sample it never makes it past 1 sample and just keeps running forever.

Need to figure out how to fix that before making the change to instance again
This commit is contained in:
Cody Winchester
2026-03-20 23:53:08 -05:00
parent cafc657eff
commit 7604f5fb10
24 changed files with 1684 additions and 1796 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/blender/draw/engines/gooengine/eevee_bloom.cc
+48 -38
View File
@@ -20,8 +20,9 @@ static const bool use_highres = true;
int EEVEE_bloom_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_EffectsInfo *effects = stl->effects;
const DRWContextState *draw_ctx = DRW_context_state_get();
const Scene *scene_eval = DEG_get_evaluated_scene(draw_ctx->depsgraph);
@@ -47,7 +48,7 @@ int EEVEE_bloom_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
blitsize[0], blitsize[1], GPU_R11F_G11F_B10F, usage, &draw_engine_eevee_type);
GPU_framebuffer_ensure_config(
&inst->bloom_blit_fb, {GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(effects->bloom_blit)});
&fbl->bloom_blit_fb, {GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(effects->bloom_blit)});
/* Parameters */
const float threshold = scene_eval->eevee.bloom_threshold;
@@ -89,7 +90,7 @@ int EEVEE_bloom_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
effects->bloom_downsample[i] = DRW_texture_pool_query_2d_ex(
texsize[0], texsize[1], GPU_R11F_G11F_B10F, downsample_usage, &draw_engine_eevee_type);
GPU_framebuffer_ensure_config(
&inst->bloom_down_fb[i],
&fbl->bloom_down_fb[i],
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(effects->bloom_downsample[i])});
}
@@ -108,7 +109,7 @@ int EEVEE_bloom_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
effects->bloom_upsample[i] = DRW_texture_pool_query_2d_ex(
texsize[0], texsize[1], GPU_R11F_G11F_B10F, upsample_usage, &draw_engine_eevee_type);
GPU_framebuffer_ensure_config(
&inst->bloom_accum_fb[i],
&fbl->bloom_accum_fb[i],
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(effects->bloom_upsample[i])});
}
@@ -116,11 +117,11 @@ int EEVEE_bloom_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
}
/* Cleanup to release memory */
GPU_FRAMEBUFFER_FREE_SAFE(inst->bloom_blit_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->bloom_blit_fb);
for (int i = 0; i < MAX_BLOOM_STEP - 1; i++) {
GPU_FRAMEBUFFER_FREE_SAFE(inst->bloom_down_fb[i]);
GPU_FRAMEBUFFER_FREE_SAFE(inst->bloom_accum_fb[i]);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->bloom_down_fb[i]);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->bloom_accum_fb[i]);
}
return 0;
@@ -156,10 +157,11 @@ static DRWShadingGroup *eevee_create_bloom_pass(const char *name,
void EEVEE_bloom_cache_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
inst->bloom_accum_ps = nullptr;
psl->bloom_accum_ps = nullptr;
if ((effects->enabled_effects & EFFECT_BLOOM) != 0) {
/**
@@ -197,21 +199,21 @@ void EEVEE_bloom_cache_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata
eevee_create_bloom_pass("Bloom Downsample First",
effects,
EEVEE_shaders_bloom_downsample_get(use_antiflicker),
&inst->bloom_downsample_first,
&psl->bloom_downsample_first,
false,
false,
false);
eevee_create_bloom_pass("Bloom Downsample",
effects,
EEVEE_shaders_bloom_downsample_get(false),
&inst->bloom_downsample,
&psl->bloom_downsample,
false,
false,
false);
eevee_create_bloom_pass("Bloom Upsample",
effects,
EEVEE_shaders_bloom_upsample_get(use_highres),
&inst->bloom_upsample,
&psl->bloom_upsample,
true,
false,
false);
@@ -219,7 +221,7 @@ void EEVEE_bloom_cache_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata
grp = eevee_create_bloom_pass("Bloom Blit",
effects,
EEVEE_shaders_bloom_blit_get(use_antiflicker),
&inst->bloom_blit,
&psl->bloom_blit,
false,
false,
false);
@@ -229,7 +231,7 @@ void EEVEE_bloom_cache_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata
grp = eevee_create_bloom_pass("Bloom Resolve",
effects,
EEVEE_shaders_bloom_resolve_get(use_highres),
&inst->bloom_resolve,
&psl->bloom_resolve,
true,
true,
true);
@@ -238,8 +240,11 @@ void EEVEE_bloom_cache_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata
void EEVEE_bloom_draw(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
/* Bloom */
if ((effects->enabled_effects & EFFECT_BLOOM) != 0) {
@@ -249,15 +254,15 @@ void EEVEE_bloom_draw(EEVEE_Data *vedata)
copy_v2_v2(effects->unf_source_texel_size, effects->source_texel_size);
effects->unf_source_buffer = effects->source_buffer;
GPU_framebuffer_bind(inst->bloom_blit_fb);
DRW_draw_pass(inst->bloom_blit);
GPU_framebuffer_bind(fbl->bloom_blit_fb);
DRW_draw_pass(psl->bloom_blit);
/* Downsample */
copy_v2_v2(effects->unf_source_texel_size, effects->blit_texel_size);
effects->unf_source_buffer = effects->bloom_blit;
GPU_framebuffer_bind(inst->bloom_down_fb[0]);
DRW_draw_pass(inst->bloom_downsample_first);
GPU_framebuffer_bind(fbl->bloom_down_fb[0]);
DRW_draw_pass(psl->bloom_downsample_first);
last = effects->bloom_downsample[0];
@@ -265,8 +270,8 @@ void EEVEE_bloom_draw(EEVEE_Data *vedata)
copy_v2_v2(effects->unf_source_texel_size, effects->downsamp_texel_size[i - 1]);
effects->unf_source_buffer = last;
GPU_framebuffer_bind(inst->bloom_down_fb[i]);
DRW_draw_pass(inst->bloom_downsample);
GPU_framebuffer_bind(fbl->bloom_down_fb[i]);
DRW_draw_pass(psl->bloom_downsample);
/* Used in next loop */
last = effects->bloom_downsample[i];
@@ -278,8 +283,8 @@ void EEVEE_bloom_draw(EEVEE_Data *vedata)
effects->unf_source_buffer = last;
effects->unf_base_buffer = effects->bloom_downsample[i];
GPU_framebuffer_bind(inst->bloom_accum_fb[i]);
DRW_draw_pass(inst->bloom_upsample);
GPU_framebuffer_bind(fbl->bloom_accum_fb[i]);
DRW_draw_pass(psl->bloom_upsample);
last = effects->bloom_upsample[i];
}
@@ -290,7 +295,7 @@ void EEVEE_bloom_draw(EEVEE_Data *vedata)
effects->unf_base_buffer = effects->source_buffer;
GPU_framebuffer_bind(effects->target_buffer);
DRW_draw_pass(inst->bloom_resolve);
DRW_draw_pass(psl->bloom_resolve);
SWAP_BUFFERS();
}
}
@@ -299,20 +304,23 @@ void EEVEE_bloom_output_init(EEVEE_ViewLayerData * /*sldata*/,
EEVEE_Data *vedata,
uint /*tot_samples*/)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
/* Create FrameBuffer. */
DRW_texture_ensure_fullscreen_2d(&inst->bloom_accum, GPU_R11F_G11F_B10F, DRWTextureFlag(0));
DRW_texture_ensure_fullscreen_2d(&txl->bloom_accum, GPU_R11F_G11F_B10F, DRWTextureFlag(0));
GPU_framebuffer_ensure_config(&inst->bloom_pass_accum_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(inst->bloom_accum)});
GPU_framebuffer_ensure_config(&fbl->bloom_pass_accum_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(txl->bloom_accum)});
/* Create Pass and shgroup. */
eevee_create_bloom_pass("Bloom Accumulate",
effects,
EEVEE_shaders_bloom_resolve_get(use_highres),
&inst->bloom_accum_ps,
&psl->bloom_accum_ps,
true,
true,
false);
@@ -320,13 +328,15 @@ void EEVEE_bloom_output_init(EEVEE_ViewLayerData * /*sldata*/,
void EEVEE_bloom_output_accumulate(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
if (inst->g_data->render_passes & EEVEE_RENDER_PASS_BLOOM) {
GPU_framebuffer_bind(inst->bloom_pass_accum_fb);
DRW_draw_pass(inst->bloom_accum_ps);
if (stl->g_data->render_passes & EEVEE_RENDER_PASS_BLOOM) {
GPU_framebuffer_bind(fbl->bloom_pass_accum_fb);
DRW_draw_pass(psl->bloom_accum_ps);
/* Restore */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}
source/blender/draw/engines/gooengine/eevee_cryptomatte.cc
+37 -36
View File
@@ -101,8 +101,8 @@ BLI_INLINE int eevee_cryptomatte_pixel_stride(const ViewLayer *view_layer)
void EEVEE_cryptomatte_renderpasses_init(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PrivateData *g_data = stl->g_data;
const DRWContextState *draw_ctx = DRW_context_state_get();
ViewLayer *view_layer = draw_ctx->view_layer;
@@ -136,8 +136,10 @@ void EEVEE_cryptomatte_output_init(EEVEE_ViewLayerData * /*sldata*/,
EEVEE_Data *vedata,
int /*tot_samples*/)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PrivateData *g_data = stl->g_data;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
const DRWContextState *draw_ctx = DRW_context_state_get();
@@ -168,11 +170,11 @@ void EEVEE_cryptomatte_output_init(EEVEE_ViewLayerData * /*sldata*/,
sizeof(EEVEE_CryptomatteSample));
}
DRW_texture_ensure_fullscreen_2d(&inst->cryptomatte, format, DRWTextureFlag(0));
GPU_framebuffer_ensure_config(&inst->cryptomatte_fb,
DRW_texture_ensure_fullscreen_2d(&txl->cryptomatte, format, DRWTextureFlag(0));
GPU_framebuffer_ensure_config(&fbl->cryptomatte_fb,
{
GPU_ATTACHMENT_TEXTURE(dtxl->depth),
GPU_ATTACHMENT_TEXTURE(inst->cryptomatte),
GPU_ATTACHMENT_TEXTURE(txl->cryptomatte),
});
}
@@ -184,9 +186,9 @@ void EEVEE_cryptomatte_output_init(EEVEE_ViewLayerData * /*sldata*/,
void EEVEE_cryptomatte_cache_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
if ((inst->g_data->render_passes & EEVEE_RENDER_PASS_CRYPTOMATTE) != 0) {
DRW_PASS_CREATE(inst->cryptomatte_ps, DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_EQUAL);
EEVEE_PassList *psl = vedata->psl;
if ((vedata->stl->g_data->render_passes & EEVEE_RENDER_PASS_CRYPTOMATTE) != 0) {
DRW_PASS_CREATE(psl->cryptomatte_ps, DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_EQUAL);
}
}
@@ -194,14 +196,13 @@ static DRWShadingGroup *eevee_cryptomatte_shading_group_create(
EEVEE_Data *vedata, EEVEE_ViewLayerData *sldata, Object *ob, Material *material, bool is_hair)
{
const DRWContextState *draw_ctx = DRW_context_state_get();
GOOENGINE_Instance *inst = vedata->instance;
const ViewLayer *view_layer = draw_ctx->view_layer;
const eViewLayerCryptomatteFlags cryptomatte_layers = eevee_cryptomatte_active_layers(
view_layer);
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_PrivateData *g_data = vedata->stl->g_data;
float cryptohash[4] = {0.0f};
EEVEE_PassList *psl = vedata->psl;
int layer_offset = 0;
if ((cryptomatte_layers & VIEW_LAYER_CRYPTOMATTE_OBJECT) != 0) {
uint32_t cryptomatte_hash = BKE_cryptomatte_object_hash(
@@ -226,7 +227,7 @@ static DRWShadingGroup *eevee_cryptomatte_shading_group_create(
}
DRWShadingGroup *grp = DRW_shgroup_create(EEVEE_shaders_cryptomatte_sh_get(is_hair),
inst->cryptomatte_ps);
psl->cryptomatte_ps);
DRW_shgroup_uniform_vec4_copy(grp, "cryptohash", cryptohash);
DRW_shgroup_uniform_block(grp, "shadow_block", sldata->shadow_ubo);
@@ -331,8 +332,8 @@ void EEVEE_cryptomatte_cache_populate(EEVEE_Data *vedata, EEVEE_ViewLayerData *s
* cryptomatte samples. */
static void eevee_cryptomatte_download_buffer(EEVEE_Data *vedata, GPUFrameBuffer *framebuffer)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PrivateData *g_data = stl->g_data;
const DRWContextState *draw_ctx = DRW_context_state_get();
const ViewLayer *view_layer = draw_ctx->view_layer;
const int num_cryptomatte_layers = eevee_cryptomatte_layers_count(view_layer);
@@ -391,9 +392,11 @@ static void eevee_cryptomatte_download_buffer(EEVEE_Data *vedata, GPUFrameBuffer
void EEVEE_cryptomatte_output_accumulate(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PrivateData *g_data = stl->g_data;
EEVEE_EffectsInfo *effects = stl->effects;
EEVEE_PassList *psl = vedata->psl;
const DRWContextState *draw_ctx = DRW_context_state_get();
const ViewLayer *view_layer = draw_ctx->view_layer;
const int cryptomatte_levels = view_layer->cryptomatte_levels;
@@ -404,14 +407,14 @@ void EEVEE_cryptomatte_output_accumulate(EEVEE_ViewLayerData * /*sldata*/, EEVEE
* integrating it into the accum buffer. */
if (g_data->cryptomatte_accurate_mode || current_sample < cryptomatte_levels) {
static float clear_color[4] = {0.0};
GPU_framebuffer_bind(inst->cryptomatte_fb);
GPU_framebuffer_clear_color(inst->cryptomatte_fb, clear_color);
DRW_draw_pass(inst->cryptomatte_ps);
GPU_framebuffer_bind(fbl->cryptomatte_fb);
GPU_framebuffer_clear_color(fbl->cryptomatte_fb, clear_color);
DRW_draw_pass(psl->cryptomatte_ps);
eevee_cryptomatte_download_buffer(vedata, inst->cryptomatte_fb);
eevee_cryptomatte_download_buffer(vedata, fbl->cryptomatte_fb);
/* Restore */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}
@@ -478,9 +481,10 @@ static int eevee_cryptomatte_sample_cmp_reverse(const void *a_, const void *b_)
* During post processing ensure that the total of weights per sample is between 0 and 1. */
static void eevee_cryptomatte_postprocess_weights(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PrivateData *g_data = stl->g_data;
EEVEE_EffectsInfo *effects = stl->effects;
EEVEE_TextureList *txl = vedata->txl;
const DRWContextState *draw_ctx = DRW_context_state_get();
const ViewLayer *view_layer = draw_ctx->view_layer;
const int num_cryptomatte_layers = eevee_cryptomatte_layers_count(view_layer);
@@ -493,7 +497,7 @@ static void eevee_cryptomatte_postprocess_weights(EEVEE_Data *vedata)
float *volumetric_transmittance_buffer = nullptr;
if ((effects->enabled_effects & EFFECT_VOLUMETRIC) != 0) {
volumetric_transmittance_buffer = static_cast<float *>(
GPU_texture_read(inst->volume_transmittance_accum, GPU_DATA_FLOAT, 0));
GPU_texture_read(txl->volume_transmittance_accum, GPU_DATA_FLOAT, 0));
}
const int num_samples = effects->taa_current_sample - 1;
@@ -613,8 +617,7 @@ void EEVEE_cryptomatte_render_result(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData * /*sldata*/)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_PrivateData *g_data = vedata->stl->g_data;
const DRWContextState *draw_ctx = DRW_context_state_get();
const ViewLayer *view_layer = draw_ctx->view_layer;
const eViewLayerCryptomatteFlags cryptomatte_layers = eViewLayerCryptomatteFlags(
@@ -624,8 +627,8 @@ void EEVEE_cryptomatte_render_result(RenderLayer *rl,
const int rect_width = BLI_rcti_size_x(rect);
const int rect_height = BLI_rcti_size_y(rect);
const int rect_offset_x = inst->g_data->overscan_pixels + rect->xmin;
const int rect_offset_y = inst->g_data->overscan_pixels + rect->ymin;
const int rect_offset_x = vedata->stl->g_data->overscan_pixels + rect->xmin;
const int rect_offset_y = vedata->stl->g_data->overscan_pixels + rect->ymin;
const float *viewport_size = DRW_viewport_size_get();
const int viewport_width = viewport_size[0];
EEVEE_CryptomatteSample *accum_buffer = g_data->cryptomatte_accum_buffer;
@@ -691,8 +694,7 @@ void EEVEE_cryptomatte_render_result(RenderLayer *rl,
void EEVEE_cryptomatte_store_metadata(EEVEE_Data *vedata, RenderResult *render_result)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_PrivateData *g_data = vedata->stl->g_data;
BLI_assert(g_data->cryptomatte_session);
BKE_cryptomatte_store_metadata(g_data->cryptomatte_session, render_result);
@@ -702,8 +704,7 @@ void EEVEE_cryptomatte_store_metadata(EEVEE_Data *vedata, RenderResult *render_r
void EEVEE_cryptomatte_free(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_PrivateData *g_data = vedata->stl->g_data;
MEM_SAFE_FREE(g_data->cryptomatte_accum_buffer);
MEM_SAFE_FREE(g_data->cryptomatte_download_buffer);
if (g_data->cryptomatte_session) {
source/blender/draw/engines/gooengine/eevee_depth_of_field.cc
+161 -141
View File
@@ -180,8 +180,10 @@ int EEVEE_depth_of_field_sample_count_get(EEVEE_EffectsInfo *effects,
int EEVEE_depth_of_field_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata, Object *camera)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_EffectsInfo *effects = stl->effects;
const DRWContextState *draw_ctx = DRW_context_state_get();
const Scene *scene_eval = DEG_get_evaluated_scene(draw_ctx->depsgraph);
@@ -242,7 +244,7 @@ int EEVEE_depth_of_field_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *veda
effects->dof_jitter_focus = focus_dist;
effects->dof_jitter_blades = blades;
int sample_count = EEVEE_temporal_sampling_sample_count_get(scene_eval, inst);
int sample_count = EEVEE_temporal_sampling_sample_count_get(scene_eval, stl);
sample_count = EEVEE_depth_of_field_sample_count_get(
effects, sample_count, &effects->dof_jitter_ring_count);
@@ -313,16 +315,16 @@ int EEVEE_depth_of_field_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *veda
effects->dof_jitter_radius = 0.0f;
/* Cleanup to release memory */
GPU_FRAMEBUFFER_FREE_SAFE(inst->dof_setup_fb);
GPU_FRAMEBUFFER_FREE_SAFE(inst->dof_flatten_tiles_fb);
GPU_FRAMEBUFFER_FREE_SAFE(inst->dof_dilate_tiles_fb);
GPU_FRAMEBUFFER_FREE_SAFE(inst->dof_reduce_fb);
GPU_FRAMEBUFFER_FREE_SAFE(inst->dof_reduce_copy_fb);
GPU_FRAMEBUFFER_FREE_SAFE(inst->dof_gather_fg_fb);
GPU_FRAMEBUFFER_FREE_SAFE(inst->dof_gather_bg_fb);
GPU_FRAMEBUFFER_FREE_SAFE(inst->dof_scatter_bg_fb);
DRW_TEXTURE_FREE_SAFE(inst->dof_reduced_color);
DRW_TEXTURE_FREE_SAFE(inst->dof_reduced_coc);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->dof_setup_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->dof_flatten_tiles_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->dof_dilate_tiles_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->dof_reduce_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->dof_reduce_copy_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->dof_gather_fg_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->dof_gather_bg_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->dof_scatter_bg_fb);
DRW_TEXTURE_FREE_SAFE(txl->dof_reduced_color);
DRW_TEXTURE_FREE_SAFE(txl->dof_reduced_coc);
return 0;
}
@@ -338,7 +340,8 @@ static const GPUSamplerState NO_FILTERING = {GPU_SAMPLER_FILTERING_MIPMAP};
/**
* Create bokeh texture.
*/
static void dof_bokeh_pass_init(GOOENGINE_Instance *inst,
static void dof_bokeh_pass_init(EEVEE_FramebufferList *fbl,
EEVEE_PassList *psl,
EEVEE_EffectsInfo *fx)
{
if ((fx->dof_bokeh_aniso[0] == 1.0f) && (fx->dof_bokeh_aniso[1] == 1.0f) &&
@@ -353,10 +356,10 @@ static void dof_bokeh_pass_init(GOOENGINE_Instance *inst,
void *owner = (void *)&EEVEE_depth_of_field_init;
const int res[2] = {DOF_BOKEH_LUT_SIZE, DOF_BOKEH_LUT_SIZE};
DRW_PASS_CREATE(inst->dof_bokeh, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->dof_bokeh, DRW_STATE_WRITE_COLOR);
GPUShader *sh = EEVEE_shaders_depth_of_field_bokeh_get();
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->dof_bokeh);
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->dof_bokeh);
DRW_shgroup_uniform_float_copy(grp, "bokehSides", fx->dof_bokeh_blades);
DRW_shgroup_uniform_float_copy(grp, "bokehRotation", fx->dof_bokeh_rotation);
DRW_shgroup_uniform_vec2_copy(grp, "bokehAnisotropyInv", fx->dof_bokeh_aniso_inv);
@@ -370,7 +373,7 @@ static void dof_bokeh_pass_init(GOOENGINE_Instance *inst,
fx->dof_bokeh_resolve_lut_tx = DRW_texture_pool_query_2d_ex(
UNPACK2(res), GPU_R16F, usage, static_cast<DrawEngineType *>(owner));
GPU_framebuffer_ensure_config(&inst->dof_bokeh_fb,
GPU_framebuffer_ensure_config(&fbl->dof_bokeh_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(fx->dof_bokeh_gather_lut_tx),
@@ -382,7 +385,8 @@ static void dof_bokeh_pass_init(GOOENGINE_Instance *inst,
/**
* Outputs halfResColorBuffer and halfResCocBuffer.
*/
static void dof_setup_pass_init(GOOENGINE_Instance *inst,
static void dof_setup_pass_init(EEVEE_FramebufferList *fbl,
EEVEE_PassList *psl,
EEVEE_EffectsInfo *fx)
{
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
@@ -391,10 +395,10 @@ static void dof_setup_pass_init(GOOENGINE_Instance *inst,
const float *fullres = DRW_viewport_size_get();
const int res[2] = {int(divide_ceil_u(fullres[0], 2)), int(divide_ceil_u(fullres[1], 2))};
DRW_PASS_CREATE(inst->dof_setup, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->dof_setup, DRW_STATE_WRITE_COLOR);
GPUShader *sh = EEVEE_shaders_depth_of_field_setup_get();
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->dof_setup);
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->dof_setup);
DRW_shgroup_uniform_texture_ref_ex(grp, "colorBuffer", &fx->source_buffer, NO_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "depthBuffer", &dtxl->depth, NO_FILTERING);
DRW_shgroup_uniform_vec4_copy(grp, "cocParams", fx->dof_coc_params);
@@ -407,7 +411,7 @@ static void dof_setup_pass_init(GOOENGINE_Instance *inst,
fx->dof_half_res_coc_tx = DRW_texture_pool_query_2d_ex(
UNPACK2(res), GPU_RG16F, usage, static_cast<DrawEngineType *>(owner));
GPU_framebuffer_ensure_config(&inst->dof_setup_fb,
GPU_framebuffer_ensure_config(&fbl->dof_setup_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(fx->dof_half_res_color_tx),
@@ -418,7 +422,8 @@ static void dof_setup_pass_init(GOOENGINE_Instance *inst,
/**
* Outputs min & max COC in each 8x8 half res pixel tiles (so 1/16th of full resolution).
*/
static void dof_flatten_tiles_pass_init(GOOENGINE_Instance *inst,
static void dof_flatten_tiles_pass_init(EEVEE_FramebufferList *fbl,
EEVEE_PassList *psl,
EEVEE_EffectsInfo *fx)
{
void *owner = (void *)&EEVEE_depth_of_field_init;
@@ -426,10 +431,10 @@ static void dof_flatten_tiles_pass_init(GOOENGINE_Instance *inst,
const int res[2] = {int(divide_ceil_u(fullres[0], DOF_TILE_DIVISOR)),
int(divide_ceil_u(fullres[1], DOF_TILE_DIVISOR))};
DRW_PASS_CREATE(inst->dof_flatten_tiles, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->dof_flatten_tiles, DRW_STATE_WRITE_COLOR);
GPUShader *sh = EEVEE_shaders_depth_of_field_flatten_tiles_get();
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->dof_flatten_tiles);
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->dof_flatten_tiles);
DRW_shgroup_uniform_texture_ref_ex(
grp, "halfResCocBuffer", &fx->dof_half_res_coc_tx, NO_FILTERING);
DRW_shgroup_call_procedural_triangles(grp, nullptr, 1);
@@ -440,7 +445,7 @@ static void dof_flatten_tiles_pass_init(GOOENGINE_Instance *inst,
fx->dof_coc_tiles_bg_tx = DRW_texture_pool_query_2d_ex(
UNPACK2(res), BG_TILE_FORMAT, usage, static_cast<DrawEngineType *>(owner));
GPU_framebuffer_ensure_config(&inst->dof_flatten_tiles_fb,
GPU_framebuffer_ensure_config(&fbl->dof_flatten_tiles_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(fx->dof_coc_tiles_fg_tx),
@@ -453,7 +458,8 @@ static void dof_flatten_tiles_pass_init(GOOENGINE_Instance *inst,
* Output format/dimensions should be the same as coc_flatten_pass as they are swapped for
* doing multiple dilation passes.
*/
static void dof_dilate_tiles_pass_init(GOOENGINE_Instance *inst,
static void dof_dilate_tiles_pass_init(EEVEE_FramebufferList *fbl,
EEVEE_PassList *psl,
EEVEE_EffectsInfo *fx)
{
void *owner = (void *)&EEVEE_depth_of_field_init;
@@ -461,11 +467,11 @@ static void dof_dilate_tiles_pass_init(GOOENGINE_Instance *inst,
const int res[2] = {int(divide_ceil_u(fullres[0], DOF_TILE_DIVISOR)),
int(divide_ceil_u(fullres[1], DOF_TILE_DIVISOR))};
DRW_PASS_CREATE(inst->dof_dilate_tiles_minmax, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(inst->dof_dilate_tiles_minabs, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->dof_dilate_tiles_minmax, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->dof_dilate_tiles_minabs, DRW_STATE_WRITE_COLOR);
for (int pass = 0; pass < 2; pass++) {
DRWPass *drw_pass = (pass == 0) ? inst->dof_dilate_tiles_minmax : inst->dof_dilate_tiles_minabs;
DRWPass *drw_pass = (pass == 0) ? psl->dof_dilate_tiles_minmax : psl->dof_dilate_tiles_minabs;
GPUShader *sh = EEVEE_shaders_depth_of_field_dilate_tiles_get(pass);
DRWShadingGroup *grp = DRW_shgroup_create(sh, drw_pass);
DRW_shgroup_uniform_texture_ref(grp, "cocTilesFgBuffer", &fx->dof_coc_tiles_fg_tx);
@@ -481,7 +487,7 @@ static void dof_dilate_tiles_pass_init(GOOENGINE_Instance *inst,
fx->dof_coc_dilated_tiles_bg_tx = DRW_texture_pool_query_2d_ex(
UNPACK2(res), BG_TILE_FORMAT, usage, static_cast<DrawEngineType *>(owner));
GPU_framebuffer_ensure_config(&inst->dof_dilate_tiles_fb,
GPU_framebuffer_ensure_config(&fbl->dof_dilate_tiles_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(fx->dof_coc_dilated_tiles_fg_tx),
@@ -489,11 +495,12 @@ static void dof_dilate_tiles_pass_init(GOOENGINE_Instance *inst,
});
}
static void dof_dilate_tiles_pass_draw(GOOENGINE_Instance *inst,
static void dof_dilate_tiles_pass_draw(EEVEE_FramebufferList *fbl,
EEVEE_PassList *psl,
EEVEE_EffectsInfo *fx)
{
for (int pass = 0; pass < 2; pass++) {
DRWPass *drw_pass = (pass == 0) ? inst->dof_dilate_tiles_minmax : inst->dof_dilate_tiles_minabs;
DRWPass *drw_pass = (pass == 0) ? psl->dof_dilate_tiles_minmax : psl->dof_dilate_tiles_minabs;
/* Error introduced by gather center jittering. */
const float error_multiplier = 1.0f + 1.0f / (DOF_GATHER_RING_COUNT + 0.5f);
@@ -517,16 +524,16 @@ static void dof_dilate_tiles_pass_draw(GOOENGINE_Instance *inst,
fx->dof_dilate_ring_count = ring_count;
fx->dof_dilate_ring_width_multiplier = multiplier;
GPU_framebuffer_bind(inst->dof_dilate_tiles_fb);
GPU_framebuffer_bind(fbl->dof_dilate_tiles_fb);
DRW_draw_pass(drw_pass);
std::swap(inst->dof_dilate_tiles_fb, inst->dof_flatten_tiles_fb);
std::swap(fbl->dof_dilate_tiles_fb, fbl->dof_flatten_tiles_fb);
std::swap(fx->dof_coc_dilated_tiles_bg_tx, fx->dof_coc_tiles_bg_tx);
std::swap(fx->dof_coc_dilated_tiles_fg_tx, fx->dof_coc_tiles_fg_tx);
}
}
/* Swap again so that final textures are dof_coc_dilated_tiles_*_tx. */
std::swap(inst->dof_dilate_tiles_fb, inst->dof_flatten_tiles_fb);
std::swap(fbl->dof_dilate_tiles_fb, fbl->dof_flatten_tiles_fb);
std::swap(fx->dof_coc_dilated_tiles_bg_tx, fx->dof_coc_tiles_bg_tx);
std::swap(fx->dof_coc_dilated_tiles_fg_tx, fx->dof_coc_tiles_fg_tx);
}
@@ -534,7 +541,9 @@ static void dof_dilate_tiles_pass_draw(GOOENGINE_Instance *inst,
/**
* Create mipmapped color & COC textures for gather passes.
*/
static void dof_reduce_pass_init(GOOENGINE_Instance *inst,
static void dof_reduce_pass_init(EEVEE_FramebufferList *fbl,
EEVEE_PassList *psl,
EEVEE_TextureList *txl,
EEVEE_EffectsInfo *fx)
{
const float *fullres = DRW_viewport_size_get();
@@ -560,10 +569,10 @@ static void dof_reduce_pass_init(GOOENGINE_Instance *inst,
fx->dof_scatter_coc_threshold = 4.0f;
{
DRW_PASS_CREATE(inst->dof_downsample, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->dof_downsample, DRW_STATE_WRITE_COLOR);
GPUShader *sh = EEVEE_shaders_depth_of_field_downsample_get();
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->dof_downsample);
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->dof_downsample);
DRW_shgroup_uniform_texture_ref_ex(
grp, "colorBuffer", &fx->dof_reduce_input_color_tx, NO_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(
@@ -575,7 +584,7 @@ static void dof_reduce_pass_init(GOOENGINE_Instance *inst,
fx->dof_downsample_tx = DRW_texture_pool_query_2d_ex(
UNPACK2(quater_res), COLOR_FORMAT, usage, static_cast<DrawEngineType *>(owner));
GPU_framebuffer_ensure_config(&inst->dof_downsample_fb,
GPU_framebuffer_ensure_config(&fbl->dof_downsample_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(fx->dof_downsample_tx),
@@ -583,11 +592,11 @@ static void dof_reduce_pass_init(GOOENGINE_Instance *inst,
}
{
DRW_PASS_CREATE(inst->dof_reduce_copy, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->dof_reduce_copy, DRW_STATE_WRITE_COLOR);
const bool is_copy_pass = true;
GPUShader *sh = EEVEE_shaders_depth_of_field_reduce_get(is_copy_pass);
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->dof_reduce_copy);
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->dof_reduce_copy);
DRW_shgroup_uniform_texture_ref_ex(
grp, "colorBuffer", &fx->dof_reduce_input_color_tx, NO_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(
@@ -609,11 +618,11 @@ static void dof_reduce_pass_init(GOOENGINE_Instance *inst,
}
{
DRW_PASS_CREATE(inst->dof_reduce, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->dof_reduce, DRW_STATE_WRITE_COLOR);
const bool is_copy_pass = false;
GPUShader *sh = EEVEE_shaders_depth_of_field_reduce_get(is_copy_pass);
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->dof_reduce);
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->dof_reduce);
DRW_shgroup_uniform_texture_ref_ex(
grp, "colorBuffer", &fx->dof_reduce_input_color_tx, NO_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(
@@ -621,39 +630,39 @@ static void dof_reduce_pass_init(GOOENGINE_Instance *inst,
DRW_shgroup_call_procedural_triangles(grp, nullptr, 1);
}
if (inst->dof_reduced_color) {
if (txl->dof_reduced_color) {
/* TODO(@fclem): In the future, we need to check if mip_count did not change.
* For now it's ok as we always define all mip level. */
if (res[0] != GPU_texture_width(inst->dof_reduced_color) ||
res[1] != GPU_texture_width(inst->dof_reduced_color))
if (res[0] != GPU_texture_width(txl->dof_reduced_color) ||
res[1] != GPU_texture_width(txl->dof_reduced_color))
{
DRW_TEXTURE_FREE_SAFE(inst->dof_reduced_color);
DRW_TEXTURE_FREE_SAFE(inst->dof_reduced_coc);
DRW_TEXTURE_FREE_SAFE(txl->dof_reduced_color);
DRW_TEXTURE_FREE_SAFE(txl->dof_reduced_coc);
}
}
if (inst->dof_reduced_color == nullptr) {
if (txl->dof_reduced_color == nullptr) {
/* Color needs to be signed format here. See note in shader for explanation. */
/* Do not use texture pool because of needs mipmaps. */
eGPUTextureUsage tex_flags = GPU_TEXTURE_USAGE_SHADER_READ | GPU_TEXTURE_USAGE_ATTACHMENT;
inst->dof_reduced_color = GPU_texture_create_2d(
txl->dof_reduced_color = GPU_texture_create_2d(
"dof_reduced_color", UNPACK2(res), mip_count, GPU_RGBA16F, tex_flags, nullptr);
inst->dof_reduced_coc = GPU_texture_create_2d(
txl->dof_reduced_coc = GPU_texture_create_2d(
"dof_reduced_coc", UNPACK2(res), mip_count, GPU_R16F, tex_flags, nullptr);
}
GPU_framebuffer_ensure_config(&inst->dof_reduce_fb,
GPU_framebuffer_ensure_config(&fbl->dof_reduce_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(inst->dof_reduced_color),
GPU_ATTACHMENT_TEXTURE(inst->dof_reduced_coc),
GPU_ATTACHMENT_TEXTURE(txl->dof_reduced_color),
GPU_ATTACHMENT_TEXTURE(txl->dof_reduced_coc),
});
GPU_framebuffer_ensure_config(&inst->dof_reduce_copy_fb,
GPU_framebuffer_ensure_config(&fbl->dof_reduce_copy_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(inst->dof_reduced_color),
GPU_ATTACHMENT_TEXTURE(inst->dof_reduced_coc),
GPU_ATTACHMENT_TEXTURE(txl->dof_reduced_color),
GPU_ATTACHMENT_TEXTURE(txl->dof_reduced_coc),
GPU_ATTACHMENT_TEXTURE(fx->dof_scatter_src_tx),
});
}
@@ -662,28 +671,30 @@ static void dof_reduce_pass_init(GOOENGINE_Instance *inst,
* Do the gather convolution. For each pixels we gather multiple pixels in its neighborhood
* depending on the min & max CoC tiles.
*/
static void dof_gather_pass_init(GOOENGINE_Instance *inst,
static void dof_gather_pass_init(EEVEE_FramebufferList *fbl,
EEVEE_PassList *psl,
EEVEE_TextureList *txl,
EEVEE_EffectsInfo *fx)
{
void *owner = (void *)&EEVEE_depth_of_field_init;
const float *fullres = DRW_viewport_size_get();
const int res[2] = {int(divide_ceil_u(fullres[0], 2)), int(divide_ceil_u(fullres[1], 2))};
int input_size[2];
GPU_texture_get_mipmap_size(inst->dof_reduced_color, 0, input_size);
GPU_texture_get_mipmap_size(txl->dof_reduced_color, 0, input_size);
const float uv_correction_fac[2] = {res[0] / float(input_size[0]),
res[1] / float(input_size[1])};
const float output_texel_size[2] = {1.0f / res[0], 1.0f / res[1]};
const bool use_bokeh_tx = (fx->dof_bokeh_gather_lut_tx != nullptr);
{
DRW_PASS_CREATE(inst->dof_gather_fg_holefill, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->dof_gather_fg_holefill, DRW_STATE_WRITE_COLOR);
GPUShader *sh = EEVEE_shaders_depth_of_field_gather_get(DOF_GATHER_HOLEFILL, false);
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->dof_gather_fg_holefill);
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->dof_gather_fg_holefill);
DRW_shgroup_uniform_texture_ref_ex(
grp, "colorBufferBilinear", &inst->dof_reduced_color, WITH_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "colorBuffer", &inst->dof_reduced_color, NO_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "cocBuffer", &inst->dof_reduced_coc, NO_FILTERING);
grp, "colorBufferBilinear", &txl->dof_reduced_color, WITH_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "colorBuffer", &txl->dof_reduced_color, NO_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "cocBuffer", &txl->dof_reduced_coc, NO_FILTERING);
DRW_shgroup_uniform_texture_ref(grp, "cocTilesFgBuffer", &fx->dof_coc_dilated_tiles_fg_tx);
DRW_shgroup_uniform_texture_ref(grp, "cocTilesBgBuffer", &fx->dof_coc_dilated_tiles_bg_tx);
DRW_shgroup_uniform_texture(grp, "utilTex", EEVEE_materials_get_util_tex());
@@ -699,7 +710,7 @@ static void dof_gather_pass_init(GOOENGINE_Instance *inst,
fx->dof_fg_holefill_weight_tx = DRW_texture_pool_query_2d_ex(
UNPACK2(res), GPU_R16F, usage, static_cast<DrawEngineType *>(owner));
GPU_framebuffer_ensure_config(&inst->dof_gather_fg_holefill_fb,
GPU_framebuffer_ensure_config(&fbl->dof_gather_fg_holefill_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(fx->dof_fg_holefill_color_tx),
@@ -707,14 +718,14 @@ static void dof_gather_pass_init(GOOENGINE_Instance *inst,
});
}
{
DRW_PASS_CREATE(inst->dof_gather_fg, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->dof_gather_fg, DRW_STATE_WRITE_COLOR);
GPUShader *sh = EEVEE_shaders_depth_of_field_gather_get(DOF_GATHER_FOREGROUND, use_bokeh_tx);
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->dof_gather_fg);
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->dof_gather_fg);
DRW_shgroup_uniform_texture_ref_ex(
grp, "colorBufferBilinear", &inst->dof_reduced_color, WITH_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "colorBuffer", &inst->dof_reduced_color, NO_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "cocBuffer", &inst->dof_reduced_coc, NO_FILTERING);
grp, "colorBufferBilinear", &txl->dof_reduced_color, WITH_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "colorBuffer", &txl->dof_reduced_color, NO_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "cocBuffer", &txl->dof_reduced_coc, NO_FILTERING);
DRW_shgroup_uniform_texture_ref(grp, "cocTilesFgBuffer", &fx->dof_coc_dilated_tiles_fg_tx);
DRW_shgroup_uniform_texture_ref(grp, "cocTilesBgBuffer", &fx->dof_coc_dilated_tiles_bg_tx);
DRW_shgroup_uniform_texture(grp, "utilTex", EEVEE_materials_get_util_tex());
@@ -741,7 +752,7 @@ static void dof_gather_pass_init(GOOENGINE_Instance *inst,
/* NOTE: First target is holefill texture so we can use the median filter on it.
* See the filter function. */
GPU_framebuffer_ensure_config(&inst->dof_gather_fg_fb,
GPU_framebuffer_ensure_config(&fbl->dof_gather_fg_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(fx->dof_fg_holefill_color_tx),
@@ -750,14 +761,14 @@ static void dof_gather_pass_init(GOOENGINE_Instance *inst,
});
}
{
DRW_PASS_CREATE(inst->dof_gather_bg, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->dof_gather_bg, DRW_STATE_WRITE_COLOR);
GPUShader *sh = EEVEE_shaders_depth_of_field_gather_get(DOF_GATHER_BACKGROUND, use_bokeh_tx);
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->dof_gather_bg);
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->dof_gather_bg);
DRW_shgroup_uniform_texture_ref_ex(
grp, "colorBufferBilinear", &inst->dof_reduced_color, WITH_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "colorBuffer", &inst->dof_reduced_color, NO_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "cocBuffer", &inst->dof_reduced_coc, NO_FILTERING);
grp, "colorBufferBilinear", &txl->dof_reduced_color, WITH_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "colorBuffer", &txl->dof_reduced_color, NO_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "cocBuffer", &txl->dof_reduced_coc, NO_FILTERING);
DRW_shgroup_uniform_texture_ref(grp, "cocTilesFgBuffer", &fx->dof_coc_dilated_tiles_fg_tx);
DRW_shgroup_uniform_texture_ref(grp, "cocTilesBgBuffer", &fx->dof_coc_dilated_tiles_bg_tx);
DRW_shgroup_uniform_texture(grp, "utilTex", EEVEE_materials_get_util_tex());
@@ -779,7 +790,7 @@ static void dof_gather_pass_init(GOOENGINE_Instance *inst,
/* NOTE: First target is holefill texture so we can use the median filter on it.
* See the filter function. */
GPU_framebuffer_ensure_config(&inst->dof_gather_bg_fb,
GPU_framebuffer_ensure_config(&fbl->dof_gather_bg_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(fx->dof_fg_holefill_color_tx),
@@ -794,27 +805,28 @@ static void dof_gather_pass_init(GOOENGINE_Instance *inst,
* NOTE: We use the holefill texture as our input to reduce memory usage.
* Thus, the holefill pass cannot be filtered.
*/
static void dof_filter_pass_init(GOOENGINE_Instance *inst,
static void dof_filter_pass_init(EEVEE_FramebufferList *fbl,
EEVEE_PassList *psl,
EEVEE_EffectsInfo *fx)
{
DRW_PASS_CREATE(inst->dof_filter, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->dof_filter, DRW_STATE_WRITE_COLOR);
GPUShader *sh = EEVEE_shaders_depth_of_field_filter_get();
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->dof_filter);
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->dof_filter);
DRW_shgroup_uniform_texture_ref_ex(
grp, "colorBuffer", &fx->dof_fg_holefill_color_tx, NO_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(
grp, "weightBuffer", &fx->dof_fg_holefill_weight_tx, NO_FILTERING);
DRW_shgroup_call_procedural_triangles(grp, nullptr, 1);
GPU_framebuffer_ensure_config(&inst->dof_filter_fg_fb,
GPU_framebuffer_ensure_config(&fbl->dof_filter_fg_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(fx->dof_fg_color_tx),
GPU_ATTACHMENT_TEXTURE(fx->dof_fg_weight_tx),
});
GPU_framebuffer_ensure_config(&inst->dof_filter_bg_fb,
GPU_framebuffer_ensure_config(&fbl->dof_filter_bg_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(fx->dof_bg_color_tx),
@@ -826,7 +838,9 @@ static void dof_filter_pass_init(GOOENGINE_Instance *inst,
* Do the Scatter convolution. A sprite is emitted for every 4 pixels but is only expanded if the
* pixels are bright enough to be scattered.
*/
static void dof_scatter_pass_init(GOOENGINE_Instance *inst,
static void dof_scatter_pass_init(EEVEE_FramebufferList *fbl,
EEVEE_PassList *psl,
EEVEE_TextureList *txl,
EEVEE_EffectsInfo *fx)
{
int input_size[2], target_size[2];
@@ -838,13 +852,13 @@ static void dof_scatter_pass_init(GOOENGINE_Instance *inst,
const bool use_bokeh_tx = (fx->dof_bokeh_gather_lut_tx != nullptr);
{
DRW_PASS_CREATE(inst->dof_scatter_fg, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD_FULL);
DRW_PASS_CREATE(psl->dof_scatter_fg, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD_FULL);
const bool is_foreground = true;
GPUShader *sh = EEVEE_shaders_depth_of_field_scatter_get(is_foreground, use_bokeh_tx);
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->dof_scatter_fg);
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->dof_scatter_fg);
DRW_shgroup_uniform_texture_ref_ex(grp, "colorBuffer", &fx->dof_scatter_src_tx, NO_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "cocBuffer", &inst->dof_reduced_coc, NO_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "cocBuffer", &txl->dof_reduced_coc, NO_FILTERING);
DRW_shgroup_uniform_texture_ref(grp, "occlusionBuffer", &fx->dof_fg_occlusion_tx);
DRW_shgroup_uniform_vec2_copy(grp, "targetTexelSize", target_texel_size);
DRW_shgroup_uniform_int_copy(grp, "spritePerRow", input_size[0] / 2);
@@ -859,20 +873,20 @@ static void dof_scatter_pass_init(GOOENGINE_Instance *inst,
}
DRW_shgroup_call_procedural_triangles(grp, nullptr, sprite_count);
GPU_framebuffer_ensure_config(&inst->dof_scatter_fg_fb,
GPU_framebuffer_ensure_config(&fbl->dof_scatter_fg_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(fx->dof_fg_color_tx),
});
}
{
DRW_PASS_CREATE(inst->dof_scatter_bg, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD_FULL);
DRW_PASS_CREATE(psl->dof_scatter_bg, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD_FULL);
const bool is_foreground = false;
GPUShader *sh = EEVEE_shaders_depth_of_field_scatter_get(is_foreground, use_bokeh_tx);
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->dof_scatter_bg);
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->dof_scatter_bg);
DRW_shgroup_uniform_texture_ref_ex(grp, "colorBuffer", &fx->dof_scatter_src_tx, NO_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "cocBuffer", &inst->dof_reduced_coc, NO_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "cocBuffer", &txl->dof_reduced_coc, NO_FILTERING);
DRW_shgroup_uniform_texture_ref(grp, "occlusionBuffer", &fx->dof_bg_occlusion_tx);
DRW_shgroup_uniform_vec2_copy(grp, "targetTexelSize", target_texel_size);
DRW_shgroup_uniform_int_copy(grp, "spritePerRow", input_size[0] / 2);
@@ -883,7 +897,7 @@ static void dof_scatter_pass_init(GOOENGINE_Instance *inst,
}
DRW_shgroup_call_procedural_triangles(grp, nullptr, sprite_count);
GPU_framebuffer_ensure_config(&inst->dof_scatter_bg_fb,
GPU_framebuffer_ensure_config(&fbl->dof_scatter_bg_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(fx->dof_bg_color_tx),
@@ -895,16 +909,17 @@ static void dof_scatter_pass_init(GOOENGINE_Instance *inst,
* Recombine the result of the foreground and background processing. Also perform a slight out of
* focus blur to improve geometric continuity.
*/
static void dof_recombine_pass_init(GOOENGINE_Instance *inst,
static void dof_recombine_pass_init(EEVEE_FramebufferList * /*fbl*/,
EEVEE_PassList *psl,
EEVEE_EffectsInfo *fx)
{
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
const bool use_bokeh_tx = (fx->dof_bokeh_gather_lut_tx != nullptr);
DRW_PASS_CREATE(inst->dof_resolve, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->dof_resolve, DRW_STATE_WRITE_COLOR);
GPUShader *sh = EEVEE_shaders_depth_of_field_resolve_get(use_bokeh_tx, fx->dof_hq_slight_focus);
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->dof_resolve);
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->dof_resolve);
DRW_shgroup_uniform_texture_ref_ex(grp, "fullResColorBuffer", &fx->source_buffer, NO_FILTERING);
DRW_shgroup_uniform_texture_ref_ex(grp, "fullResDepthBuffer", &dtxl->depth, NO_FILTERING);
DRW_shgroup_uniform_texture_ref(grp, "bgColorBuffer", &fx->dof_bg_color_tx);
@@ -927,8 +942,11 @@ static void dof_recombine_pass_init(GOOENGINE_Instance *inst,
void EEVEE_depth_of_field_cache_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *fx = inst->effects;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *fx = stl->effects;
if ((fx->enabled_effects & EFFECT_DOF) != 0) {
/* GPU_RGBA16F is sufficient now that all scattered bokeh are premultiplied.
@@ -936,100 +954,102 @@ void EEVEE_depth_of_field_cache_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Dat
* relatively small benefits. */
fx->dof_color_format = GPU_RGBA16F;
dof_bokeh_pass_init(inst, fx);
dof_setup_pass_init(inst, fx);
dof_flatten_tiles_pass_init(inst, fx);
dof_dilate_tiles_pass_init(inst, fx);
dof_reduce_pass_init(inst, fx);
dof_gather_pass_init(inst, fx);
dof_filter_pass_init(inst, fx);
dof_scatter_pass_init(inst, fx);
dof_recombine_pass_init(inst, fx);
dof_bokeh_pass_init(fbl, psl, fx);
dof_setup_pass_init(fbl, psl, fx);
dof_flatten_tiles_pass_init(fbl, psl, fx);
dof_dilate_tiles_pass_init(fbl, psl, fx);
dof_reduce_pass_init(fbl, psl, txl, fx);
dof_gather_pass_init(fbl, psl, txl, fx);
dof_filter_pass_init(fbl, psl, fx);
dof_scatter_pass_init(fbl, psl, txl, fx);
dof_recombine_pass_init(fbl, psl, fx);
}
}
static void dof_recursive_reduce(void *vedata, int /*level*/)
{
EEVEE_Data *data = static_cast<EEVEE_Data *>(vedata);
GOOENGINE_Instance *inst = data->instance;
EEVEE_EffectsInfo *fx = inst->effects;
EEVEE_PassList *psl = ((EEVEE_Data *)vedata)->psl;
EEVEE_TextureList *txl = ((EEVEE_Data *)vedata)->txl;
EEVEE_EffectsInfo *fx = ((EEVEE_Data *)vedata)->stl->effects;
fx->dof_reduce_input_color_tx = inst->dof_reduced_color;
fx->dof_reduce_input_coc_tx = inst->dof_reduced_coc;
fx->dof_reduce_input_color_tx = txl->dof_reduced_color;
fx->dof_reduce_input_coc_tx = txl->dof_reduced_coc;
DRW_draw_pass(inst->dof_reduce);
DRW_draw_pass(psl->dof_reduce);
}
void EEVEE_depth_of_field_draw(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects; /* TODO(fclem): Because of silly SWAP_BUFFERS. */
EEVEE_PassList *psl = vedata->psl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects; /* TODO(fclem): Because of silly SWAP_BUFFERS. */
EEVEE_EffectsInfo *fx = effects;
/* Depth Of Field */
if ((effects->enabled_effects & EFFECT_DOF) != 0) {
if (fx->dof_bokeh_gather_lut_tx != nullptr) {
GPU_framebuffer_bind(inst->dof_bokeh_fb);
DRW_draw_pass(inst->dof_bokeh);
GPU_framebuffer_bind(fbl->dof_bokeh_fb);
DRW_draw_pass(psl->dof_bokeh);
}
GPU_framebuffer_bind(inst->dof_setup_fb);
DRW_draw_pass(inst->dof_setup);
GPU_framebuffer_bind(fbl->dof_setup_fb);
DRW_draw_pass(psl->dof_setup);
GPU_framebuffer_bind(inst->dof_flatten_tiles_fb);
DRW_draw_pass(inst->dof_flatten_tiles);
GPU_framebuffer_bind(fbl->dof_flatten_tiles_fb);
DRW_draw_pass(psl->dof_flatten_tiles);
dof_dilate_tiles_pass_draw(inst, fx);
dof_dilate_tiles_pass_draw(fbl, psl, fx);
fx->dof_reduce_input_color_tx = fx->dof_half_res_color_tx;
fx->dof_reduce_input_coc_tx = fx->dof_half_res_coc_tx;
/* First step is just a copy. */
GPU_framebuffer_bind(inst->dof_downsample_fb);
DRW_draw_pass(inst->dof_downsample);
GPU_framebuffer_bind(fbl->dof_downsample_fb);
DRW_draw_pass(psl->dof_downsample);
/* First step is just a copy. */
GPU_framebuffer_bind(inst->dof_reduce_copy_fb);
DRW_draw_pass(inst->dof_reduce_copy);
GPU_framebuffer_bind(fbl->dof_reduce_copy_fb);
DRW_draw_pass(psl->dof_reduce_copy);
GPU_framebuffer_recursive_downsample(
inst->dof_reduce_fb, fx->dof_reduce_steps, &dof_recursive_reduce, vedata);
fbl->dof_reduce_fb, fx->dof_reduce_steps, &dof_recursive_reduce, vedata);
{
/* Foreground convolution. */
GPU_framebuffer_bind(inst->dof_gather_fg_fb);
DRW_draw_pass(inst->dof_gather_fg);
GPU_framebuffer_bind(fbl->dof_gather_fg_fb);
DRW_draw_pass(psl->dof_gather_fg);
GPU_framebuffer_bind(inst->dof_filter_fg_fb);
DRW_draw_pass(inst->dof_filter);
GPU_framebuffer_bind(fbl->dof_filter_fg_fb);
DRW_draw_pass(psl->dof_filter);
GPU_framebuffer_bind(inst->dof_scatter_fg_fb);
DRW_draw_pass(inst->dof_scatter_fg);
GPU_framebuffer_bind(fbl->dof_scatter_fg_fb);
DRW_draw_pass(psl->dof_scatter_fg);
}
{
/* Background convolution. */
GPU_framebuffer_bind(inst->dof_gather_bg_fb);
DRW_draw_pass(inst->dof_gather_bg);
GPU_framebuffer_bind(fbl->dof_gather_bg_fb);
DRW_draw_pass(psl->dof_gather_bg);
GPU_framebuffer_bind(inst->dof_filter_bg_fb);
DRW_draw_pass(inst->dof_filter);
GPU_framebuffer_bind(fbl->dof_filter_bg_fb);
DRW_draw_pass(psl->dof_filter);
GPU_framebuffer_bind(inst->dof_scatter_bg_fb);
DRW_draw_pass(inst->dof_scatter_bg);
GPU_framebuffer_bind(fbl->dof_scatter_bg_fb);
DRW_draw_pass(psl->dof_scatter_bg);
}
{
/* Hole-fill convolution. */
GPU_framebuffer_bind(inst->dof_gather_fg_holefill_fb);
DRW_draw_pass(inst->dof_gather_fg_holefill);
GPU_framebuffer_bind(fbl->dof_gather_fg_holefill_fb);
DRW_draw_pass(psl->dof_gather_fg_holefill);
/* NOTE: do not filter the hole-fill pass as we use it as out filter input buffer. */
}
GPU_framebuffer_bind(fx->target_buffer);
DRW_draw_pass(inst->dof_resolve);
DRW_draw_pass(psl->dof_resolve);
SWAP_BUFFERS();
}
source/blender/draw/engines/gooengine/eevee_effects.cc
+118 -105
View File
@@ -59,24 +59,27 @@ void EEVEE_effects_init(EEVEE_ViewLayerData *sldata,
Object *camera,
const bool minimal)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_CommonUniformBuffer *common_data = &sldata->common_data;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_EffectsInfo *effects;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
const float *viewport_size = DRW_viewport_size_get();
const int size_fs[2] = {int(viewport_size[0]), int(viewport_size[1])};
if (!inst->effects) {
inst->effects = static_cast<EEVEE_EffectsInfo *>(
if (!stl->effects) {
stl->effects = static_cast<EEVEE_EffectsInfo *>(
MEM_callocN(sizeof(EEVEE_EffectsInfo), "EEVEE_EffectsInfo"));
inst->effects->taa_render_sample = 1;
stl->effects->taa_render_sample = 1;
}
/* WORKAROUND: EEVEE_lookdev_init can reset TAA and needs a inst->effect.
/* WORKAROUND: EEVEE_lookdev_init can reset TAA and needs a stl->effect.
* So putting this before EEVEE_temporal_sampling_init for now. */
EEVEE_lookdev_init(vedata);
effects = inst->effects;
effects = stl->effects;
int div = 1 << MAX_SCREEN_BUFFERS_LOD_LEVEL;
effects->hiz_size[0] = divide_ceil_u(size_fs[0], div) * div;
@@ -99,7 +102,7 @@ void EEVEE_effects_init(EEVEE_ViewLayerData *sldata,
EEVEE_subsurface_init(sldata, vedata);
/* Force normal buffer creation. */
if (!minimal && (inst->g_data->render_passes & EEVEE_RENDER_PASS_NORMAL) != 0) {
if (!minimal && (stl->g_data->render_passes & EEVEE_RENDER_PASS_NORMAL) != 0) {
effects->enabled_effects |= EFFECT_NORMAL_BUFFER;
}
@@ -109,29 +112,29 @@ void EEVEE_effects_init(EEVEE_ViewLayerData *sldata,
if (GPU_type_matches_ex(GPU_DEVICE_INTEL, GPU_OS_ANY, GPU_DRIVER_ANY, GPU_BACKEND_OPENGL)) {
/* Intel gpu seems to have problem rendering to only depth hiz_format */
DRW_texture_ensure_2d(&inst->maxzbuffer, UNPACK2(effects->hiz_size), GPU_R32F, DRW_TEX_MIPMAP);
GPU_framebuffer_ensure_config(&inst->maxzbuffer_fb,
DRW_texture_ensure_2d(&txl->maxzbuffer, UNPACK2(effects->hiz_size), GPU_R32F, DRW_TEX_MIPMAP);
GPU_framebuffer_ensure_config(&fbl->maxzbuffer_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(inst->maxzbuffer),
GPU_ATTACHMENT_TEXTURE(txl->maxzbuffer),
});
}
else {
eGPUTextureUsage usage = GPU_TEXTURE_USAGE_ATTACHMENT | GPU_TEXTURE_USAGE_SHADER_READ;
DRW_texture_ensure_2d_ex(&inst->maxzbuffer,
DRW_texture_ensure_2d_ex(&txl->maxzbuffer,
UNPACK2(effects->hiz_size),
GPU_DEPTH_COMPONENT24,
usage,
DRW_TEX_MIPMAP);
GPU_framebuffer_ensure_config(&inst->maxzbuffer_fb,
GPU_framebuffer_ensure_config(&fbl->maxzbuffer_fb,
{
GPU_ATTACHMENT_TEXTURE(inst->maxzbuffer),
GPU_ATTACHMENT_TEXTURE(txl->maxzbuffer),
GPU_ATTACHMENT_NONE,
});
}
if (inst->downsample_fb == nullptr) {
inst->downsample_fb = GPU_framebuffer_create("downsample_fb");
if (fbl->downsample_fb == nullptr) {
fbl->downsample_fb = GPU_framebuffer_create("downsample_fb");
}
/**
@@ -150,21 +153,21 @@ void EEVEE_effects_init(EEVEE_ViewLayerData *sldata,
*/
if ((effects->enabled_effects & EFFECT_RADIANCE_BUFFER) != 0) {
eGPUTextureUsage usage = GPU_TEXTURE_USAGE_ATTACHMENT | GPU_TEXTURE_USAGE_SHADER_READ;
DRW_texture_ensure_2d_ex(&inst->filtered_radiance,
DRW_texture_ensure_2d_ex(&txl->filtered_radiance,
UNPACK2(effects->hiz_size),
GPU_R11F_G11F_B10F,
usage,
DRWTextureFlag(DRW_TEX_FILTER | DRW_TEX_MIPMAP));
GPU_framebuffer_ensure_config(&inst->radiance_filtered_fb,
GPU_framebuffer_ensure_config(&fbl->radiance_filtered_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(inst->filtered_radiance),
GPU_ATTACHMENT_TEXTURE(txl->filtered_radiance),
});
}
else {
DRW_TEXTURE_FREE_SAFE(inst->filtered_radiance);
GPU_FRAMEBUFFER_FREE_SAFE(inst->radiance_filtered_fb);
DRW_TEXTURE_FREE_SAFE(txl->filtered_radiance);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->radiance_filtered_fb);
}
/**
@@ -175,7 +178,7 @@ void EEVEE_effects_init(EEVEE_ViewLayerData *sldata,
effects->ssr_normal_input = DRW_texture_pool_query_2d_ex(
size_fs[0], size_fs[1], GPU_RG16, usage, &draw_engine_eevee_type);
GPU_framebuffer_texture_attach(inst->main_fb, effects->ssr_normal_input, 1, 0);
GPU_framebuffer_texture_attach(fbl->main_fb, effects->ssr_normal_input, 1, 0);
}
else {
effects->ssr_normal_input = nullptr;
@@ -189,14 +192,14 @@ void EEVEE_effects_init(EEVEE_ViewLayerData *sldata,
effects->velocity_tx = DRW_texture_pool_query_2d_ex(
size_fs[0], size_fs[1], GPU_RGBA16, usage, &draw_engine_eevee_type);
GPU_framebuffer_ensure_config(&inst->velocity_fb,
GPU_framebuffer_ensure_config(&fbl->velocity_fb,
{
GPU_ATTACHMENT_TEXTURE(dtxl->depth),
GPU_ATTACHMENT_TEXTURE(effects->velocity_tx),
});
GPU_framebuffer_ensure_config(
&inst->velocity_resolve_fb,
&fbl->velocity_resolve_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(effects->velocity_tx)});
}
else {
@@ -208,29 +211,31 @@ void EEVEE_effects_init(EEVEE_ViewLayerData *sldata,
*/
if ((effects->enabled_effects & EFFECT_DEPTH_DOUBLE_BUFFER) != 0) {
DRW_texture_ensure_fullscreen_2d(
&inst->depth_double_buffer, GPU_DEPTH24_STENCIL8, DRWTextureFlag(0));
&txl->depth_double_buffer, GPU_DEPTH24_STENCIL8, DRWTextureFlag(0));
GPU_framebuffer_ensure_config(&inst->double_buffer_depth_fb,
{GPU_ATTACHMENT_TEXTURE(inst->depth_double_buffer)});
GPU_framebuffer_ensure_config(&fbl->double_buffer_depth_fb,
{GPU_ATTACHMENT_TEXTURE(txl->depth_double_buffer)});
}
else {
/* Cleanup to release memory */
DRW_TEXTURE_FREE_SAFE(inst->depth_double_buffer);
GPU_FRAMEBUFFER_FREE_SAFE(inst->double_buffer_depth_fb);
DRW_TEXTURE_FREE_SAFE(txl->depth_double_buffer);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->double_buffer_depth_fb);
}
if ((effects->enabled_effects & (EFFECT_TAA | EFFECT_TAA_REPROJECT)) != 0) {
SETUP_BUFFER(inst->taa_history, inst->taa_history_fb, inst->taa_history_color_fb);
SETUP_BUFFER(txl->taa_history, fbl->taa_history_fb, fbl->taa_history_color_fb);
}
else {
CLEANUP_BUFFER(inst->taa_history, inst->taa_history_fb, inst->taa_history_color_fb);
CLEANUP_BUFFER(txl->taa_history, fbl->taa_history_fb, fbl->taa_history_color_fb);
}
}
void EEVEE_effects_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
DRWState downsample_write = DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_ALWAYS;
DRWShadingGroup *grp;
@@ -243,25 +248,25 @@ void EEVEE_effects_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
blender::gpu::Batch *quad = DRW_cache_fullscreen_quad_get();
if (effects->enabled_effects & EFFECT_RADIANCE_BUFFER) {
DRW_PASS_CREATE(inst->color_copy_ps, DRW_STATE_WRITE_COLOR);
grp = DRW_shgroup_create(EEVEE_shaders_effect_color_copy_sh_get(), inst->color_copy_ps);
DRW_PASS_CREATE(psl->color_copy_ps, DRW_STATE_WRITE_COLOR);
grp = DRW_shgroup_create(EEVEE_shaders_effect_color_copy_sh_get(), psl->color_copy_ps);
DRW_shgroup_uniform_texture_ref_ex(
grp, "source", &e_data.color_src, GPUSamplerState::default_sampler());
DRW_shgroup_uniform_float(grp, "fireflyFactor", &sldata->common_data.ssr_firefly_fac, 1);
DRW_shgroup_call_procedural_triangles(grp, nullptr, 1);
DRW_PASS_CREATE(inst->color_downsample_ps, DRW_STATE_WRITE_COLOR);
grp = DRW_shgroup_create(EEVEE_shaders_effect_downsample_sh_get(), inst->color_downsample_ps);
DRW_PASS_CREATE(psl->color_downsample_ps, DRW_STATE_WRITE_COLOR);
grp = DRW_shgroup_create(EEVEE_shaders_effect_downsample_sh_get(), psl->color_downsample_ps);
const GPUSamplerState sampler_state = {GPU_SAMPLER_FILTERING_LINEAR};
DRW_shgroup_uniform_texture_ex(grp, "source", inst->filtered_radiance, sampler_state);
DRW_shgroup_uniform_texture_ex(grp, "source", txl->filtered_radiance, sampler_state);
DRW_shgroup_uniform_vec2(grp, "texelSize", e_data.texel_size, 1);
DRW_shgroup_call_procedural_triangles(grp, nullptr, 1);
}
{
DRW_PASS_CREATE(inst->color_downsample_cube_ps, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->color_downsample_cube_ps, DRW_STATE_WRITE_COLOR);
grp = DRW_shgroup_create(EEVEE_shaders_effect_downsample_cube_sh_get(),
inst->color_downsample_cube_ps);
psl->color_downsample_cube_ps);
DRW_shgroup_uniform_texture_ref(grp, "source", &e_data.color_src);
DRW_shgroup_uniform_float(grp, "texelSize", e_data.texel_size, 1);
DRW_shgroup_uniform_int_copy(grp, "Layer", 0);
@@ -270,23 +275,23 @@ void EEVEE_effects_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
/* Perform min/max down-sample. */
DRW_PASS_CREATE(inst->maxz_downlevel_ps, downsample_write);
grp = DRW_shgroup_create(EEVEE_shaders_effect_maxz_downlevel_sh_get(), inst->maxz_downlevel_ps);
DRW_PASS_CREATE(psl->maxz_downlevel_ps, downsample_write);
grp = DRW_shgroup_create(EEVEE_shaders_effect_maxz_downlevel_sh_get(), psl->maxz_downlevel_ps);
DRW_shgroup_uniform_texture_ref_ex(
grp, "depthBuffer", &inst->maxzbuffer, GPUSamplerState::default_sampler());
grp, "depthBuffer", &txl->maxzbuffer, GPUSamplerState::default_sampler());
DRW_shgroup_uniform_vec2(grp, "texelSize", e_data.texel_size, 1);
DRW_shgroup_call(grp, quad, nullptr);
/* Copy depth buffer to top level of HiZ */
DRW_PASS_CREATE(inst->maxz_copydepth_ps, downsample_write);
grp = DRW_shgroup_create(EEVEE_shaders_effect_maxz_copydepth_sh_get(), inst->maxz_copydepth_ps);
DRW_PASS_CREATE(psl->maxz_copydepth_ps, downsample_write);
grp = DRW_shgroup_create(EEVEE_shaders_effect_maxz_copydepth_sh_get(), psl->maxz_copydepth_ps);
DRW_shgroup_uniform_texture_ref_ex(
grp, "depthBuffer", &e_data.depth_src, GPUSamplerState::default_sampler());
DRW_shgroup_call(grp, quad, nullptr);
DRW_PASS_CREATE(inst->maxz_copydepth_layer_ps, downsample_write);
DRW_PASS_CREATE(psl->maxz_copydepth_layer_ps, downsample_write);
grp = DRW_shgroup_create(EEVEE_shaders_effect_maxz_copydepth_layer_sh_get(),
inst->maxz_copydepth_layer_ps);
psl->maxz_copydepth_layer_ps);
DRW_shgroup_uniform_texture_ref_ex(
grp, "depthBuffer", &e_data.depth_src, GPUSamplerState::default_sampler());
DRW_shgroup_uniform_int(grp, "depthLayer", &e_data.depth_src_layer, 1);
@@ -297,8 +302,8 @@ void EEVEE_effects_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
EEVEE_MotionBlurData *mb_data = &effects->motion_blur;
/* This pass compute camera motions to the non moving objects. */
DRW_PASS_CREATE(inst->velocity_resolve, DRW_STATE_WRITE_COLOR);
grp = DRW_shgroup_create(EEVEE_shaders_velocity_resolve_sh_get(), inst->velocity_resolve);
DRW_PASS_CREATE(psl->velocity_resolve, DRW_STATE_WRITE_COLOR);
grp = DRW_shgroup_create(EEVEE_shaders_velocity_resolve_sh_get(), psl->velocity_resolve);
DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &e_data.depth_src);
DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
DRW_shgroup_uniform_block(grp, "renderpass_block", sldata->renderpass_ubo.combined);
@@ -312,79 +317,80 @@ void EEVEE_effects_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
void EEVEE_effects_draw_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
/**
* Setup double buffer so we can access last frame as it was before post processes.
*/
if ((effects->enabled_effects & EFFECT_DOUBLE_BUFFER) != 0) {
SETUP_BUFFER(inst->color_double_buffer, inst->double_buffer_fb, inst->double_buffer_color_fb);
SETUP_BUFFER(txl->color_double_buffer, fbl->double_buffer_fb, fbl->double_buffer_color_fb);
}
else {
CLEANUP_BUFFER(inst->color_double_buffer, inst->double_buffer_fb, inst->double_buffer_color_fb);
CLEANUP_BUFFER(txl->color_double_buffer, fbl->double_buffer_fb, fbl->double_buffer_color_fb);
}
/**
* Ping Pong buffer
*/
if ((effects->enabled_effects & EFFECT_POST_BUFFER) != 0) {
SETUP_BUFFER(inst->color_post, inst->effect_fb, inst->effect_color_fb);
SETUP_BUFFER(txl->color_post, fbl->effect_fb, fbl->effect_color_fb);
}
else {
CLEANUP_BUFFER(inst->color_post, inst->effect_fb, inst->effect_color_fb);
CLEANUP_BUFFER(txl->color_post, fbl->effect_fb, fbl->effect_color_fb);
}
}
#if 0 /* Not required for now */
static void min_downsample_cb(void *vedata, int /*level*/)
{
EEVEE_Data *ved = (EEVEE_Data *)vedata;
GOOENGINE_Instance *inst = ved->instance;
DRW_draw_pass(inst->minz_downlevel_ps);
EEVEE_PassList *psl = ((EEVEE_Data *)vedata)->psl;
DRW_draw_pass(psl->minz_downlevel_ps);
}
#endif
static void max_downsample_cb(void *vedata, int level)
{
EEVEE_Data *ved = (EEVEE_Data *)vedata;
GOOENGINE_Instance *inst = ved->instance;
EEVEE_PassList *psl = ((EEVEE_Data *)vedata)->psl;
EEVEE_TextureList *txl = ((EEVEE_Data *)vedata)->txl;
int texture_size[3];
GPU_texture_get_mipmap_size(inst->maxzbuffer, level - 1, texture_size);
GPU_texture_get_mipmap_size(txl->maxzbuffer, level - 1, texture_size);
e_data.texel_size[0] = 1.0f / texture_size[0];
e_data.texel_size[1] = 1.0f / texture_size[1];
DRW_draw_pass(inst->maxz_downlevel_ps);
DRW_draw_pass(psl->maxz_downlevel_ps);
}
static void simple_downsample_cube_cb(void *vedata, int level)
{
EEVEE_Data *ved = (EEVEE_Data *)vedata;
GOOENGINE_Instance *inst = ved->instance;
EEVEE_PassList *psl = ((EEVEE_Data *)vedata)->psl;
e_data.texel_size[0] = float(1 << level) / float(GPU_texture_width(e_data.color_src));
e_data.texel_size[1] = e_data.texel_size[0];
DRW_draw_pass(inst->color_downsample_cube_ps);
DRW_draw_pass(psl->color_downsample_cube_ps);
}
void EEVEE_create_minmax_buffer(EEVEE_Data *vedata, GPUTexture *depth_src, int layer)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PassList *psl = vedata->psl;
EEVEE_FramebufferList *fbl = vedata->fbl;
e_data.depth_src = depth_src;
e_data.depth_src_layer = layer;
/* Copy depth buffer to max texture top level */
GPU_framebuffer_bind(inst->maxzbuffer_fb);
GPU_framebuffer_bind(fbl->maxzbuffer_fb);
if (layer >= 0) {
DRW_draw_pass(inst->maxz_copydepth_layer_ps);
DRW_draw_pass(psl->maxz_copydepth_layer_ps);
}
else {
DRW_draw_pass(inst->maxz_copydepth_ps);
DRW_draw_pass(psl->maxz_copydepth_ps);
}
/* Create lower levels */
GPU_framebuffer_recursive_downsample(
inst->maxzbuffer_fb, MAX_SCREEN_BUFFERS_LOD_LEVEL, &max_downsample_cb, vedata);
fbl->maxzbuffer_fb, MAX_SCREEN_BUFFERS_LOD_LEVEL, &max_downsample_cb, vedata);
/* Restore */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
if (GPU_mip_render_workaround() ||
GPU_type_matches(GPU_DEVICE_INTEL_UHD, GPU_OS_WIN, GPU_DRIVER_ANY))
@@ -396,85 +402,92 @@ void EEVEE_create_minmax_buffer(EEVEE_Data *vedata, GPUTexture *depth_src, int l
static void downsample_radiance_cb(void *vedata, int level)
{
EEVEE_Data *ved = (EEVEE_Data *)vedata;
GOOENGINE_Instance *inst = ved->instance;
EEVEE_PassList *psl = ((EEVEE_Data *)vedata)->psl;
EEVEE_TextureList *txl = ((EEVEE_Data *)vedata)->txl;
int texture_size[3];
GPU_texture_get_mipmap_size(inst->filtered_radiance, level - 1, texture_size);
GPU_texture_get_mipmap_size(txl->filtered_radiance, level - 1, texture_size);
e_data.texel_size[0] = 1.0f / texture_size[0];
e_data.texel_size[1] = 1.0f / texture_size[1];
DRW_draw_pass(inst->color_downsample_ps);
DRW_draw_pass(psl->color_downsample_ps);
}
void EEVEE_effects_downsample_radiance_buffer(EEVEE_Data *vedata, GPUTexture *texture_src)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PassList *psl = vedata->psl;
EEVEE_FramebufferList *fbl = vedata->fbl;
e_data.color_src = texture_src;
GPU_framebuffer_bind(inst->radiance_filtered_fb);
DRW_draw_pass(inst->color_copy_ps);
GPU_framebuffer_bind(fbl->radiance_filtered_fb);
DRW_draw_pass(psl->color_copy_ps);
GPU_framebuffer_recursive_downsample(
inst->radiance_filtered_fb, MAX_SCREEN_BUFFERS_LOD_LEVEL, &downsample_radiance_cb, vedata);
fbl->radiance_filtered_fb, MAX_SCREEN_BUFFERS_LOD_LEVEL, &downsample_radiance_cb, vedata);
}
void EEVEE_effects_radiance_copy(EEVEE_ViewLayerData */*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
/* Copy color buffer to texture */
if ((effects->enabled_effects & EFFECT_REFRACT) != 0) {
GPU_framebuffer_bind(inst->radiance_filtered_fb);
DRW_draw_pass(inst->color_copy_ps);
GPU_framebuffer_bind(fbl->radiance_filtered_fb);
DRW_draw_pass(psl->color_copy_ps);
/* Restore */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}
void EEVEE_downsample_cube_buffer(EEVEE_Data *vedata, GPUTexture *texture_src, int level)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_FramebufferList *fbl = vedata->fbl;
e_data.color_src = texture_src;
/* Create lower levels */
GPU_framebuffer_texture_attach(inst->downsample_fb, texture_src, 0, 0);
GPU_framebuffer_texture_attach(fbl->downsample_fb, texture_src, 0, 0);
GPU_framebuffer_recursive_downsample(
inst->downsample_fb, level, &simple_downsample_cube_cb, vedata);
GPU_framebuffer_texture_detach(inst->downsample_fb, texture_src);
fbl->downsample_fb, level, &simple_downsample_cube_cb, vedata);
GPU_framebuffer_texture_detach(fbl->downsample_fb, texture_src);
}
static void EEVEE_velocity_resolve(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
if ((effects->enabled_effects & EFFECT_VELOCITY_BUFFER) != 0) {
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
e_data.depth_src = dtxl->depth;
GPU_framebuffer_bind(inst->velocity_resolve_fb);
DRW_draw_pass(inst->velocity_resolve);
GPU_framebuffer_bind(fbl->velocity_resolve_fb);
DRW_draw_pass(psl->velocity_resolve);
if (inst->velocity_object) {
GPU_framebuffer_bind(inst->velocity_fb);
DRW_draw_pass(inst->velocity_object);
if (psl->velocity_object) {
GPU_framebuffer_bind(fbl->velocity_fb);
DRW_draw_pass(psl->velocity_object);
}
}
}
void EEVEE_draw_effects(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
/* only once per frame after the first post process */
effects->swap_double_buffer = ((effects->enabled_effects & EFFECT_DOUBLE_BUFFER) != 0);
/* Init pointers */
effects->source_buffer = inst->color; /* latest updated texture */
effects->target_buffer = inst->effect_color_fb; /* next target to render to */
effects->source_buffer = txl->color; /* latest updated texture */
effects->target_buffer = fbl->effect_color_fb; /* next target to render to */
/* Post process stack (order matters) */
EEVEE_velocity_resolve(vedata);
@@ -496,16 +509,16 @@ void EEVEE_draw_effects(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
/* Save the final texture and frame-buffer for final transformation or read. */
effects->final_tx = effects->source_buffer;
effects->final_fb = (effects->target_buffer != inst->main_color_fb) ? inst->main_fb :
inst->effect_fb;
if ((effects->enabled_effects & EFFECT_TAA) && (effects->source_buffer == inst->taa_history)) {
effects->final_fb = inst->taa_history_fb;
effects->final_fb = (effects->target_buffer != fbl->main_color_fb) ? fbl->main_fb :
fbl->effect_fb;
if ((effects->enabled_effects & EFFECT_TAA) && (effects->source_buffer == txl->taa_history)) {
effects->final_fb = fbl->taa_history_fb;
}
/* If no post processes is enabled, buffers are still not swapped, do it now. */
SWAP_DOUBLE_BUFFERS();
if (!inst->g_data->valid_double_buffer &&
if (!stl->g_data->valid_double_buffer &&
((effects->enabled_effects & EFFECT_DOUBLE_BUFFER) != 0) &&
(DRW_state_is_image_render() == false))
{
@@ -519,7 +532,7 @@ void EEVEE_draw_effects(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
/* Update double buffer status if render mode. */
if (DRW_state_is_image_render()) {
inst->g_data->valid_double_buffer = (inst->color_double_buffer != nullptr);
inst->g_data->valid_taa_history = (inst->taa_history != nullptr);
stl->g_data->valid_double_buffer = (txl->color_double_buffer != nullptr);
stl->g_data->valid_taa_history = (txl->taa_history != nullptr);
}
}
source/blender/draw/engines/gooengine/eevee_engine.cc
+77 -308
View File
@@ -35,130 +35,9 @@
static void eevee_engine_init(void *ved)
{
EEVEE_Data *vedata = (EEVEE_Data *)ved;
if (vedata->instance == nullptr) {
vedata->instance = new GOOENGINE_Instance();
}
else {
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->gtao_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->gtao_debug_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->downsample_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->maxzbuffer_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->bloom_blit_fb);
GPU_FRAMEBUFFER_FREE_SAFE(*vedata->instance->bloom_down_fb);
GPU_FRAMEBUFFER_FREE_SAFE(*vedata->instance->bloom_accum_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->bloom_pass_accum_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->cryptomatte_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->shadow_accum_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->ssr_accum_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->sss_blur_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->sss_blit_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->sss_resolve_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->sss_clear_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->sss_translucency_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->sss_accum_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->dof_setup_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->dof_flatten_tiles_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->dof_dilate_tiles_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->dof_downsample_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->dof_reduce_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->dof_reduce_copy_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->dof_bokeh_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->dof_gather_fg_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->dof_filter_fg_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->dof_gather_fg_holefill_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->dof_gather_bg_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->dof_filter_bg_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->dof_scatter_fg_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->dof_scatter_bg_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->volumetric_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->volumetric_scat_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->volumetric_integ_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->volumetric_accum_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->screen_tracing_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->mist_accum_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->material_accum_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->renderpass_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->ao_accum_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->velocity_resolve_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->velocity_fb);
GPU_FRAMEBUFFER_FREE_SAFE(*vedata->instance->velocity_tiles_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->update_noise_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->planarref_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->planar_downsample_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->main_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->main_color_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->effect_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->effect_color_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->radiance_filtered_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->double_buffer_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->double_buffer_color_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->double_buffer_depth_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->transparent_rpass_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->transparent_rpass_accum_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->taa_history_fb);
GPU_FRAMEBUFFER_FREE_SAFE(vedata->instance->taa_history_color_fb);
GPU_TEXTURE_FREE_SAFE(vedata->instance->color_post);
GPU_TEXTURE_FREE_SAFE(vedata->instance->mist_accum);
GPU_TEXTURE_FREE_SAFE(vedata->instance->ao_accum);
GPU_TEXTURE_FREE_SAFE(vedata->instance->sss_accum);
GPU_TEXTURE_FREE_SAFE(vedata->instance->env_accum);
GPU_TEXTURE_FREE_SAFE(vedata->instance->diff_color_accum);
GPU_TEXTURE_FREE_SAFE(vedata->instance->diff_light_accum);
GPU_TEXTURE_FREE_SAFE(vedata->instance->spec_color_accum);
GPU_TEXTURE_FREE_SAFE(vedata->instance->spec_light_accum);
GPU_TEXTURE_FREE_SAFE(*vedata->instance->aov_surface_accum);
GPU_TEXTURE_FREE_SAFE(vedata->instance->emit_accum);
GPU_TEXTURE_FREE_SAFE(vedata->instance->bloom_accum);
GPU_TEXTURE_FREE_SAFE(vedata->instance->ssr_accum);
GPU_TEXTURE_FREE_SAFE(vedata->instance->shadow_accum);
GPU_TEXTURE_FREE_SAFE(vedata->instance->transparent_accum);
GPU_TEXTURE_FREE_SAFE(vedata->instance->transparent_depth_tmp);
GPU_TEXTURE_FREE_SAFE(vedata->instance->transparent_color_tmp);
GPU_TEXTURE_FREE_SAFE(vedata->instance->cryptomatte);
GPU_TEXTURE_FREE_SAFE(vedata->instance->taa_history);
GPU_TEXTURE_FREE_SAFE(vedata->instance->dof_reduced_color);
GPU_TEXTURE_FREE_SAFE(vedata->instance->dof_reduced_coc);
GPU_TEXTURE_FREE_SAFE(vedata->instance->volume_prop_scattering);
GPU_TEXTURE_FREE_SAFE(vedata->instance->volume_prop_extinction);
GPU_TEXTURE_FREE_SAFE(vedata->instance->volume_prop_emission);
GPU_TEXTURE_FREE_SAFE(vedata->instance->volume_prop_phase);
GPU_TEXTURE_FREE_SAFE(vedata->instance->volume_scatter);
GPU_TEXTURE_FREE_SAFE(vedata->instance->volume_transmit);
GPU_TEXTURE_FREE_SAFE(vedata->instance->volume_scatter_history);
GPU_TEXTURE_FREE_SAFE(vedata->instance->volume_transmit_history);
GPU_TEXTURE_FREE_SAFE(vedata->instance->volume_scatter_accum);
GPU_TEXTURE_FREE_SAFE(vedata->instance->volume_transmittance_accum);
GPU_TEXTURE_FREE_SAFE(vedata->instance->lookdev_grid_tx);
GPU_TEXTURE_FREE_SAFE(vedata->instance->lookdev_cube_tx);
GPU_TEXTURE_FREE_SAFE(vedata->instance->planar_pool);
GPU_TEXTURE_FREE_SAFE(vedata->instance->planar_depth);
GPU_TEXTURE_FREE_SAFE(vedata->instance->maxzbuffer);
GPU_TEXTURE_FREE_SAFE(vedata->instance->filtered_radiance);
GPU_TEXTURE_FREE_SAFE(vedata->instance->renderpass);
GPU_TEXTURE_FREE_SAFE(vedata->instance->color);
GPU_TEXTURE_FREE_SAFE(vedata->instance->color_double_buffer);
GPU_TEXTURE_FREE_SAFE(vedata->instance->depth_double_buffer);
MEM_SAFE_FREE(vedata->instance->effects);
MEM_SAFE_FREE(vedata->instance->g_data);
MEM_SAFE_FREE(vedata->instance->lookdev_lightcache);
MEM_SAFE_FREE(vedata->instance->lookdev_cube_data);
MEM_SAFE_FREE(vedata->instance->lookdev_grid_data);
MEM_SAFE_FREE(vedata->instance->lookdev_cube_mips);
}
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = ((EEVEE_Data *)vedata)->stl;
EEVEE_ViewLayerData *sldata = EEVEE_view_layer_data_ensure();
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
@@ -167,40 +46,40 @@ static void eevee_engine_init(void *ved)
RegionView3D *rv3d = draw_ctx->rv3d;
Object *camera = (rv3d->persp == RV3D_CAMOB) ? v3d->camera : nullptr;
if (!inst->g_data) {
if (!stl->g_data) {
/* Alloc transient pointers */
inst->g_data = static_cast<EEVEE_PrivateData *>(MEM_callocN(sizeof(*inst->g_data), __func__));
stl->g_data = static_cast<EEVEE_PrivateData *>(MEM_callocN(sizeof(*stl->g_data), __func__));
}
inst->g_data->use_color_render_settings = USE_SCENE_LIGHT(v3d) ||
stl->g_data->use_color_render_settings = USE_SCENE_LIGHT(v3d) ||
!LOOK_DEV_STUDIO_LIGHT_ENABLED(v3d);
inst->g_data->background_alpha = DRW_state_draw_background() ? 1.0f : 0.0f;
inst->g_data->valid_double_buffer = (inst->color_double_buffer != nullptr);
inst->g_data->valid_taa_history = (inst->taa_history != nullptr);
inst->g_data->queued_shaders_count = 0;
inst->g_data->queued_optimise_shaders_count = 0;
inst->g_data->render_timesteps = 1;
inst->g_data->disable_ligthprobes = v3d &&
stl->g_data->background_alpha = DRW_state_draw_background() ? 1.0f : 0.0f;
stl->g_data->valid_double_buffer = (txl->color_double_buffer != nullptr);
stl->g_data->valid_taa_history = (txl->taa_history != nullptr);
stl->g_data->queued_shaders_count = 0;
stl->g_data->queued_optimise_shaders_count = 0;
stl->g_data->render_timesteps = 1;
stl->g_data->disable_ligthprobes = v3d &&
(v3d->object_type_exclude_viewport & (1 << OB_LIGHTPROBE));
/* Main Buffer */
DRW_texture_ensure_fullscreen_2d(&inst->color, GPU_RGBA16F, DRW_TEX_FILTER);
DRW_texture_ensure_fullscreen_2d(&txl->color, GPU_RGBA16F, DRW_TEX_FILTER);
GPU_framebuffer_ensure_config(&inst->main_fb,
GPU_framebuffer_ensure_config(&fbl->main_fb,
{GPU_ATTACHMENT_TEXTURE(dtxl->depth),
GPU_ATTACHMENT_TEXTURE(inst->color),
GPU_ATTACHMENT_TEXTURE(txl->color),
GPU_ATTACHMENT_LEAVE,
GPU_ATTACHMENT_LEAVE,
GPU_ATTACHMENT_LEAVE,
GPU_ATTACHMENT_LEAVE});
GPU_framebuffer_ensure_config(&inst->main_color_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(inst->color)});
GPU_framebuffer_ensure_config(&fbl->main_color_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(txl->color)});
/* `EEVEE_renderpasses_init` will set the active render passes used by `EEVEE_effects_init`.
* `EEVEE_effects_init` needs to go second for TAA. */
* `EEVEE_effects_init` needs to go second for TAA. */
EEVEE_renderpasses_init(vedata);
EEVEE_effects_init(sldata, vedata, camera, false);
EEVEE_materials_init(sldata, vedata);
EEVEE_materials_init(sldata, vedata, stl, fbl);
EEVEE_shadows_init(sldata);
EEVEE_lightprobes_init(sldata, vedata);
}
@@ -272,9 +151,9 @@ void EEVEE_cache_populate(void *vedata, Object *ob)
static void eevee_cache_finish(void *vedata)
{
EEVEE_Data *ved = (EEVEE_Data *)vedata;
GOOENGINE_Instance *inst = ved->instance;
EEVEE_ViewLayerData *sldata = EEVEE_view_layer_data_ensure();
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_StorageList *stl = ved->stl;
EEVEE_PrivateData *g_data = stl->g_data;
const DRWContextState *draw_ctx = DRW_context_state_get();
const Scene *scene_eval = DEG_get_evaluated_scene(draw_ctx->depsgraph);
@@ -327,8 +206,9 @@ static void eevee_cache_finish(void *vedata)
* to reduce the fill-rate. */
static void eevee_draw_scene(void *vedata)
{
EEVEE_Data *ved = (EEVEE_Data *)vedata;
GOOENGINE_Instance *inst = ved->instance;
EEVEE_PassList *psl = ((EEVEE_Data *)vedata)->psl;
EEVEE_StorageList *stl = ((EEVEE_Data *)vedata)->stl;
EEVEE_FramebufferList *fbl = ((EEVEE_Data *)vedata)->fbl;
EEVEE_ViewLayerData *sldata = EEVEE_view_layer_data_ensure();
/* Default framebuffer and texture */
@@ -336,7 +216,7 @@ static void eevee_draw_scene(void *vedata)
DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get();
/* Sort transparents before the loop. */
DRW_pass_sort_shgroup_z(inst->transparent_pass);
DRW_pass_sort_shgroup_z(psl->transparent_pass);
/* Number of iteration: Use viewport taa_samples when using viewport rendering */
int loop_len = 1;
@@ -346,7 +226,7 @@ static void eevee_draw_scene(void *vedata)
loop_len = std::max(1, scene->eevee.taa_samples);
}
if (inst->effects->bypass_drawing) {
if (stl->effects->bypass_drawing) {
loop_len = 0;
}
@@ -358,41 +238,41 @@ static void eevee_draw_scene(void *vedata)
double offset[3] = {0.0, 0.0, 0.0};
double r[3];
bool taa_use_reprojection = (inst->effects->enabled_effects & EFFECT_TAA_REPROJECT) != 0;
bool taa_use_reprojection = (stl->effects->enabled_effects & EFFECT_TAA_REPROJECT) != 0;
if (DRW_state_is_image_render() || taa_use_reprojection ||
((inst->effects->enabled_effects & EFFECT_TAA) != 0))
((stl->effects->enabled_effects & EFFECT_TAA) != 0))
{
int samp = taa_use_reprojection ? inst->effects->taa_reproject_sample + 1 :
inst->effects->taa_current_sample;
int samp = taa_use_reprojection ? stl->effects->taa_reproject_sample + 1 :
stl->effects->taa_current_sample;
BLI_halton_3d(primes, offset, samp, r);
EEVEE_update_noise(ved, r);
EEVEE_update_noise(psl, fbl, r);
EEVEE_volumes_set_jitter(sldata, samp - 1);
EEVEE_materials_init(sldata, static_cast<EEVEE_Data *>(vedata));
EEVEE_materials_init(sldata, static_cast<EEVEE_Data *>(vedata), stl, fbl);
}
/* Copy previous persmat to UBO data */
copy_m4_m4(sldata->common_data.prev_persmat, inst->effects->prev_persmat);
copy_m4_m4(sldata->common_data.prev_persmat, stl->effects->prev_persmat);
/* Refresh Probes
* Shadows needs to be updated for correct probes */
EEVEE_shadows_update(sldata, static_cast<EEVEE_Data *>(vedata));
EEVEE_lightprobes_refresh(sldata, static_cast<EEVEE_Data *>(vedata));
EEVEE_lightprobes_refresh_planar(sldata, static_cast<EEVEE_Data *>(vedata));
/* Refresh shadows */
EEVEE_shadows_draw(sldata, static_cast<EEVEE_Data *>(vedata), inst->effects->taa_view);
EEVEE_shadows_draw(sldata, static_cast<EEVEE_Data *>(vedata), stl->effects->taa_view);
if (((inst->effects->enabled_effects & EFFECT_TAA) != 0) &&
(inst->effects->taa_current_sample > 1) && !DRW_state_is_image_render() &&
if (((stl->effects->enabled_effects & EFFECT_TAA) != 0) &&
(stl->effects->taa_current_sample > 1) && !DRW_state_is_image_render() &&
!taa_use_reprojection)
{
DRW_view_set_active(inst->effects->taa_view);
DRW_view_set_active(stl->effects->taa_view);
}
/* when doing viewport rendering the overrides needs to be recalculated for
* every loop as this normally happens once inside
* `EEVEE_temporal_sampling_init` */
else if (((inst->effects->enabled_effects & EFFECT_TAA) != 0) &&
(inst->effects->taa_current_sample > 1) && DRW_state_is_image_render())
else if (((stl->effects->enabled_effects & EFFECT_TAA) != 0) &&
(stl->effects->taa_current_sample > 1) && DRW_state_is_image_render())
{
EEVEE_temporal_sampling_update_matrices(static_cast<EEVEE_Data *>(vedata));
}
@@ -400,20 +280,20 @@ static void eevee_draw_scene(void *vedata)
/* Set ray type. */
sldata->common_data.ray_type = EEVEE_RAY_CAMERA;
sldata->common_data.ray_depth = 0.0f;
if (inst->g_data->disable_ligthprobes) {
if (stl->g_data->disable_ligthprobes) {
sldata->common_data.prb_num_render_cube = 1;
sldata->common_data.prb_num_render_grid = 1;
}
GPU_uniformbuf_update(sldata->common_ubo, &sldata->common_data);
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
eGPUFrameBufferBits clear_bits = GPU_DEPTH_BIT;
SET_FLAG_FROM_TEST(clear_bits, !DRW_state_draw_background(), GPU_COLOR_BIT);
SET_FLAG_FROM_TEST(clear_bits, (inst->effects->enabled_effects & EFFECT_SSS), GPU_STENCIL_BIT);
GPU_framebuffer_clear(inst->main_fb, clear_bits, clear_col, clear_depth, clear_stencil);
SET_FLAG_FROM_TEST(clear_bits, (stl->effects->enabled_effects & EFFECT_SSS), GPU_STENCIL_BIT);
GPU_framebuffer_clear(fbl->main_fb, clear_bits, clear_col, clear_depth, clear_stencil);
/* Depth pre-pass. */
DRW_draw_pass(inst->depth_ps);
DRW_draw_pass(psl->depth_ps);
/* Create minmax texture */
EEVEE_create_minmax_buffer(static_cast<EEVEE_Data *>(vedata), dtxl->depth, -1);
@@ -423,23 +303,23 @@ static void eevee_draw_scene(void *vedata)
/* Shading pass */
if (DRW_state_draw_background()) {
DRW_draw_pass(inst->background_ps);
DRW_draw_pass(psl->background_ps);
}
DRW_draw_pass(inst->material_ps);
DRW_draw_pass(psl->material_ps);
EEVEE_subsurface_data_render(sldata, static_cast<EEVEE_Data *>(vedata));
/* Effects pre-transparency */
EEVEE_subsurface_compute(sldata, static_cast<EEVEE_Data *>(vedata));
EEVEE_reflection_compute(sldata, static_cast<EEVEE_Data *>(vedata));
EEVEE_occlusion_draw_debug(sldata, static_cast<EEVEE_Data *>(vedata));
if (inst->probe_display) {
DRW_draw_pass(inst->probe_display);
if (psl->probe_display) {
DRW_draw_pass(psl->probe_display);
}
EEVEE_refraction_compute(sldata, static_cast<EEVEE_Data *>(vedata));
/* Opaque refraction */
DRW_draw_pass(inst->depth_refract_ps);
DRW_draw_pass(inst->material_refract_ps);
DRW_draw_pass(psl->depth_refract_ps);
DRW_draw_pass(psl->material_refract_ps);
/* Streamlined version of EEVEE_refraction_compute to just copy the colour buffer */
EEVEE_effects_radiance_copy(sldata, static_cast<EEVEE_Data *>(vedata));
@@ -454,26 +334,26 @@ static void eevee_draw_scene(void *vedata)
EEVEE_material_transparent_output_accumulate(static_cast<EEVEE_Data *>(vedata));
/* TODO(@fclem): should be its own Frame-buffer.
* This is needed because dual-source blending only works with 1 color buffer. */
GPU_framebuffer_texture_attach(inst->main_color_fb, dtxl->depth, 0, 0);
GPU_framebuffer_bind(inst->main_color_fb);
DRW_draw_pass(inst->transparent_pass);
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_texture_detach(inst->main_color_fb, dtxl->depth);
GPU_framebuffer_texture_attach(fbl->main_color_fb, dtxl->depth, 0, 0);
GPU_framebuffer_bind(fbl->main_color_fb);
DRW_draw_pass(psl->transparent_pass);
GPU_framebuffer_bind(fbl->main_fb);
GPU_framebuffer_texture_detach(fbl->main_color_fb, dtxl->depth);
/* Post Process */
EEVEE_draw_effects(sldata, static_cast<EEVEE_Data *>(vedata));
DRW_view_set_active(nullptr);
if (DRW_state_is_image_render() && (inst->effects->enabled_effects & EFFECT_SSR) &&
!inst->effects->ssr_was_valid_double_buffer)
if (DRW_state_is_image_render() && (stl->effects->enabled_effects & EFFECT_SSR) &&
!stl->effects->ssr_was_valid_double_buffer)
{
/* SSR needs one iteration to start properly. */
loop_len++;
/* Reset sampling (and accumulation) after the first sample to avoid
* washed out first bounce for SSR. */
EEVEE_temporal_sampling_reset(static_cast<EEVEE_Data *>(vedata));
inst->effects->ssr_was_valid_double_buffer = inst->g_data->valid_double_buffer;
stl->effects->ssr_was_valid_double_buffer = stl->g_data->valid_double_buffer;
}
/* Perform render step between samples to allow flushing of freed temporary GPUBackend
@@ -487,35 +367,32 @@ static void eevee_draw_scene(void *vedata)
}
}
if ((inst->g_data->render_passes & EEVEE_RENDER_PASS_COMBINED) != 0) {
if ((stl->g_data->render_passes & EEVEE_RENDER_PASS_COMBINED) != 0) {
/* Transfer result to default framebuffer. */
GPU_framebuffer_bind(dfbl->default_fb);
DRW_transform_none(inst->effects->final_tx);
DRW_transform_none(stl->effects->final_tx);
}
else {
EEVEE_renderpasses_draw(sldata, static_cast<EEVEE_Data *>(vedata));
}
if (inst->effects->bypass_drawing) {
if (stl->effects->bypass_drawing) {
/* Restore the depth from sample 1. */
GPU_framebuffer_blit(inst->double_buffer_depth_fb, 0, dfbl->default_fb, 0, GPU_DEPTH_BIT);
GPU_framebuffer_blit(fbl->double_buffer_depth_fb, 0, dfbl->default_fb, 0, GPU_DEPTH_BIT);
}
EEVEE_renderpasses_draw_debug(static_cast<EEVEE_Data *>(vedata));
inst->g_data->view_updated = false;
stl->g_data->view_updated = false;
DRW_view_set_active(nullptr);
}
static void eevee_view_update(void *vedata)
{
EEVEE_Data *ved = (EEVEE_Data *)vedata;
GOOENGINE_Instance *inst = ved->instance;
if (inst) {
if (inst->g_data) {
inst->g_data->view_updated = true;
}
EEVEE_StorageList *stl = ((EEVEE_Data *)vedata)->stl;
if (stl && stl->g_data) {
stl->g_data->view_updated = true;
}
}
@@ -541,11 +418,10 @@ static void eevee_id_object_update(void * /*vedata*/, Object *object)
static void eevee_id_world_update(void *vedata, World *wo)
{
EEVEE_Data *ved = (EEVEE_Data *)vedata;
GOOENGINE_Instance *inst = ved->instance;
LightCache *lcache = inst->g_data->light_cache;
EEVEE_StorageList *stl = ((EEVEE_Data *)vedata)->stl;
LightCache *lcache = stl->g_data->light_cache;
if (ELEM(lcache, nullptr, inst->lookdev_lightcache)) {
if (ELEM(lcache, nullptr, stl->lookdev_lightcache)) {
/* Avoid Lookdev viewport clearing the update flag (see #67741). */
return;
}
@@ -578,104 +454,8 @@ void eevee_id_update(void *vedata, ID *id)
static void eevee_render_reset_passes(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
/* Reset pass-list. This is safe as they are stored into managed memory chunks. */
// memset(vedata->psl, 0, sizeof(*vedata->psl)); ORIGINAL
// memset(inst, 0, sizeof(*inst)); NEW NEED TO FIGURE THIS OUT
// THIS IS ONLY USED FOR MOTION BLUR DURING RENDERING
memset(inst->shadow_pass, 0, sizeof(inst->shadow_pass));
memset(inst->shadow_accum_pass, 0, sizeof(inst->shadow_accum_pass));
memset(inst->probe_background, 0, sizeof(inst->probe_background));
memset(inst->probe_glossy_compute, 0, sizeof(inst->probe_glossy_compute));
memset(inst->probe_diffuse_compute, 0, sizeof(inst->probe_diffuse_compute));
memset(inst->probe_visibility_compute, 0, sizeof(inst->probe_visibility_compute));
memset(inst->probe_grid_fill, 0, sizeof(inst->probe_grid_fill));
memset(inst->probe_display, 0, sizeof(inst->probe_display));
memset(inst->probe_planar_downsample_ps, 0, sizeof(inst->probe_planar_downsample_ps));
memset(inst->ao_horizon_search, 0, sizeof(inst->ao_horizon_search));
memset(inst->ao_horizon_debug, 0, sizeof(inst->ao_horizon_debug));
memset(inst->ao_accum_ps, 0, sizeof(inst->ao_accum_ps));
memset(inst->mist_accum_ps, 0, sizeof(inst->mist_accum_ps));
memset(inst->motion_blur, 0, sizeof(inst->motion_blur));
memset(inst->bloom_blit, 0, sizeof(inst->bloom_blit));
memset(inst->bloom_downsample_first, 0, sizeof(inst->bloom_downsample_first));
memset(inst->bloom_downsample, 0, sizeof(inst->bloom_downsample));
memset(inst->bloom_upsample, 0, sizeof(inst->bloom_upsample));
memset(inst->bloom_resolve, 0, sizeof(inst->bloom_resolve));
memset(inst->bloom_accum_ps, 0, sizeof(inst->bloom_accum_ps));
memset(inst->dof_setup, 0, sizeof(inst->dof_setup));
memset(inst->dof_flatten_tiles, 0, sizeof(inst->dof_flatten_tiles));
memset(inst->dof_dilate_tiles_minmax, 0, sizeof(inst->dof_dilate_tiles_minmax));
memset(inst->dof_dilate_tiles_minabs, 0, sizeof(inst->dof_dilate_tiles_minabs));
memset(inst->dof_reduce_copy, 0, sizeof(inst->dof_reduce_copy));
memset(inst->dof_downsample, 0, sizeof(inst->dof_downsample));
memset(inst->dof_reduce, 0, sizeof(inst->dof_reduce));
memset(inst->dof_bokeh, 0, sizeof(inst->dof_bokeh));
memset(inst->dof_gather_fg, 0, sizeof(inst->dof_gather_fg));
memset(inst->dof_gather_fg_holefill, 0, sizeof(inst->dof_gather_fg_holefill));
memset(inst->dof_gather_bg, 0, sizeof(inst->dof_gather_bg));
memset(inst->dof_scatter_fg, 0, sizeof(inst->dof_scatter_fg));
memset(inst->dof_scatter_bg, 0, sizeof(inst->dof_scatter_bg));
memset(inst->dof_filter, 0, sizeof(inst->dof_filter));
memset(inst->dof_resolve, 0, sizeof(inst->dof_resolve));
memset(inst->volumetric_world_ps, 0, sizeof(inst->volumetric_world_ps));
memset(inst->volumetric_objects_ps, 0, sizeof(inst->volumetric_objects_ps));
memset(inst->volumetric_scatter_ps, 0, sizeof(inst->volumetric_scatter_ps));
memset(inst->volumetric_integration_ps, 0, sizeof(inst->volumetric_integration_ps));
memset(inst->volumetric_resolve_ps, 0, sizeof(inst->volumetric_resolve_ps));
memset(inst->volumetric_accum_ps, 0, sizeof(inst->volumetric_accum_ps));
memset(inst->ssr_raytrace, 0, sizeof(inst->ssr_raytrace));
memset(inst->ssr_resolve, 0, sizeof(inst->ssr_resolve));
memset(inst->ssr_resolve_probe, 0, sizeof(inst->ssr_resolve_probe));
memset(inst->ssr_resolve_refl, 0, sizeof(inst->ssr_resolve_refl));
memset(inst->sss_blur_ps, 0, sizeof(inst->sss_blur_ps));
memset(inst->sss_resolve_ps, 0, sizeof(inst->sss_resolve_ps));
memset(inst->sss_translucency_ps, 0, sizeof(inst->sss_translucency_ps));
memset(inst->color_copy_ps, 0, sizeof(inst->color_copy_ps));
memset(inst->color_downsample_ps, 0, sizeof(inst->color_downsample_ps));
memset(inst->color_downsample_cube_ps, 0, sizeof(inst->color_downsample_cube_ps));
memset(inst->velocity_object, 0, sizeof(inst->velocity_object));
memset(inst->velocity_hair, 0, sizeof(inst->velocity_hair));
memset(inst->velocity_resolve, 0, sizeof(inst->velocity_resolve));
memset(inst->velocity_tiles_x, 0, sizeof(inst->velocity_tiles_x));
memset(inst->velocity_tiles, 0, sizeof(inst->velocity_tiles));
memset(inst->velocity_tiles_expand[2], 0, sizeof(inst->velocity_tiles_expand[2]));
memset(inst->taa_resolve, 0, sizeof(inst->taa_resolve));
memset(inst->alpha_checker, 0, sizeof(inst->alpha_checker));
memset(inst->maxz_downlevel_ps, 0, sizeof(inst->maxz_downlevel_ps));
memset(inst->maxz_copydepth_ps, 0, sizeof(inst->maxz_copydepth_ps));
memset(inst->maxz_copydepth_layer_ps, 0, sizeof(inst->maxz_copydepth_layer_ps));
memset(inst->material_accum_ps, 0, sizeof(inst->material_accum_ps));
memset(inst->background_accum_ps, 0, sizeof(inst->background_accum_ps));
memset(inst->transparent_accum_ps, 0, sizeof(inst->transparent_accum_ps));
memset(inst->cryptomatte_ps, 0, sizeof(inst->cryptomatte_ps));
memset(inst->depth_ps, 0, sizeof(inst->depth_ps));
memset(inst->depth_cull_ps, 0, sizeof(inst->depth_cull_ps));
memset(inst->depth_clip_ps, 0, sizeof(inst->depth_clip_ps));
memset(inst->depth_clip_cull_ps, 0, sizeof(inst->depth_clip_cull_ps));
memset(inst->depth_refract_ps, 0, sizeof(inst->depth_refract_ps));
memset(inst->depth_refract_cull_ps, 0, sizeof(inst->depth_refract_cull_ps));
memset(inst->depth_refract_clip_ps, 0, sizeof(inst->depth_refract_clip_ps));
memset(inst->depth_refract_clip_cull_ps, 0, sizeof(inst->depth_refract_clip_cull_ps));
memset(inst->material_ps, 0, sizeof(inst->material_ps));
memset(inst->material_cull_ps, 0, sizeof(inst->material_cull_ps));
memset(inst->material_refract_ps, 0, sizeof(inst->material_refract_ps));
memset(inst->material_refract_cull_ps, 0, sizeof(inst->material_refract_cull_ps));
memset(inst->material_sss_ps, 0, sizeof(inst->material_sss_ps));
memset(inst->material_sss_cull_ps, 0, sizeof(inst->material_sss_cull_ps));
memset(inst->transparent_pass, 0, sizeof(inst->transparent_pass));
memset(inst->background_ps, 0, sizeof(inst->background_ps));
memset(inst->update_noise_pass, 0, sizeof(inst->update_noise_pass));
memset(inst->lookdev_glossy_pass, 0, sizeof(inst->lookdev_glossy_pass));
memset(inst->lookdev_diffuse_pass, 0, sizeof(inst->lookdev_diffuse_pass));
memset(inst->renderpass_pass, 0, sizeof(inst->renderpass_pass));
memset(vedata->psl, 0, sizeof(*vedata->psl));
}
static void eevee_render_to_image(void *vedata,
@@ -684,11 +464,6 @@ static void eevee_render_to_image(void *vedata,
const rcti *rect)
{
EEVEE_Data *ved = (EEVEE_Data *)vedata;
if (ved->instance == nullptr) {
ved->instance = new GOOENGINE_Instance();
}
GOOENGINE_Instance *inst = ved->instance;
const DRWContextState *draw_ctx = DRW_context_state_get();
Depsgraph *depsgraph = draw_ctx->depsgraph;
Scene *scene = DEG_get_evaluated_scene(depsgraph);
@@ -699,7 +474,7 @@ static void eevee_render_to_image(void *vedata,
if (!EEVEE_render_init(static_cast<EEVEE_Data *>(vedata), engine, depsgraph)) {
return;
}
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_PrivateData *g_data = ved->stl->g_data;
int initial_frame = scene->r.cfra;
float initial_subframe = scene->r.subframe;
@@ -710,7 +485,7 @@ static void eevee_render_to_image(void *vedata,
EEVEE_render_modules_init(static_cast<EEVEE_Data *>(vedata), engine, depsgraph);
g_data->render_sample_count_per_timestep = EEVEE_temporal_sampling_sample_count_get(scene,
inst);
ved->stl);
/* Reset in case the same engine is used on multiple views. */
EEVEE_temporal_sampling_reset(static_cast<EEVEE_Data *>(vedata));
@@ -828,7 +603,7 @@ static void eevee_render_to_image(void *vedata,
}
}
EEVEE_motion_blur_data_free(&inst->effects->motion_blur);
EEVEE_motion_blur_data_free(&ved->stl->effects->motion_blur);
if (RE_engine_test_break(engine)) {
return;
@@ -849,8 +624,7 @@ static void eevee_render_to_image(void *vedata,
static void eevee_store_metadata(void *vedata, RenderResult *render_result)
{
EEVEE_Data *ved = (EEVEE_Data *)vedata;
GOOENGINE_Instance *inst = ved->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_PrivateData *g_data = ved->stl->g_data;
if (g_data->render_passes & EEVEE_RENDER_PASS_CRYPTOMATTE) {
EEVEE_cryptomatte_store_metadata(ved, render_result);
EEVEE_cryptomatte_free(ved);
@@ -866,11 +640,6 @@ static void eevee_engine_free()
EEVEE_volumes_free();
}
static void eevee_instance_free(void *instance)
{
delete reinterpret_cast<GOOENGINE_Instance *>(instance);
}
static const DrawEngineDataSize eevee_data_size = DRW_VIEWPORT_DATA_SIZE(EEVEE_Data);
DrawEngineType draw_engine_eevee_type = {
@@ -880,7 +649,7 @@ DrawEngineType draw_engine_eevee_type = {
/*vedata_size*/ &eevee_data_size,
/*engine_init*/ &eevee_engine_init,
/*engine_free*/ &eevee_engine_free,
/*instance_free*/ &eevee_instance_free,
/*instance_free*/ nullptr,
/*cache_init*/ &eevee_cache_init,
/*cache_populate*/ &EEVEE_cache_populate,
/*cache_finish*/ &eevee_cache_finish,
source/blender/draw/engines/gooengine/eevee_lightcache.cc
+18 -18
View File
@@ -943,7 +943,9 @@ static void eevee_lightbake_delete_resources(EEVEE_LightBake *lbake)
static void eevee_lightbake_cache_create(EEVEE_Data *vedata, EEVEE_LightBake *lbake)
{
using namespace blender::draw;
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_ViewLayerData *sldata = EEVEE_view_layer_data_ensure();
Scene *scene_eval = DEG_get_evaluated_scene(lbake->depsgraph);
lbake->sldata = sldata;
@@ -953,9 +955,9 @@ static void eevee_lightbake_cache_create(EEVEE_Data *vedata, EEVEE_LightBake *lb
scene_eval->eevee.taa_samples = 1;
scene_eval->eevee.gi_irradiance_smoothing = 0.0f;
inst->g_data = static_cast<EEVEE_PrivateData *>(MEM_callocN(sizeof(*inst->g_data), __func__));
inst->g_data->background_alpha = 1.0f;
inst->g_data->render_timesteps = 1;
stl->g_data = static_cast<EEVEE_PrivateData *>(MEM_callocN(sizeof(*stl->g_data), __func__));
stl->g_data->background_alpha = 1.0f;
stl->g_data->render_timesteps = 1;
/* XXX TODO: remove this. This is in order to make the init functions work. */
if (DRW_view_default_get() == nullptr) {
@@ -968,16 +970,16 @@ static void eevee_lightbake_cache_create(EEVEE_Data *vedata, EEVEE_LightBake *lb
DRW_view_set_active(view);
}
/* HACK: set inst->color but unset it before Draw Manager frees it. */
inst->color = lbake->rt_color;
/* HACK: set txl->color but unset it before Draw Manager frees it. */
txl->color = lbake->rt_color;
const int viewport_size[2] = {
GPU_texture_width(inst->color),
GPU_texture_height(inst->color),
GPU_texture_width(txl->color),
GPU_texture_height(txl->color),
};
DRW_render_viewport_size_set(viewport_size);
EEVEE_effects_init(sldata, vedata, nullptr, true);
EEVEE_materials_init(sldata, vedata);
EEVEE_materials_init(sldata, vedata, stl, fbl);
EEVEE_shadows_init(sldata);
EEVEE_lightprobes_init(sldata, vedata);
@@ -1006,13 +1008,13 @@ static void eevee_lightbake_cache_create(EEVEE_Data *vedata, EEVEE_LightBake *lb
EEVEE_shadows_update(sldata, vedata);
/* Disable volumetrics when baking. */
inst->effects->enabled_effects &= ~EFFECT_VOLUMETRIC;
stl->effects->enabled_effects &= ~EFFECT_VOLUMETRIC;
EEVEE_subsurface_draw_init(sldata, vedata);
EEVEE_effects_draw_init(sldata, vedata);
EEVEE_volumes_draw_init(sldata, vedata);
inst->color = nullptr;
txl->color = nullptr;
DRW_render_instance_buffer_finish();
DRW_curves_update(*DRW_manager_get());
@@ -1041,7 +1043,6 @@ static void eevee_lightbake_copy_irradiance(EEVEE_LightBake *lbake, LightCache *
static void eevee_lightbake_render_world_sample(void *ved, void *user_data)
{
EEVEE_Data *vedata = (EEVEE_Data *)ved;
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_ViewLayerData *sldata = EEVEE_view_layer_data_ensure();
EEVEE_LightBake *lbake = (EEVEE_LightBake *)user_data;
Scene *scene_eval = DEG_get_evaluated_scene(lbake->depsgraph);
@@ -1049,7 +1050,7 @@ static void eevee_lightbake_render_world_sample(void *ved, void *user_data)
float clamp = scene_eval->eevee.gi_glossy_clamp;
float filter_quality = scene_eval->eevee.gi_filter_quality;
/* TODO: do this once for the whole bake when we have independent DRWContexts. */
/* TODO: do this once for the whole bake when we have independent DRWManagers. */
eevee_lightbake_cache_create(vedata, lbake);
sldata->common_data.ray_type = EEVEE_RAY_GLOSSY;
@@ -1078,7 +1079,7 @@ static void eevee_lightbake_render_world_sample(void *ved, void *user_data)
GPU_framebuffer_bind(lbake->store_fb);
/* Clear to 1.0f for visibility. */
GPU_framebuffer_clear_color(lbake->store_fb, blender::float4{1.0f, 1.0f, 1.0f, 1.0f});
DRW_draw_pass(inst->probe_grid_fill);
DRW_draw_pass(vedata->psl->probe_grid_fill);
std::swap(lbake->grid_prev, lcache->grid_tx.tex);
@@ -1174,7 +1175,7 @@ static void eevee_lightbake_render_grid_sample(void *ved, void *user_data)
/* Use the previous bounce for rendering this bounce. */
std::swap(lbake->grid_prev, lcache->grid_tx.tex);
/* TODO: do this once for the whole bake when we have independent DRWContexts.
/* TODO: do this once for the whole bake when we have independent DRWManagers.
* WARNING: Some of the things above require this. */
eevee_lightbake_cache_create(vedata, lbake);
@@ -1252,7 +1253,7 @@ static void eevee_lightbake_render_probe_sample(void *ved, void *user_data)
float clamp = scene_eval->eevee.gi_glossy_clamp;
float filter_quality = scene_eval->eevee.gi_filter_quality;
/* TODO: do this once for the whole bake when we have independent DRWContexts. */
/* TODO: do this once for the whole bake when we have independent DRWManagers. */
eevee_lightbake_cache_create(vedata, lbake);
/* Disable specular lighting when rendering probes to avoid feedback loops (looks bad). */
@@ -1533,8 +1534,7 @@ void EEVEE_lightbake_update_world_quick(EEVEE_ViewLayerData *sldata,
EEVEE_Data *vedata,
const Scene *scene)
{
GOOENGINE_Instance *inst = vedata->instance;
LightCache *lcache = inst->g_data->light_cache;
LightCache *lcache = vedata->stl->g_data->light_cache;
float clamp = scene->eevee.gi_glossy_clamp;
float filter_quality = scene->eevee.gi_filter_quality;
source/blender/draw/engines/gooengine/eevee_lightprobes.cc
+126 -125
View File
@@ -77,8 +77,9 @@ bool EEVEE_lightprobes_obj_visibility_cb(bool vis_in, void *user_data)
static void planar_pool_ensure_alloc(EEVEE_Data *vedata, int num_planar_ref)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *fx = inst->effects;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *fx = stl->effects;
/* XXX TODO: OPTIMIZATION: This is a complete waste of texture memory.
* Instead of allocating each planar probe for each viewport,
@@ -93,21 +94,21 @@ static void planar_pool_ensure_alloc(EEVEE_Data *vedata, int num_planar_ref)
int height = max_ii(1, fx->hiz_size[1] / screen_divider);
/* Fix case were the pool was allocated width the dummy size (1,1,1). */
if (inst->planar_pool && (num_planar_ref > 0) &&
(GPU_texture_width(inst->planar_pool) != width ||
GPU_texture_height(inst->planar_pool) != height))
if (txl->planar_pool && (num_planar_ref > 0) &&
(GPU_texture_width(txl->planar_pool) != width ||
GPU_texture_height(txl->planar_pool) != height))
{
DRW_TEXTURE_FREE_SAFE(inst->planar_pool);
DRW_TEXTURE_FREE_SAFE(inst->planar_depth);
DRW_TEXTURE_FREE_SAFE(txl->planar_pool);
DRW_TEXTURE_FREE_SAFE(txl->planar_depth);
}
/* We need an Array texture so allocate it ourself */
if (!inst->planar_pool) {
if (!txl->planar_pool) {
eGPUTextureUsage planar_usage = GPU_TEXTURE_USAGE_ATTACHMENT | GPU_TEXTURE_USAGE_SHADER_READ;
eGPUTextureUsage planar_usage_depth = GPU_TEXTURE_USAGE_ATTACHMENT |
GPU_TEXTURE_USAGE_SHADER_READ;
if (num_planar_ref > 0) {
inst->planar_pool = DRW_texture_create_2d_array_ex(
txl->planar_pool = DRW_texture_create_2d_array_ex(
width,
height,
num_planar_ref,
@@ -115,7 +116,7 @@ static void planar_pool_ensure_alloc(EEVEE_Data *vedata, int num_planar_ref)
planar_usage,
DRWTextureFlag(DRW_TEX_FILTER | DRW_TEX_MIPMAP),
nullptr);
inst->planar_depth = DRW_texture_create_2d_array_ex(width,
txl->planar_depth = DRW_texture_create_2d_array_ex(width,
height,
num_planar_ref,
GPU_DEPTH_COMPONENT24,
@@ -126,7 +127,7 @@ static void planar_pool_ensure_alloc(EEVEE_Data *vedata, int num_planar_ref)
else if (num_planar_ref == 0) {
/* Makes Opengl Happy : Create a placeholder texture that will never be sampled but still
* bound to shader. */
inst->planar_pool = DRW_texture_create_2d_array_ex(
txl->planar_pool = DRW_texture_create_2d_array_ex(
1,
1,
1,
@@ -134,7 +135,7 @@ static void planar_pool_ensure_alloc(EEVEE_Data *vedata, int num_planar_ref)
planar_usage,
DRWTextureFlag(DRW_TEX_FILTER | DRW_TEX_MIPMAP),
nullptr);
inst->planar_depth = DRW_texture_create_2d_array_ex(
txl->planar_depth = DRW_texture_create_2d_array_ex(
1, 1, 1, GPU_DEPTH_COMPONENT24, planar_usage_depth, DRWTextureFlag(0), nullptr);
}
}
@@ -142,8 +143,8 @@ static void planar_pool_ensure_alloc(EEVEE_Data *vedata, int num_planar_ref)
void EEVEE_lightprobes_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_CommonUniformBuffer *common_data = &sldata->common_data;
EEVEE_StorageList *stl = vedata->stl;
const DRWContextState *draw_ctx = DRW_context_state_get();
const Scene *scene_eval = DEG_get_evaluated_scene(draw_ctx->depsgraph);
@@ -151,13 +152,13 @@ void EEVEE_lightprobes_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
EEVEE_shaders_material_shaders_init();
memset(inst->g_data->bake_views, 0, sizeof(inst->g_data->bake_views));
memset(inst->g_data->cube_views, 0, sizeof(inst->g_data->cube_views));
memset(inst->g_data->world_views, 0, sizeof(inst->g_data->world_views));
memset(inst->g_data->planar_views, 0, sizeof(inst->g_data->planar_views));
memset(stl->g_data->bake_views, 0, sizeof(stl->g_data->bake_views));
memset(stl->g_data->cube_views, 0, sizeof(stl->g_data->cube_views));
memset(stl->g_data->world_views, 0, sizeof(stl->g_data->world_views));
memset(stl->g_data->planar_views, 0, sizeof(stl->g_data->planar_views));
if (EEVEE_lightcache_load(scene_eval->eevee.light_cache_data)) {
inst->g_data->light_cache = scene_eval->eevee.light_cache_data;
stl->g_data->light_cache = scene_eval->eevee.light_cache_data;
}
else {
if (scene_eval->eevee.light_cache_data &&
@@ -180,7 +181,7 @@ void EEVEE_lightprobes_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
scene_eval->eevee.gi_visibility_resolution,
blender::int3{grid_res, grid_res, 1});
}
inst->g_data->light_cache = sldata->fallback_lightcache;
stl->g_data->light_cache = sldata->fallback_lightcache;
}
if (!sldata->probes) {
@@ -213,15 +214,15 @@ void EEVEE_lightbake_cache_init(EEVEE_ViewLayerData *sldata,
GPUTexture *rt_color,
GPUTexture *rt_depth)
{
GOOENGINE_Instance *inst = vedata->instance;
LightCache *light_cache = inst->g_data->light_cache;
EEVEE_PassList *psl = vedata->psl;
LightCache *light_cache = vedata->stl->g_data->light_cache;
EEVEE_LightProbesInfo *pinfo = sldata->probes;
{
DRW_PASS_CREATE(inst->probe_glossy_compute, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->probe_glossy_compute, DRW_STATE_WRITE_COLOR);
DRWShadingGroup *grp = DRW_shgroup_create(EEVEE_shaders_probe_filter_glossy_sh_get(),
inst->probe_glossy_compute);
psl->probe_glossy_compute);
DRW_shgroup_uniform_float(grp, "intensityFac", &pinfo->intensity_fac, 1);
DRW_shgroup_uniform_float(grp, "sampleCount", &pinfo->samples_len, 1);
@@ -242,9 +243,9 @@ void EEVEE_lightbake_cache_init(EEVEE_ViewLayerData *sldata,
}
{
DRW_PASS_CREATE(inst->probe_diffuse_compute, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->probe_diffuse_compute, DRW_STATE_WRITE_COLOR);
DRWShadingGroup *grp = DRW_shgroup_create(EEVEE_shaders_probe_filter_diffuse_sh_get(),
inst->probe_diffuse_compute);
psl->probe_diffuse_compute);
#ifdef IRRADIANCE_SH_L2
DRW_shgroup_uniform_int(grp, "probeSize", &pinfo->shres, 1);
#else
@@ -262,9 +263,9 @@ void EEVEE_lightbake_cache_init(EEVEE_ViewLayerData *sldata,
}
{
DRW_PASS_CREATE(inst->probe_visibility_compute, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->probe_visibility_compute, DRW_STATE_WRITE_COLOR);
DRWShadingGroup *grp = DRW_shgroup_create(EEVEE_shaders_probe_filter_visibility_sh_get(),
inst->probe_visibility_compute);
psl->probe_visibility_compute);
DRW_shgroup_uniform_int(grp, "outputSize", &pinfo->shres, 1);
DRW_shgroup_uniform_float(grp, "visibilityRange", &pinfo->visibility_range, 1);
DRW_shgroup_uniform_float(grp, "visibilityBlur", &pinfo->visibility_blur, 1);
@@ -281,10 +282,10 @@ void EEVEE_lightbake_cache_init(EEVEE_ViewLayerData *sldata,
}
{
DRW_PASS_CREATE(inst->probe_grid_fill, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->probe_grid_fill, DRW_STATE_WRITE_COLOR);
DRWShadingGroup *grp = DRW_shgroup_create(EEVEE_shaders_probe_grid_fill_sh_get(),
inst->probe_grid_fill);
psl->probe_grid_fill);
DRW_shgroup_uniform_texture_ref(grp, "irradianceGrid", &light_cache->grid_tx.tex);
@@ -295,9 +296,11 @@ void EEVEE_lightbake_cache_init(EEVEE_ViewLayerData *sldata,
void EEVEE_lightprobes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_LightProbesInfo *pinfo = sldata->probes;
LightCache *lcache = inst->g_data->light_cache;
LightCache *lcache = stl->g_data->light_cache;
const DRWContextState *draw_ctx = DRW_context_state_get();
const Scene *scene_eval = DEG_get_evaluated_scene(draw_ctx->depsgraph);
@@ -307,10 +310,10 @@ void EEVEE_lightprobes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedat
pinfo->do_cube_update = false;
{
DRW_PASS_CREATE(inst->probe_background, DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_EQUAL);
DRW_PASS_CREATE(psl->probe_background, DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_EQUAL);
DRWShadingGroup *grp = nullptr;
EEVEE_lookdev_cache_init(vedata, sldata, inst->probe_background, pinfo, &grp);
EEVEE_lookdev_cache_init(vedata, sldata, psl->probe_background, pinfo, &grp);
if (grp == nullptr) {
Scene *scene = draw_ctx->scene;
@@ -319,7 +322,7 @@ void EEVEE_lightprobes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedat
const int options = VAR_WORLD_BACKGROUND | VAR_WORLD_PROBE;
GPUMaterial *gpumat = EEVEE_material_get(vedata, scene, nullptr, world, options);
grp = DRW_shgroup_material_create(gpumat, inst->probe_background);
grp = DRW_shgroup_material_create(gpumat, psl->probe_background);
DRW_shgroup_uniform_float_copy(grp, "backgroundAlpha", 1.0f);
/* Bind all textures required by Material shaders on Metal */
@@ -333,21 +336,21 @@ void EEVEE_lightprobes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedat
DRW_shgroup_uniform_block(grp, "planar_block", sldata->planar_ubo);
DRW_shgroup_uniform_block(grp, "light_block", sldata->light_ubo);
DRW_shgroup_uniform_block(grp, "shadow_block", sldata->shadow_ubo);
DRW_shgroup_uniform_block_ref(grp, "renderpass_block", &inst->g_data->renderpass_ubo);
DRW_shgroup_uniform_block_ref(grp, "renderpass_block", &stl->g_data->renderpass_ubo);
DRW_shgroup_call(grp, DRW_cache_fullscreen_quad_get(), nullptr);
}
if (DRW_state_draw_support()) {
DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL |
DRW_STATE_CULL_BACK;
DRW_PASS_CREATE(inst->probe_display, state);
DRW_PASS_CREATE(psl->probe_display, state);
if (!LOOK_DEV_STUDIO_LIGHT_ENABLED(draw_ctx->v3d)) {
/* Cube Display */
if (scene_eval->eevee.flag & SCE_EEVEE_SHOW_CUBEMAPS && lcache->cube_len > 1) {
int cube_len = lcache->cube_len - 1; /* don't count the world. */
DRWShadingGroup *grp = DRW_shgroup_create(EEVEE_shaders_probe_cube_display_sh_get(),
inst->probe_display);
psl->probe_display);
DRW_shgroup_uniform_texture_ref(grp, "probeCubes", &lcache->cube_tx.tex);
DRW_shgroup_uniform_block(grp, "probe_block", sldata->probe_ubo);
@@ -367,7 +370,7 @@ void EEVEE_lightprobes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedat
EEVEE_LightGrid *egrid = lcache->grid_data + 1;
for (int p = 1; p < lcache->grid_len; p++, egrid++) {
DRWShadingGroup *shgrp = DRW_shgroup_create(EEVEE_shaders_probe_grid_display_sh_get(),
inst->probe_display);
psl->probe_display);
DRW_shgroup_uniform_int(shgrp, "offset", &egrid->offset, 1);
DRW_shgroup_uniform_ivec3(shgrp, "grid_resolution", egrid->resolution, 1);
@@ -399,16 +402,16 @@ void EEVEE_lightprobes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedat
});
DRWShadingGroup *grp = DRW_shgroup_create(EEVEE_shaders_probe_planar_display_sh_get(),
inst->probe_display);
DRW_shgroup_uniform_texture_ref(grp, "probePlanars", &inst->planar_pool);
psl->probe_display);
DRW_shgroup_uniform_texture_ref(grp, "probePlanars", &txl->planar_pool);
DRW_shgroup_uniform_block(grp, "renderpass_block", sldata->renderpass_ubo.combined);
inst->g_data->planar_display_shgrp = DRW_shgroup_call_buffer_instance(
stl->g_data->planar_display_shgrp = DRW_shgroup_call_buffer_instance(
grp, e_data.format_probe_display_planar, DRW_cache_quad_get());
}
}
else {
inst->g_data->planar_display_shgrp = nullptr;
stl->g_data->planar_display_shgrp = nullptr;
}
}
@@ -447,7 +450,6 @@ static bool eevee_lightprobes_culling_test(Object *ob)
void EEVEE_lightprobes_cache_add(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, Object *ob)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_LightProbesInfo *pinfo = sldata->probes;
LightProbe *probe = (LightProbe *)ob->data;
@@ -468,7 +470,7 @@ void EEVEE_lightprobes_cache_add(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata
EEVEE_lightprobes_planar_data_from_object(
ob, &pinfo->planar_data[pinfo->num_planar], &pinfo->planar_vis_tests[pinfo->num_planar]);
/* Debug Display */
DRWCallBuffer *grp = inst->g_data->planar_display_shgrp;
DRWCallBuffer *grp = vedata->stl->g_data->planar_display_shgrp;
if (grp && (probe->flag & LIGHTPROBE_FLAG_SHOW_DATA)) {
DRW_buffer_add_entry(grp, &pinfo->num_planar, ob->object_to_world().ptr());
}
@@ -697,8 +699,8 @@ static void eevee_lightprobes_extract_from_cache(EEVEE_LightProbesInfo *pinfo, L
void EEVEE_lightprobes_cache_finish(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
LightCache *light_cache = inst->g_data->light_cache;
EEVEE_StorageList *stl = vedata->stl;
LightCache *light_cache = stl->g_data->light_cache;
EEVEE_LightProbesInfo *pinfo = sldata->probes;
const DRWContextState *draw_ctx = DRW_context_state_get();
const Scene *scene_eval = DEG_get_evaluated_scene(draw_ctx->depsgraph);
@@ -717,8 +719,8 @@ void EEVEE_lightprobes_cache_finish(EEVEE_ViewLayerData *sldata, EEVEE_Data *ved
sldata->common_data.prb_num_planar = pinfo->num_planar;
if (pinfo->num_planar != pinfo->cache_num_planar) {
DRW_TEXTURE_FREE_SAFE(inst->planar_pool);
DRW_TEXTURE_FREE_SAFE(inst->planar_depth);
DRW_TEXTURE_FREE_SAFE(vedata->txl->planar_pool);
DRW_TEXTURE_FREE_SAFE(vedata->txl->planar_depth);
pinfo->cache_num_planar = pinfo->num_planar;
}
planar_pool_ensure_alloc(vedata, pinfo->num_planar);
@@ -748,13 +750,14 @@ void EEVEE_lightprobes_cache_finish(EEVEE_ViewLayerData *sldata, EEVEE_Data *ved
}
if (pinfo->num_planar > 0) {
GOOENGINE_Instance *inst = vedata->instance;
DRW_PASS_CREATE(inst->probe_planar_downsample_ps, DRW_STATE_WRITE_COLOR);
EEVEE_PassList *psl = vedata->psl;
EEVEE_TextureList *txl = vedata->txl;
DRW_PASS_CREATE(psl->probe_planar_downsample_ps, DRW_STATE_WRITE_COLOR);
DRWShadingGroup *grp = DRW_shgroup_create(EEVEE_shaders_probe_planar_downsample_sh_get(),
inst->probe_planar_downsample_ps);
psl->probe_planar_downsample_ps);
DRW_shgroup_uniform_texture_ref(grp, "source", &inst->planar_pool);
DRW_shgroup_uniform_texture_ref(grp, "source", &txl->planar_pool);
DRW_shgroup_uniform_float(grp, "fireflyFactor", &sldata->common_data.ssr_firefly_fac, 1);
DRW_shgroup_call_procedural_triangles(grp, nullptr, pinfo->num_planar);
}
@@ -777,9 +780,8 @@ static void render_cubemap(void (*callback)(int face, EEVEE_BakeRenderData *user
float far,
bool do_culling)
{
EEVEE_Data *vedata = user_data->vedata;
GOOENGINE_Instance *inst = vedata->instance;
DRWView **views = do_culling ? inst->g_data->bake_views : inst->g_data->world_views;
EEVEE_StorageList *stl = user_data->vedata->stl;
DRWView **views = do_culling ? stl->g_data->bake_views : stl->g_data->world_views;
float winmat[4][4], viewmat[4][4];
perspective_m4(winmat, -near, near, -near, near, near, far);
@@ -820,11 +822,10 @@ static void render_reflections(void (*callback)(int face, EEVEE_BakeRenderData *
EEVEE_PlanarReflection *planar_data,
int ref_count)
{
EEVEE_Data *vedata = user_data->vedata;
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_StorageList *stl = user_data->vedata->stl;
EEVEE_ViewLayerData *sldata = user_data->sldata;
DRWView *main_view = inst->effects->taa_view;
DRWView **views = inst->g_data->planar_views;
DRWView *main_view = stl->effects->taa_view;
DRWView **views = stl->g_data->planar_views;
/* Prepare views at the same time for faster culling. */
for (int i = 0; i < ref_count; i++) {
lightbake_planar_ensure_view(&planar_data[i], main_view, &views[i]);
@@ -840,15 +841,14 @@ static void render_reflections(void (*callback)(int face, EEVEE_BakeRenderData *
static void lightbake_render_world_face(int face, EEVEE_BakeRenderData *user_data)
{
EEVEE_Data *vedata = user_data->vedata;
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PassList *psl = user_data->vedata->psl;
GPUFrameBuffer **face_fb = user_data->face_fb;
/* For world probe, we don't need to clear the color buffer
* since we render the background directly. */
GPU_framebuffer_bind(face_fb[face]);
GPU_framebuffer_clear_depth(face_fb[face], 1.0f);
DRW_draw_pass(inst->probe_background);
DRW_draw_pass(psl->probe_background);
}
void EEVEE_lightbake_render_world(EEVEE_ViewLayerData * /*sldata*/,
@@ -864,10 +864,9 @@ void EEVEE_lightbake_render_world(EEVEE_ViewLayerData * /*sldata*/,
static void lightbake_render_scene_face(int face, EEVEE_BakeRenderData *user_data)
{
EEVEE_Data *vedata = user_data->vedata;
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_ViewLayerData *sldata = user_data->sldata;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_PassList *psl = user_data->vedata->psl;
EEVEE_PrivateData *g_data = user_data->vedata->stl->g_data;
DRWView **views = g_data->bake_views;
GPUFrameBuffer **face_fb = user_data->face_fb;
@@ -878,11 +877,11 @@ static void lightbake_render_scene_face(int face, EEVEE_BakeRenderData *user_dat
GPU_framebuffer_bind(face_fb[face]);
GPU_framebuffer_clear_depth(face_fb[face], 1.0f);
DRW_draw_pass(inst->depth_ps);
DRW_draw_pass(inst->probe_background);
DRW_draw_pass(inst->material_ps);
DRW_draw_pass(inst->material_sss_ps); /* Only output standard pass */
DRW_draw_pass(inst->transparent_pass);
DRW_draw_pass(psl->depth_ps);
DRW_draw_pass(psl->probe_background);
DRW_draw_pass(psl->material_ps);
DRW_draw_pass(psl->material_sss_ps); /* Only output standard pass */
DRW_draw_pass(psl->transparent_pass);
}
void EEVEE_lightbake_render_scene(EEVEE_ViewLayerData *sldata,
@@ -903,62 +902,65 @@ void EEVEE_lightbake_render_scene(EEVEE_ViewLayerData *sldata,
static void lightbake_render_scene_reflected(int layer, EEVEE_BakeRenderData *user_data)
{
EEVEE_Data *vedata = user_data->vedata;
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_ViewLayerData *sldata = user_data->sldata;
EEVEE_PassList *psl = vedata->psl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_LightProbesInfo *pinfo = sldata->probes;
GPU_framebuffer_ensure_config(&inst->planarref_fb,
{GPU_ATTACHMENT_TEXTURE_LAYER(inst->planar_depth, layer),
GPU_ATTACHMENT_TEXTURE_LAYER(inst->planar_pool, layer)});
GPU_framebuffer_ensure_config(&fbl->planarref_fb,
{GPU_ATTACHMENT_TEXTURE_LAYER(txl->planar_depth, layer),
GPU_ATTACHMENT_TEXTURE_LAYER(txl->planar_pool, layer)});
/* Use visibility info for this planar reflection. */
pinfo->vis_data = pinfo->planar_vis_tests[layer];
/* Avoid using the texture attached to framebuffer when rendering. */
/* XXX */
GPUTexture *tmp_planar_pool = inst->planar_pool;
GPUTexture *tmp_planar_depth = inst->planar_depth;
inst->planar_pool = e_data.planar_pool_placeholder;
inst->planar_depth = e_data.depth_array_placeholder;
GPUTexture *tmp_planar_pool = txl->planar_pool;
GPUTexture *tmp_planar_depth = txl->planar_depth;
txl->planar_pool = e_data.planar_pool_placeholder;
txl->planar_depth = e_data.depth_array_placeholder;
/* Be sure that cascaded shadow maps are updated. */
EEVEE_shadows_draw(sldata, vedata, inst->g_data->planar_views[layer]);
EEVEE_shadows_draw(sldata, vedata, stl->g_data->planar_views[layer]);
GPU_framebuffer_bind(inst->planarref_fb);
GPU_framebuffer_clear_depth(inst->planarref_fb, 1.0);
GPU_framebuffer_bind(fbl->planarref_fb);
GPU_framebuffer_clear_depth(fbl->planarref_fb, 1.0);
float prev_background_alpha = inst->g_data->background_alpha;
inst->g_data->background_alpha = 1.0f;
float prev_background_alpha = vedata->stl->g_data->background_alpha;
vedata->stl->g_data->background_alpha = 1.0f;
/* Slight modification: we handle refraction as normal
* shading and don't do SSRefraction. */
DRW_draw_pass(inst->depth_clip_ps);
DRW_draw_pass(inst->depth_refract_clip_ps);
DRW_draw_pass(psl->depth_clip_ps);
DRW_draw_pass(psl->depth_refract_clip_ps);
DRW_draw_pass(inst->probe_background);
DRW_draw_pass(psl->probe_background);
EEVEE_create_minmax_buffer(vedata, tmp_planar_depth, layer);
EEVEE_occlusion_compute(sldata, vedata);
GPU_framebuffer_bind(inst->planarref_fb);
GPU_framebuffer_bind(fbl->planarref_fb);
/* Shading pass */
DRW_draw_pass(inst->material_ps);
DRW_draw_pass(inst->material_sss_ps); /* Only output standard pass */
DRW_draw_pass(inst->material_refract_ps);
DRW_draw_pass(psl->material_ps);
DRW_draw_pass(psl->material_sss_ps); /* Only output standard pass */
DRW_draw_pass(psl->material_refract_ps);
/* Transparent */
if (DRW_state_is_image_render()) {
/* Do the reordering only for offline because it can be costly. */
DRW_pass_sort_shgroup_z(inst->transparent_pass);
DRW_pass_sort_shgroup_z(psl->transparent_pass);
}
DRW_draw_pass(inst->transparent_pass);
DRW_draw_pass(psl->transparent_pass);
/* Restore */
inst->planar_pool = tmp_planar_pool;
inst->planar_depth = tmp_planar_depth;
txl->planar_pool = tmp_planar_pool;
txl->planar_depth = tmp_planar_depth;
inst->g_data->background_alpha = prev_background_alpha;
vedata->stl->g_data->background_alpha = prev_background_alpha;
}
static void eevee_lightbake_render_scene_to_planars(EEVEE_ViewLayerData *sldata,
@@ -990,9 +992,9 @@ void EEVEE_lightbake_filter_glossy(EEVEE_ViewLayerData *sldata,
float filter_quality,
float firefly_fac)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PassList *psl = vedata->psl;
EEVEE_LightProbesInfo *pinfo = sldata->probes;
LightCache *light_cache = inst->g_data->light_cache;
LightCache *light_cache = vedata->stl->g_data->light_cache;
float target_size = float(GPU_texture_width(rt_color));
@@ -1061,7 +1063,7 @@ void EEVEE_lightbake_filter_glossy(EEVEE_ViewLayerData *sldata,
GPU_ATTACHMENT_TEXTURE_MIP(light_cache->cube_tx.tex, i),
});
GPU_framebuffer_bind(fb);
DRW_draw_pass(inst->probe_glossy_compute);
DRW_draw_pass(psl->probe_glossy_compute);
mipsize /= 2;
CLAMP_MIN(mipsize, 1);
@@ -1075,9 +1077,9 @@ void EEVEE_lightbake_filter_diffuse(EEVEE_ViewLayerData *sldata,
int grid_offset,
float intensity)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PassList *psl = vedata->psl;
EEVEE_LightProbesInfo *pinfo = sldata->probes;
LightCache *light_cache = inst->g_data->light_cache;
LightCache *light_cache = vedata->stl->g_data->light_cache;
float target_size = float(GPU_texture_width(rt_color));
@@ -1116,7 +1118,7 @@ void EEVEE_lightbake_filter_diffuse(EEVEE_ViewLayerData *sldata,
&fb, {GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE_LAYER(light_cache->grid_tx.tex, 0)});
GPU_framebuffer_bind(fb);
GPU_framebuffer_viewport_set(fb, x, y, size[0], size[1]);
DRW_draw_pass(inst->probe_diffuse_compute);
DRW_draw_pass(psl->probe_diffuse_compute);
GPU_framebuffer_viewport_reset(fb);
}
@@ -1131,9 +1133,9 @@ void EEVEE_lightbake_filter_visibility(EEVEE_ViewLayerData *sldata,
float vis_blur,
int vis_size)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PassList *psl = vedata->psl;
EEVEE_LightProbesInfo *pinfo = sldata->probes;
LightCache *light_cache = inst->g_data->light_cache;
LightCache *light_cache = vedata->stl->g_data->light_cache;
pinfo->samples_len = 512.0f; /* TODO: refine. */
pinfo->shres = vis_size;
@@ -1153,51 +1155,51 @@ void EEVEE_lightbake_filter_visibility(EEVEE_ViewLayerData *sldata,
&fb, {GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE_LAYER(light_cache->grid_tx.tex, layer)});
GPU_framebuffer_bind(fb);
GPU_framebuffer_viewport_set(fb, x, y, vis_size, vis_size);
DRW_draw_pass(inst->probe_visibility_compute);
DRW_draw_pass(psl->probe_visibility_compute);
GPU_framebuffer_viewport_reset(fb);
}
/* Actually a simple down-sampling. */
static void downsample_planar(void *vedata, int level)
{
EEVEE_Data *ved = (EEVEE_Data *)vedata;
GOOENGINE_Instance *inst = ved->instance;
EEVEE_PassList *psl = ((EEVEE_Data *)vedata)->psl;
EEVEE_StorageList *stl = ((EEVEE_Data *)vedata)->stl;
const float *size = DRW_viewport_size_get();
copy_v2_v2(inst->g_data->planar_texel_size, size);
copy_v2_v2(stl->g_data->planar_texel_size, size);
for (int i = 0; i < level - 1; i++) {
inst->g_data->planar_texel_size[0] /= 2.0f;
inst->g_data->planar_texel_size[1] /= 2.0f;
min_ff(floorf(inst->g_data->planar_texel_size[0]), 1.0f);
min_ff(floorf(inst->g_data->planar_texel_size[1]), 1.0f);
stl->g_data->planar_texel_size[0] /= 2.0f;
stl->g_data->planar_texel_size[1] /= 2.0f;
min_ff(floorf(stl->g_data->planar_texel_size[0]), 1.0f);
min_ff(floorf(stl->g_data->planar_texel_size[1]), 1.0f);
}
invert_v2(inst->g_data->planar_texel_size);
invert_v2(stl->g_data->planar_texel_size);
DRW_draw_pass(inst->probe_planar_downsample_ps);
DRW_draw_pass(psl->probe_planar_downsample_ps);
}
static void EEVEE_lightbake_filter_planar(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_FramebufferList *fbl = vedata->fbl;
GPU_framebuffer_ensure_config(&inst->planar_downsample_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(inst->planar_pool)});
GPU_framebuffer_ensure_config(&fbl->planar_downsample_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(txl->planar_pool)});
GPU_framebuffer_recursive_downsample(
inst->planar_downsample_fb, MAX_SCREEN_BUFFERS_LOD_LEVEL, &downsample_planar, vedata);
fbl->planar_downsample_fb, MAX_SCREEN_BUFFERS_LOD_LEVEL, &downsample_planar, vedata);
}
/** \} */
void EEVEE_lightprobes_refresh_planar(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_CommonUniformBuffer *common_data = &sldata->common_data;
EEVEE_LightProbesInfo *pinfo = sldata->probes;
if (pinfo->num_planar == 0) {
/* Disable SSR if we cannot read previous frame */
common_data->ssr_toggle = inst->g_data->valid_double_buffer;
common_data->ssr_toggle = vedata->stl->g_data->valid_double_buffer;
common_data->prb_num_planar = 0;
return;
}
@@ -1211,7 +1213,7 @@ void EEVEE_lightprobes_refresh_planar(EEVEE_ViewLayerData *sldata, EEVEE_Data *v
common_data->ssrefract_toggle = false;
common_data->sss_toggle = false;
if (inst->g_data->disable_ligthprobes) {
if (vedata->stl->g_data->disable_ligthprobes) {
sldata->common_data.prb_num_render_cube = 1;
sldata->common_data.prb_num_render_grid = 1;
}
@@ -1239,25 +1241,24 @@ void EEVEE_lightprobes_refresh_planar(EEVEE_ViewLayerData *sldata, EEVEE_Data *v
copy_v2_v2(common_data->hiz_uv_scale, hiz_uv_scale_prev);
/* Prefilter for SSR */
if ((inst->effects->enabled_effects & EFFECT_SSR) != 0) {
if ((vedata->stl->effects->enabled_effects & EFFECT_SSR) != 0) {
EEVEE_lightbake_filter_planar(vedata);
}
if (DRW_state_is_image_render()) {
/* Sort the transparent passes because planar reflections could have re-sorted them. */
DRW_pass_sort_shgroup_z(inst->transparent_pass);
DRW_pass_sort_shgroup_z(vedata->psl->transparent_pass);
}
/* Disable SSR if we cannot read previous frame */
common_data->ssr_toggle = inst->g_data->valid_double_buffer;
common_data->ssr_toggle = vedata->stl->g_data->valid_double_buffer;
}
void EEVEE_lightprobes_refresh(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
const DRWContextState *draw_ctx = DRW_context_state_get();
const Scene *scene_eval = DEG_get_evaluated_scene(draw_ctx->depsgraph);
LightCache *light_cache = inst->g_data->light_cache;
LightCache *light_cache = vedata->stl->g_data->light_cache;
if ((light_cache->flag & LIGHTCACHE_UPDATE_WORLD) && (light_cache->flag & LIGHTCACHE_BAKED) == 0)
{
source/blender/draw/engines/gooengine/eevee_lights.cc
+1 -2
View File
@@ -251,13 +251,12 @@ void EEVEE_lights_cache_add(EEVEE_ViewLayerData *sldata, Object *ob)
void EEVEE_lights_cache_finish(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_LightsInfo *linfo = sldata->lights;
sldata->common_data.la_num_light = linfo->num_light;
/* Clamp volume lights power. */
float upper_bound = inst->effects->volume_light_clamp;
float upper_bound = vedata->stl->effects->volume_light_clamp;
for (int i = 0; i < linfo->num_light; i++) {
EEVEE_Light *evli = linfo->light_data + i;
source/blender/draw/engines/gooengine/eevee_lookdev.cc
+43 -39
View File
@@ -32,26 +32,27 @@
static void eevee_lookdev_lightcache_delete(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PrivateData *g_data = stl->g_data;
EEVEE_TextureList *txl = vedata->txl;
MEM_SAFE_FREE(inst->lookdev_lightcache);
MEM_SAFE_FREE(inst->lookdev_grid_data);
MEM_SAFE_FREE(inst->lookdev_cube_data);
DRW_TEXTURE_FREE_SAFE(inst->lookdev_grid_tx);
DRW_TEXTURE_FREE_SAFE(inst->lookdev_cube_tx);
MEM_SAFE_FREE(stl->lookdev_lightcache);
MEM_SAFE_FREE(stl->lookdev_grid_data);
MEM_SAFE_FREE(stl->lookdev_cube_data);
DRW_TEXTURE_FREE_SAFE(txl->lookdev_grid_tx);
DRW_TEXTURE_FREE_SAFE(txl->lookdev_cube_tx);
g_data->studiolight_index = -1;
g_data->studiolight_rot_z = 0.0f;
}
static void eevee_lookdev_hdri_preview_init(EEVEE_Data *vedata, EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PassList *psl = vedata->psl;
const DRWContextState *draw_ctx = DRW_context_state_get();
Scene *scene = draw_ctx->scene;
DRWShadingGroup *grp;
const EEVEE_EffectsInfo *effects = inst->effects;
const EEVEE_EffectsInfo *effects = vedata->stl->effects;
blender::gpu::Batch *sphere = DRW_cache_sphere_get(effects->sphere_lod);
int mat_options = VAR_MAT_MESH | VAR_MAT_LOOKDEV;
@@ -63,8 +64,8 @@ static void eevee_lookdev_hdri_preview_init(EEVEE_Data *vedata, EEVEE_ViewLayerD
GPUMaterial *gpumat = EEVEE_material_get(vedata, scene, ma, nullptr, mat_options);
GPUShader *sh = GPU_material_get_shader(gpumat);
DRW_PASS_CREATE(inst->lookdev_diffuse_pass, state);
grp = DRW_shgroup_create(sh, inst->lookdev_diffuse_pass);
DRW_PASS_CREATE(psl->lookdev_diffuse_pass, state);
grp = DRW_shgroup_create(sh, psl->lookdev_diffuse_pass);
EEVEE_material_bind_resources(
grp, gpumat, sldata, vedata, nullptr, nullptr, -1.0f, false, false);
DRW_shgroup_add_material_resources(grp, gpumat);
@@ -75,8 +76,8 @@ static void eevee_lookdev_hdri_preview_init(EEVEE_Data *vedata, EEVEE_ViewLayerD
GPUMaterial *gpumat = EEVEE_material_get(vedata, scene, ma, nullptr, mat_options);
GPUShader *sh = GPU_material_get_shader(gpumat);
DRW_PASS_CREATE(inst->lookdev_glossy_pass, state);
grp = DRW_shgroup_create(sh, inst->lookdev_glossy_pass);
DRW_PASS_CREATE(psl->lookdev_glossy_pass, state);
grp = DRW_shgroup_create(sh, psl->lookdev_glossy_pass);
EEVEE_material_bind_resources(
grp, gpumat, sldata, vedata, nullptr, nullptr, -1.0f, false, false);
DRW_shgroup_add_material_resources(grp, gpumat);
@@ -86,8 +87,8 @@ static void eevee_lookdev_hdri_preview_init(EEVEE_Data *vedata, EEVEE_ViewLayerD
void EEVEE_lookdev_init(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
const DRWContextState *draw_ctx = DRW_context_state_get();
/* The view will be nullptr when rendering previews. */
const View3D *v3d = draw_ctx->v3d;
@@ -134,7 +135,7 @@ void EEVEE_lookdev_init(EEVEE_Data *vedata)
effects->sphere_size = sphere_size;
effects->anchor[0] = rect->xmax;
effects->anchor[1] = rect->ymin;
inst->g_data->valid_double_buffer = false;
stl->g_data->valid_double_buffer = false;
EEVEE_temporal_sampling_reset(vedata);
}
}
@@ -146,9 +147,10 @@ void EEVEE_lookdev_cache_init(EEVEE_Data *vedata,
EEVEE_LightProbesInfo *pinfo,
DRWShadingGroup **r_shgrp)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_EffectsInfo *effects = stl->effects;
EEVEE_PrivateData *g_data = stl->g_data;
const DRWContextState *draw_ctx = DRW_context_state_get();
/* The view will be nullptr when rendering previews. */
const View3D *v3d = draw_ctx->v3d;
@@ -177,39 +179,39 @@ void EEVEE_lookdev_cache_init(EEVEE_Data *vedata,
int cube_res = scene_eval->eevee.gi_cubemap_resolution;
/* If one of the component is missing we start from scratch. */
if ((inst->lookdev_grid_data == nullptr) || (inst->lookdev_cube_data == nullptr) ||
(inst->lookdev_grid_tx == nullptr) || (inst->lookdev_cube_tx == nullptr) ||
if ((stl->lookdev_grid_data == nullptr) || (stl->lookdev_cube_data == nullptr) ||
(txl->lookdev_grid_tx == nullptr) || (txl->lookdev_cube_tx == nullptr) ||
(g_data->light_cache && g_data->light_cache->ref_res != cube_res))
{
eevee_lookdev_lightcache_delete(vedata);
}
if (inst->lookdev_lightcache == nullptr) {
if (stl->lookdev_lightcache == nullptr) {
#if defined(IRRADIANCE_SH_L2)
int grid_res = 4;
#elif defined(IRRADIANCE_HL2)
int grid_res = 4;
#endif
inst->lookdev_lightcache = EEVEE_lightcache_create(
stl->lookdev_lightcache = EEVEE_lightcache_create(
1, 1, cube_res, 8, blender::int3{grid_res, grid_res, 1});
/* XXX: Fix memleak. TODO: find out why. */
MEM_SAFE_FREE(inst->lookdev_cube_mips);
MEM_SAFE_FREE(stl->lookdev_cube_mips);
/* We do this to use a special light cache for lookdev.
* This light-cache needs to be per viewport. But we need to
* have correct freeing when the viewport is closed. So we
* need to reference all textures to the txl and the memblocks
* to the stl. */
inst->lookdev_grid_data = inst->lookdev_lightcache->grid_data;
inst->lookdev_cube_data = inst->lookdev_lightcache->cube_data;
inst->lookdev_cube_mips = inst->lookdev_lightcache->cube_mips;
inst->lookdev_grid_tx = inst->lookdev_lightcache->grid_tx.tex;
inst->lookdev_cube_tx = inst->lookdev_lightcache->cube_tx.tex;
stl->lookdev_grid_data = stl->lookdev_lightcache->grid_data;
stl->lookdev_cube_data = stl->lookdev_lightcache->cube_data;
stl->lookdev_cube_mips = stl->lookdev_lightcache->cube_mips;
txl->lookdev_grid_tx = stl->lookdev_lightcache->grid_tx.tex;
txl->lookdev_cube_tx = stl->lookdev_lightcache->cube_tx.tex;
}
g_data->light_cache = inst->lookdev_lightcache;
g_data->light_cache = stl->lookdev_lightcache;
DRWShadingGroup *grp = DRW_shgroup_create(shader, pass);
axis_angle_to_mat3_single(g_data->studiolight_matrix, 'Z', shading->studiolight_rot_z);
@@ -246,7 +248,7 @@ void EEVEE_lookdev_cache_init(EEVEE_Data *vedata,
float studiolight_blur = powf(shading->studiolight_blur, 2.5f);
DRW_shgroup_uniform_float_copy(grp, "backgroundAlpha", background_alpha);
DRW_shgroup_uniform_float_copy(grp, "studioLightBlur", studiolight_blur);
DRW_shgroup_uniform_texture(grp, "probeCubes", inst->lookdev_cube_tx);
DRW_shgroup_uniform_texture(grp, "probeCubes", txl->lookdev_cube_tx);
DRW_shgroup_uniform_float_copy(grp, "studioLightIntensity", 1.0f);
}
@@ -263,7 +265,7 @@ void EEVEE_lookdev_cache_init(EEVEE_Data *vedata,
g_data->studiolight_glossy_clamp != scene->eevee.gi_glossy_clamp ||
g_data->studiolight_filter_quality != scene->eevee.gi_filter_quality)
{
inst->lookdev_lightcache->flag |= LIGHTCACHE_UPDATE_WORLD;
stl->lookdev_lightcache->flag |= LIGHTCACHE_UPDATE_WORLD;
g_data->studiolight_index = sl->index;
copy_m3_m3(g_data->studiolight_matrix, studiolight_matrix);
g_data->studiolight_rot_z = shading->studiolight_rot_z;
@@ -294,13 +296,15 @@ static void eevee_lookdev_apply_taa(const EEVEE_EffectsInfo *effects,
void EEVEE_lookdev_draw(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = ((EEVEE_Data *)vedata)->stl;
EEVEE_EffectsInfo *effects = stl->effects;
EEVEE_ViewLayerData *sldata = EEVEE_view_layer_data_ensure();
const DRWContextState *draw_ctx = DRW_context_state_get();
if (inst->lookdev_diffuse_pass && eevee_hdri_preview_overlay_enabled(draw_ctx->v3d)) {
if (psl->lookdev_diffuse_pass && eevee_hdri_preview_overlay_enabled(draw_ctx->v3d)) {
/* Config renderer. */
EEVEE_CommonUniformBuffer *common = &sldata->common_data;
common->la_num_light = 0;
@@ -337,8 +341,8 @@ void EEVEE_lookdev_draw(EEVEE_Data *vedata)
DRW_view_set_active(effects->lookdev_view);
/* Find the right frame-buffers to render to. */
GPUFrameBuffer *fb = (effects->target_buffer == inst->effect_color_fb) ? inst->main_fb :
inst->effect_fb;
GPUFrameBuffer *fb = (effects->target_buffer == fbl->effect_color_fb) ? fbl->main_fb :
fbl->effect_fb;
GPU_framebuffer_bind(fb);
@@ -352,7 +356,7 @@ void EEVEE_lookdev_draw(EEVEE_Data *vedata)
effects->sphere_size,
effects->sphere_size);
DRW_draw_pass(inst->lookdev_diffuse_pass);
DRW_draw_pass(psl->lookdev_diffuse_pass);
offset[0] = (effects->sphere_size + sphere_margin) +
(sphere_margin + effects->sphere_size + sphere_margin);
@@ -362,7 +366,7 @@ void EEVEE_lookdev_draw(EEVEE_Data *vedata)
effects->sphere_size,
effects->sphere_size);
DRW_draw_pass(inst->lookdev_glossy_pass);
DRW_draw_pass(psl->lookdev_glossy_pass);
GPU_framebuffer_viewport_reset(fb);
source/blender/draw/engines/gooengine/eevee_materials.cc
+150 -146
View File
@@ -107,8 +107,6 @@ void EEVEE_material_bind_resources(DRWShadingGroup *shgrp,
bool use_ssrefraction,
bool use_alpha_blend)
{
GOOENGINE_Instance *inst = vedata->instance;
bool use_diffuse = GPU_material_flag_get(gpumat, GPU_MATFLAG_DIFFUSE);
bool use_glossy = GPU_material_flag_get(gpumat, GPU_MATFLAG_GLOSSY);
bool use_refract = GPU_material_flag_get(gpumat, GPU_MATFLAG_REFRACT);
@@ -121,9 +119,9 @@ void EEVEE_material_bind_resources(DRWShadingGroup *shgrp,
use_ssrefraction = true;
use_alpha_blend = true;
#endif
LightCache *lcache = inst->g_data->light_cache;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PrivateData *pd = inst->g_data;
LightCache *lcache = vedata->stl->g_data->light_cache;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
EEVEE_PrivateData *pd = vedata->stl->g_data;
DRW_shgroup_uniform_block(shgrp, "probe_block", sldata->probe_ubo);
DRW_shgroup_uniform_block(shgrp, "grid_block", sldata->grid_ubo);
@@ -175,14 +173,14 @@ void EEVEE_material_bind_resources(DRWShadingGroup *shgrp,
if (use_diffuse || use_glossy || use_refract || use_ao) {
#ifdef __APPLE__
if (inst->maxzbuffer != nullptr) {
DRW_shgroup_uniform_texture_ref(shgrp, "maxzBuffer", &inst->maxzbuffer);
if (&vedata->txl->maxzbuffer != nullptr) {
DRW_shgroup_uniform_texture_ref(shgrp, "maxzBuffer", &vedata->txl->maxzbuffer);
}
else {
DRW_shgroup_uniform_texture(shgrp, "maxzBuffer", e_data.util_tex);
}
#else
DRW_shgroup_uniform_texture_ref(shgrp, "maxzBuffer", &inst->maxzbuffer);
DRW_shgroup_uniform_texture_ref(shgrp, "maxzBuffer", &vedata->txl->maxzbuffer);
#endif
}
@@ -232,21 +230,21 @@ void EEVEE_material_bind_resources(DRWShadingGroup *shgrp,
if (use_glossy) {
#ifdef __APPLE__
if (inst->planar_pool != nullptr) {
DRW_shgroup_uniform_texture_ref(shgrp, "probePlanars", &inst->planar_pool);
if (vedata->txl->planar_pool != nullptr) {
DRW_shgroup_uniform_texture_ref(shgrp, "probePlanars", &vedata->txl->planar_pool);
}
else {
DRW_shgroup_uniform_texture(shgrp, "probePlanars", e_data.dummy_2d_array);
}
if (inst->planar_depth != nullptr) {
DRW_shgroup_uniform_texture_ref(shgrp, "planarDepth", &inst->planar_depth);
if (vedata->txl->planar_depth != nullptr) {
DRW_shgroup_uniform_texture_ref(shgrp, "planarDepth", &vedata->txl->planar_depth);
}
else {
DRW_shgroup_uniform_texture(shgrp, "planarDepth", e_data.dummy_2d_array);
}
#else
DRW_shgroup_uniform_texture_ref(shgrp, "probePlanars", &inst->planar_pool);
DRW_shgroup_uniform_texture_ref(shgrp, "planarDepth", &inst->planar_depth);
DRW_shgroup_uniform_texture_ref(shgrp, "probePlanars", &vedata->txl->planar_pool);
DRW_shgroup_uniform_texture_ref(shgrp, "planarDepth", &vedata->txl->planar_depth);
#endif
DRW_shgroup_uniform_int_copy(shgrp, "outputSsrId", ssr_id ? *ssr_id : 0);
}
@@ -260,16 +258,16 @@ void EEVEE_material_bind_resources(DRWShadingGroup *shgrp,
shgrp, "refractionDepth", (refract_depth) ? *refract_depth : 0.0);
if (use_ssrefraction) {
#ifdef __APPLE__
if (inst->filtered_radiance != nullptr) {
if (vedata->txl->filtered_radiance != nullptr) {
DRW_shgroup_uniform_texture_ref(
shgrp, "refractColorBuffer", &inst->filtered_radiance);
shgrp, "refractColorBuffer", &vedata->txl->filtered_radiance);
}
else {
DRW_shgroup_uniform_texture(shgrp, "refractColorBuffer", e_data.dummy_2d);
}
#else
DRW_shgroup_uniform_texture_ref(
shgrp, "refractColorBuffer", &inst->filtered_radiance);
shgrp, "refractColorBuffer", &vedata->txl->filtered_radiance);
#endif
}
}
@@ -405,24 +403,23 @@ static void eevee_init_util_texture()
MEM_freeN(texels);
}
void EEVEE_update_noise(EEVEE_Data *vedata, const double offsets[3])
void EEVEE_update_noise(EEVEE_PassList *psl, EEVEE_FramebufferList *fbl, const double offsets[3])
{
GOOENGINE_Instance *inst = vedata->instance;
e_data.noise_offsets[0] = offsets[0];
e_data.noise_offsets[1] = offsets[1];
e_data.noise_offsets[2] = offsets[2];
GPU_framebuffer_bind(inst->update_noise_fb);
DRW_draw_pass(inst->update_noise_pass);
GPU_framebuffer_bind(fbl->update_noise_fb);
DRW_draw_pass(psl->update_noise_pass);
}
void EEVEE_materials_init(EEVEE_ViewLayerData *sldata,
EEVEE_Data *vedata)
EEVEE_Data *vedata,
EEVEE_StorageList *stl,
EEVEE_FramebufferList *fbl)
{
GOOENGINE_Instance *inst = vedata->instance;
const DRWContextState *draw_ctx = DRW_context_state_get();
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_PrivateData *g_data = stl->g_data;
if (!e_data.util_tex) {
EEVEE_shaders_material_shaders_init();
@@ -464,13 +461,13 @@ void EEVEE_materials_init(EEVEE_ViewLayerData *sldata,
copy_v2_fl2(sldata->common_data.camera_uv_bias, 0.0f, 0.0f);
}
if (!DRW_state_is_image_render() && ((inst->effects->enabled_effects & EFFECT_TAA) == 0)) {
if (!DRW_state_is_image_render() && ((stl->effects->enabled_effects & EFFECT_TAA) == 0)) {
sldata->common_data.alpha_hash_offset = 0.0f;
sldata->common_data.alpha_hash_scale = 1.0f;
}
else {
double r;
BLI_halton_1d(5, 0.0, inst->effects->taa_current_sample - 1, &r);
BLI_halton_1d(5, 0.0, stl->effects->taa_current_sample - 1, &r);
sldata->common_data.alpha_hash_offset = float(r);
sldata->common_data.alpha_hash_scale = 0.01f;
}
@@ -478,7 +475,7 @@ void EEVEE_materials_init(EEVEE_ViewLayerData *sldata,
{
/* Update noise Frame-buffer. */
GPU_framebuffer_ensure_config(
&inst->update_noise_fb,
&fbl->update_noise_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE_LAYER(e_data.util_tex, 2)});
}
@@ -520,9 +517,9 @@ void EEVEE_materials_init(EEVEE_ViewLayerData *sldata,
{
g_data->num_aovs_used = 0;
if ((inst->g_data->render_passes & EEVEE_RENDER_PASS_AOV) != 0) {
if ((stl->g_data->render_passes & EEVEE_RENDER_PASS_AOV) != 0) {
EEVEE_RenderPassData data = {true, true, true, true, true, false, false, true, 0};
if (inst->g_data->aov_hash == EEVEE_AOV_HASH_ALL) {
if (stl->g_data->aov_hash == EEVEE_AOV_HASH_ALL) {
ViewLayer *view_layer = draw_ctx->view_layer;
int aov_index = 0;
LISTBASE_FOREACH (ViewLayerAOV *, aov, &view_layer->aovs) {
@@ -546,7 +543,7 @@ void EEVEE_materials_init(EEVEE_ViewLayerData *sldata,
}
else {
/* Rendering a single AOV in the 3d viewport */
data.renderPassAOVActive = inst->g_data->aov_hash;
data.renderPassAOVActive = stl->g_data->aov_hash;
if (sldata->renderpass_ubo.aovs[0]) {
GPU_uniformbuf_update(sldata->renderpass_ubo.aovs[0], &data);
}
@@ -586,12 +583,13 @@ void EEVEE_materials_init(EEVEE_ViewLayerData *sldata,
void EEVEE_materials_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PassList *psl = ((EEVEE_Data *)vedata)->psl;
EEVEE_StorageList *stl = ((EEVEE_Data *)vedata)->stl;
const DRWContextState *draw_ctx = DRW_context_state_get();
/* Create Material #GHash. */
{
inst->g_data->material_hash = BLI_ghash_ptr_new("Eevee_material ghash");
stl->g_data->material_hash = BLI_ghash_ptr_new("Eevee_material ghash");
if (sldata->material_cache == nullptr) {
sldata->material_cache = BLI_memblock_create(sizeof(EeveeMaterialCache));
@@ -602,10 +600,10 @@ void EEVEE_materials_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
}
{
DRW_PASS_CREATE(inst->background_ps, DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_EQUAL);
DRW_PASS_CREATE(psl->background_ps, DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_EQUAL);
DRWShadingGroup *grp = nullptr;
EEVEE_lookdev_cache_init(vedata, sldata, inst->background_ps, nullptr, &grp);
EEVEE_lookdev_cache_init(vedata, sldata, psl->background_ps, nullptr, &grp);
if (grp == nullptr) {
Scene *scene = draw_ctx->scene;
@@ -619,8 +617,8 @@ void EEVEE_materials_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
const int options = VAR_WORLD_BACKGROUND;
GPUMaterial *gpumat = EEVEE_material_get(vedata, scene, nullptr, world, options);
grp = DRW_shgroup_material_create(gpumat, inst->background_ps);
DRW_shgroup_uniform_float(grp, "backgroundAlpha", &inst->g_data->background_alpha, 1);
grp = DRW_shgroup_material_create(gpumat, psl->background_ps);
DRW_shgroup_uniform_float(grp, "backgroundAlpha", &stl->g_data->background_alpha, 1);
}
DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
@@ -629,7 +627,7 @@ void EEVEE_materials_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
DRW_shgroup_uniform_block(grp, "planar_block", sldata->planar_ubo);
DRW_shgroup_uniform_block(grp, "light_block", sldata->light_ubo);
DRW_shgroup_uniform_block(grp, "shadow_block", sldata->shadow_ubo);
DRW_shgroup_uniform_block_ref(grp, "renderpass_block", &inst->g_data->renderpass_ubo);
DRW_shgroup_uniform_block_ref(grp, "renderpass_block", &stl->g_data->renderpass_ubo);
DRW_shgroup_uniform_texture(grp, "utilTex", e_data.util_tex);
DRW_shgroup_uniform_texture_ref(grp, "shadowCubeTexture", &sldata->shadow_cube_pool);
DRW_shgroup_uniform_texture_ref(grp, "shadowCascadeTexture", &sldata->shadow_cascade_pool);
@@ -639,8 +637,8 @@ void EEVEE_materials_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
DRW_shgroup_uniform_texture_ref(
grp, "shadowCascadeIDTexture", &sldata->shadow_cascade_id_pool);
GPUTexture *scatter_tex = inst->effects->volume_scatter;
GPUTexture *transmit_tex = inst->effects->volume_transmit;
GPUTexture *scatter_tex = stl->effects->volume_scatter;
GPUTexture *transmit_tex = stl->effects->volume_transmit;
if (!scatter_tex) {
GPUTexture *dummy = EEVEE_volumes_get_dummy_scatter();
scatter_tex = dummy ? dummy : e_data.dummy_3d;
@@ -652,27 +650,27 @@ void EEVEE_materials_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
DRW_shgroup_uniform_texture(grp, "inScattering", scatter_tex);
DRW_shgroup_uniform_texture(grp, "inTransmittance", transmit_tex);
#endif
DRW_shgroup_uniform_texture_ref(grp, "probePlanars", &inst->planar_pool);
DRW_shgroup_uniform_texture_ref(grp, "probeCubes", &inst->g_data->light_cache->cube_tx.tex);
DRW_shgroup_uniform_texture_ref(grp, "irradianceGrid", &inst->g_data->light_cache->grid_tx.tex);
DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &inst->maxzbuffer);
DRW_shgroup_uniform_texture_ref(grp, "probePlanars", &vedata->txl->planar_pool);
DRW_shgroup_uniform_texture_ref(grp, "probeCubes", &stl->g_data->light_cache->cube_tx.tex);
DRW_shgroup_uniform_texture_ref(grp, "irradianceGrid", &stl->g_data->light_cache->grid_tx.tex);
DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &vedata->txl->maxzbuffer);
DRW_shgroup_call(grp, DRW_cache_fullscreen_quad_get(), nullptr);
}
#define EEVEE_PASS_CREATE(pass, state) \
do { \
DRW_PASS_CREATE(inst->pass##_ps, state); \
DRW_PASS_CREATE(inst->pass##_cull_ps, state | DRW_STATE_CULL_BACK); \
DRW_pass_link(inst->pass##_ps, inst->pass##_cull_ps); \
DRW_PASS_CREATE(psl->pass##_ps, state); \
DRW_PASS_CREATE(psl->pass##_cull_ps, state | DRW_STATE_CULL_BACK); \
DRW_pass_link(psl->pass##_ps, psl->pass##_cull_ps); \
} while (0)
#define EEVEE_CLIP_PASS_CREATE(pass, state) \
do { \
DRWState st = state | DRW_STATE_CLIP_PLANES; \
DRW_PASS_INSTANCE_CREATE(inst->pass##_clip_ps, inst->pass##_ps, st); \
DRW_PASS_INSTANCE_CREATE(psl->pass##_clip_ps, psl->pass##_ps, st); \
DRW_PASS_INSTANCE_CREATE( \
inst->pass##_clip_cull_ps, inst->pass##_cull_ps, st | DRW_STATE_CULL_BACK); \
DRW_pass_link(inst->pass##_clip_ps, inst->pass##_clip_cull_ps); \
psl->pass##_clip_cull_ps, psl->pass##_cull_ps, st | DRW_STATE_CULL_BACK); \
DRW_pass_link(psl->pass##_clip_ps, psl->pass##_clip_cull_ps); \
} while (0)
{
@@ -695,10 +693,10 @@ void EEVEE_materials_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_EQUAL | DRW_STATE_BLEND_ADD_FULL;
/* Create an instance of each of these passes and link them together. */
DRWPass *passes[] = {
inst->material_ps,
inst->material_cull_ps,
inst->material_sss_ps,
inst->material_sss_cull_ps,
psl->material_ps,
psl->material_cull_ps,
psl->material_sss_ps,
psl->material_sss_cull_ps,
};
DRWPass *first = nullptr, *last = nullptr;
for (int i = 0; i < ARRAY_SIZE(passes); i++) {
@@ -711,19 +709,19 @@ void EEVEE_materials_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
last = pass;
}
}
inst->material_accum_ps = first;
psl->material_accum_ps = first;
/* Same for background */
DRW_PASS_INSTANCE_CREATE(inst->background_accum_ps, inst->background_ps, state);
DRW_PASS_INSTANCE_CREATE(psl->background_accum_ps, psl->background_ps, state);
}
{
DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_CLIP_PLANES;
DRW_PASS_CREATE(inst->transparent_pass, state);
DRW_PASS_CREATE(psl->transparent_pass, state);
}
{
DRW_PASS_CREATE(inst->update_noise_pass, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->update_noise_pass, DRW_STATE_WRITE_COLOR);
GPUShader *sh = EEVEE_shaders_update_noise_sh_get();
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->update_noise_pass);
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->update_noise_pass);
DRW_shgroup_uniform_texture(grp, "blueNoise", e_data.noise_tex);
DRW_shgroup_uniform_vec3(grp, "offsets", e_data.noise_offsets, 1);
DRW_shgroup_call(grp, DRW_cache_fullscreen_quad_get(), nullptr);
@@ -736,8 +734,8 @@ BLI_INLINE void material_shadow(EEVEE_Data *vedata,
bool is_hair,
EeveeMaterialCache *emc)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *pd = inst->g_data;
EEVEE_PrivateData *pd = vedata->stl->g_data;
EEVEE_PassList *psl = vedata->psl;
const DRWContextState *draw_ctx = DRW_context_state_get();
Scene *scene = draw_ctx->scene;
@@ -771,7 +769,7 @@ BLI_INLINE void material_shadow(EEVEE_Data *vedata,
DRW_shgroup_uniform_float_copy(grp, "alphaClipThreshold", alpha_clip_threshold);
}
else {
*grp_p = grp = DRW_shgroup_create(sh, inst->shadow_pass);
*grp_p = grp = DRW_shgroup_create(sh, psl->shadow_pass);
EEVEE_material_bind_resources(
grp, gpumat, sldata, vedata, nullptr, nullptr, alpha_clip_threshold, false, false);
}
@@ -792,9 +790,9 @@ static EeveeMaterialCache material_opaque(EEVEE_Data *vedata,
Material *ma,
const bool is_hair)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PrivateData *pd = inst->g_data;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
EEVEE_PrivateData *pd = vedata->stl->g_data;
EEVEE_PassList *psl = vedata->psl;
const DRWContextState *draw_ctx = DRW_context_state_get();
Scene *scene = draw_ctx->scene;
@@ -832,10 +830,10 @@ static EeveeMaterialCache material_opaque(EEVEE_Data *vedata,
SET_FLAG_FROM_TEST(option, do_cull, KEY_CULL);
SET_FLAG_FROM_TEST(option, use_ssrefract, KEY_REFRACT);
DRWPass *depth_ps = std::array{
inst->depth_ps,
inst->depth_cull_ps,
inst->depth_refract_ps,
inst->depth_refract_cull_ps,
psl->depth_ps,
psl->depth_cull_ps,
psl->depth_refract_ps,
psl->depth_refract_cull_ps,
}[option];
/* Hair are rendered inside the non-cull pass but needs to have a separate cache key. */
SET_FLAG_FROM_TEST(option, is_hair, KEY_HAIR);
@@ -874,12 +872,12 @@ static EeveeMaterialCache material_opaque(EEVEE_Data *vedata,
int ssr_id = (((effects->enabled_effects & EFFECT_SSR) != 0) && !use_ssrefract) ? 1 : 0;
int option = (use_ssrefract ? 0 : (use_sss ? 1 : 2)) * 2 + do_cull;
DRWPass *shading_pass = std::array{
inst->material_refract_ps,
inst->material_refract_cull_ps,
inst->material_sss_ps,
inst->material_sss_cull_ps,
inst->material_ps,
inst->material_cull_ps,
psl->material_refract_ps,
psl->material_refract_cull_ps,
psl->material_sss_ps,
psl->material_sss_cull_ps,
psl->material_ps,
psl->material_cull_ps,
}[option];
/* Hair are rendered inside the non-cull pass but needs to have a separate cache key */
option = option * 2 + is_hair;
@@ -933,9 +931,9 @@ static EeveeMaterialCache material_transparent(EEVEE_Data *vedata,
Material *ma)
{
const DRWContextState *draw_ctx = DRW_context_state_get();
GOOENGINE_Instance *inst = vedata->instance;
Scene *scene = draw_ctx->scene;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
EeveeMaterialCache emc = {nullptr};
const bool do_cull = (ma->blend_flag & MA_BL_CULL_BACKFACE) != 0;
@@ -957,7 +955,7 @@ static EeveeMaterialCache material_transparent(EEVEE_Data *vedata,
GPUMaterial *gpumat = EEVEE_material_get(vedata, scene, ma, nullptr, mat_options);
GPUShader *sh = GPU_material_get_shader(gpumat);
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->transparent_pass);
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->transparent_pass);
EEVEE_material_bind_resources(
grp, gpumat, sldata, vedata, nullptr, nullptr, -1.0f, false, true);
@@ -979,7 +977,7 @@ static EeveeMaterialCache material_transparent(EEVEE_Data *vedata,
GPUMaterial *gpumat = EEVEE_material_get(vedata, scene, ma, nullptr, mat_options);
DRWShadingGroup *grp = DRW_shgroup_create(GPU_material_get_shader(gpumat),
inst->transparent_pass);
psl->transparent_pass);
EEVEE_material_bind_resources(
grp, gpumat, sldata, vedata, &ssr_id, &ma->refract_depth, -1.0f, use_ssrefract, true);
@@ -1238,9 +1236,8 @@ void EEVEE_object_curves_cache_populate(EEVEE_Data *vedata,
void EEVEE_materials_cache_finish(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *pd = inst->g_data;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PrivateData *pd = vedata->stl->g_data;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
BLI_ghash_free(pd->material_hash, nullptr, nullptr);
pd->material_hash = nullptr;
@@ -1260,8 +1257,7 @@ void EEVEE_materials_free()
void EEVEE_material_renderpasses_init(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *pd = inst->g_data;
EEVEE_PrivateData *pd = vedata->stl->g_data;
/* For diffuse and glossy we calculate the final light + color buffer where we extract the
* light from by dividing by the color buffer. When one the light is requested we also tag
@@ -1281,40 +1277,42 @@ static void material_renderpass_init(GPUTexture **output_tx, const eGPUTextureFo
void EEVEE_material_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, uint tot_samples)
{
EEVEE_FramebufferList *fbl = vedata->fbl;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PrivateData *pd = inst->g_data;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
EEVEE_PrivateData *pd = stl->g_data;
/* Should be enough precision for many samples. */
const eGPUTextureFormat texture_format = (tot_samples > 128) ? GPU_RGBA32F : GPU_RGBA16F;
/* Create FrameBuffer. */
GPU_framebuffer_ensure_config(&inst->material_accum_fb,
GPU_framebuffer_ensure_config(&fbl->material_accum_fb,
{GPU_ATTACHMENT_TEXTURE(dtxl->depth), GPU_ATTACHMENT_LEAVE});
if (pd->render_passes & EEVEE_RENDER_PASS_ENVIRONMENT) {
material_renderpass_init(&inst->env_accum, texture_format);
material_renderpass_init(&txl->env_accum, texture_format);
}
if (pd->render_passes & EEVEE_RENDER_PASS_EMIT) {
material_renderpass_init(&inst->emit_accum, texture_format);
material_renderpass_init(&txl->emit_accum, texture_format);
}
if (pd->render_passes & EEVEE_RENDER_PASS_DIFFUSE_COLOR) {
material_renderpass_init(&inst->diff_color_accum, texture_format);
material_renderpass_init(&txl->diff_color_accum, texture_format);
}
if (pd->render_passes & EEVEE_RENDER_PASS_DIFFUSE_LIGHT) {
material_renderpass_init(&inst->diff_light_accum, texture_format);
material_renderpass_init(&txl->diff_light_accum, texture_format);
}
if (pd->render_passes & EEVEE_RENDER_PASS_SPECULAR_COLOR) {
material_renderpass_init(&inst->spec_color_accum, texture_format);
material_renderpass_init(&txl->spec_color_accum, texture_format);
}
if (pd->render_passes & EEVEE_RENDER_PASS_AOV) {
for (int aov_index = 0; aov_index < pd->num_aovs_used; aov_index++) {
material_renderpass_init(&inst->aov_surface_accum[aov_index], texture_format);
material_renderpass_init(&txl->aov_surface_accum[aov_index], texture_format);
}
}
if (pd->render_passes & EEVEE_RENDER_PASS_SPECULAR_LIGHT) {
material_renderpass_init(&inst->spec_light_accum, texture_format);
material_renderpass_init(&txl->spec_light_accum, texture_format);
if (effects->enabled_effects & EFFECT_SSR) {
EEVEE_reflection_output_init(sldata, vedata, tot_samples);
@@ -1323,19 +1321,19 @@ void EEVEE_material_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata,
}
static void material_renderpass_accumulate(EEVEE_EffectsInfo *effects,
GOOENGINE_Instance *inst,
EEVEE_FramebufferList *fbl,
DRWPass *renderpass,
DRWPass *renderpass2,
EEVEE_PrivateData *pd,
GPUTexture *output_tx,
GPUUniformBuf *renderpass_option_ubo)
{
GPU_framebuffer_texture_attach(inst->material_accum_fb, output_tx, 0, 0);
GPU_framebuffer_bind(inst->material_accum_fb);
GPU_framebuffer_texture_attach(fbl->material_accum_fb, output_tx, 0, 0);
GPU_framebuffer_bind(fbl->material_accum_fb);
if (effects->taa_current_sample == 1) {
const float clear[4] = {0.0f, 0.0f, 0.0f, 0.0f};
GPU_framebuffer_clear_color(inst->material_accum_fb, clear);
GPU_framebuffer_clear_color(fbl->material_accum_fb, clear);
}
pd->renderpass_ubo = renderpass_option_ubo;
@@ -1344,52 +1342,54 @@ static void material_renderpass_accumulate(EEVEE_EffectsInfo *effects,
DRW_draw_pass(renderpass2);
}
GPU_framebuffer_texture_detach(inst->material_accum_fb, output_tx);
GPU_framebuffer_texture_detach(fbl->material_accum_fb, output_tx);
}
void EEVEE_material_output_accumulate(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *pd = inst->g_data;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_PassList *psl = vedata->psl;
EEVEE_PrivateData *pd = vedata->stl->g_data;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
EEVEE_TextureList *txl = vedata->txl;
if (inst->material_accum_fb != nullptr) {
DRWPass *material_accum_ps = inst->material_accum_ps;
DRWPass *background_accum_ps = inst->background_accum_ps;
if (fbl->material_accum_fb != nullptr) {
DRWPass *material_accum_ps = psl->material_accum_ps;
DRWPass *background_accum_ps = psl->background_accum_ps;
if (pd->render_passes & EEVEE_RENDER_PASS_ENVIRONMENT) {
material_renderpass_accumulate(effects,
inst,
fbl,
background_accum_ps,
nullptr,
pd,
inst->env_accum,
txl->env_accum,
sldata->renderpass_ubo.environment);
}
if (pd->render_passes & EEVEE_RENDER_PASS_EMIT) {
material_renderpass_accumulate(effects,
inst,
fbl,
material_accum_ps,
nullptr,
pd,
inst->emit_accum,
txl->emit_accum,
sldata->renderpass_ubo.emit);
}
if (pd->render_passes & EEVEE_RENDER_PASS_DIFFUSE_COLOR) {
material_renderpass_accumulate(effects,
inst,
fbl,
material_accum_ps,
nullptr,
pd,
inst->diff_color_accum,
txl->diff_color_accum,
sldata->renderpass_ubo.diff_color);
}
if (pd->render_passes & EEVEE_RENDER_PASS_DIFFUSE_LIGHT) {
material_renderpass_accumulate(effects,
inst,
fbl,
material_accum_ps,
nullptr,
pd,
inst->diff_light_accum,
txl->diff_light_accum,
sldata->renderpass_ubo.diff_light);
if (effects->enabled_effects & EFFECT_SSS) {
@@ -1404,11 +1404,11 @@ void EEVEE_material_output_accumulate(EEVEE_ViewLayerData *sldata, EEVEE_Data *v
GPU_uniformbuf_update(sldata->common_ubo, &sldata->common_data);
}
material_renderpass_accumulate(effects,
inst,
fbl,
material_accum_ps,
nullptr,
pd,
inst->spec_color_accum,
txl->spec_color_accum,
sldata->renderpass_ubo.spec_color);
if (prev_ssr) {
sldata->common_data.ssr_toggle = prev_ssr;
@@ -1417,11 +1417,11 @@ void EEVEE_material_output_accumulate(EEVEE_ViewLayerData *sldata, EEVEE_Data *v
}
if (pd->render_passes & EEVEE_RENDER_PASS_SPECULAR_LIGHT) {
material_renderpass_accumulate(effects,
inst,
fbl,
material_accum_ps,
nullptr,
pd,
inst->spec_light_accum,
txl->spec_light_accum,
sldata->renderpass_ubo.spec_light);
if (effects->enabled_effects & EFFECT_SSR) {
@@ -1431,58 +1431,60 @@ void EEVEE_material_output_accumulate(EEVEE_ViewLayerData *sldata, EEVEE_Data *v
if (pd->render_passes & EEVEE_RENDER_PASS_AOV) {
for (int aov_index = 0; aov_index < pd->num_aovs_used; aov_index++) {
material_renderpass_accumulate(effects,
inst,
fbl,
material_accum_ps,
background_accum_ps,
pd,
inst->aov_surface_accum[aov_index],
txl->aov_surface_accum[aov_index],
sldata->renderpass_ubo.aovs[aov_index]);
}
}
/* Free unused aov textures. */
for (int aov_index = pd->num_aovs_used; aov_index < MAX_AOVS; aov_index++) {
DRW_TEXTURE_FREE_SAFE(inst->aov_surface_accum[aov_index]);
DRW_TEXTURE_FREE_SAFE(txl->aov_surface_accum[aov_index]);
}
/* Restore default. */
pd->renderpass_ubo = sldata->renderpass_ubo.combined;
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}
void EEVEE_material_transparent_output_init(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *pd = inst->g_data;
EEVEE_PassList *psl = vedata->psl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_PrivateData *pd = vedata->stl->g_data;
EEVEE_TextureList *txl = vedata->txl;
if (pd->render_passes & EEVEE_RENDER_PASS_TRANSPARENT) {
/* Intermediate result to blend objects on. */
eGPUTextureUsage usage = GPU_TEXTURE_USAGE_SHADER_READ | GPU_TEXTURE_USAGE_ATTACHMENT;
DRW_texture_ensure_fullscreen_2d_ex(
&inst->transparent_depth_tmp, GPU_DEPTH24_STENCIL8, usage, DRWTextureFlag(0));
&txl->transparent_depth_tmp, GPU_DEPTH24_STENCIL8, usage, DRWTextureFlag(0));
DRW_texture_ensure_fullscreen_2d_ex(
&inst->transparent_color_tmp, GPU_RGBA16F, usage, DRWTextureFlag(0));
GPU_framebuffer_ensure_config(&inst->transparent_rpass_fb,
{GPU_ATTACHMENT_TEXTURE(inst->transparent_depth_tmp),
GPU_ATTACHMENT_TEXTURE(inst->transparent_color_tmp)});
&txl->transparent_color_tmp, GPU_RGBA16F, usage, DRWTextureFlag(0));
GPU_framebuffer_ensure_config(&fbl->transparent_rpass_fb,
{GPU_ATTACHMENT_TEXTURE(txl->transparent_depth_tmp),
GPU_ATTACHMENT_TEXTURE(txl->transparent_color_tmp)});
/* Final result to with AntiAliasing. */
/* TODO mem usage. */
const eGPUTextureFormat texture_format = (true) ? GPU_RGBA32F : GPU_RGBA16F;
eGPUTextureUsage usage_accum = GPU_TEXTURE_USAGE_SHADER_READ | GPU_TEXTURE_USAGE_HOST_READ |
GPU_TEXTURE_USAGE_ATTACHMENT;
DRW_texture_ensure_fullscreen_2d_ex(
&inst->transparent_accum, texture_format, usage_accum, DRWTextureFlag(0));
&txl->transparent_accum, texture_format, usage_accum, DRWTextureFlag(0));
GPU_framebuffer_ensure_config(
&inst->transparent_rpass_accum_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(inst->transparent_accum)});
&fbl->transparent_rpass_accum_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(txl->transparent_accum)});
{
/* This pass Accumulate 1 sample of the transparent pass into the transparent
* accumulation buffer. */
DRW_PASS_CREATE(inst->transparent_accum_ps, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD_FULL);
DRW_PASS_CREATE(psl->transparent_accum_ps, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD_FULL);
DRWShadingGroup *grp = DRW_shgroup_create(EEVEE_shaders_renderpasses_accumulate_sh_get(),
inst->transparent_accum_ps);
DRW_shgroup_uniform_texture(grp, "inputBuffer", inst->transparent_color_tmp);
psl->transparent_accum_ps);
DRW_shgroup_uniform_texture(grp, "inputBuffer", txl->transparent_color_tmp);
DRW_shgroup_call(grp, DRW_cache_fullscreen_quad_get(), nullptr);
}
}
@@ -1490,9 +1492,11 @@ void EEVEE_material_transparent_output_init(EEVEE_Data *vedata)
void EEVEE_material_transparent_output_accumulate(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PrivateData *pd = inst->g_data;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_PassList *psl = vedata->psl;
EEVEE_PrivateData *pd = vedata->stl->g_data;
EEVEE_TextureList *txl = vedata->txl;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
if (pd->render_passes & EEVEE_RENDER_PASS_TRANSPARENT) {
@@ -1502,22 +1506,22 @@ void EEVEE_material_transparent_output_accumulate(EEVEE_Data *vedata)
/* Work on a copy of the depth texture to allow re-rendering
* the transparent object to the main pass. */
GPU_texture_copy(inst->transparent_depth_tmp, dtxl->depth);
GPU_texture_copy(txl->transparent_depth_tmp, dtxl->depth);
/* Render transparent objects on a black background. */
GPU_framebuffer_bind(inst->transparent_rpass_fb);
GPU_framebuffer_clear_color(inst->transparent_rpass_fb, clear);
DRW_draw_pass(inst->transparent_pass);
GPU_framebuffer_bind(fbl->transparent_rpass_fb);
GPU_framebuffer_clear_color(fbl->transparent_rpass_fb, clear);
DRW_draw_pass(psl->transparent_pass);
/* Accumulate the resulting color buffer. */
GPU_framebuffer_bind(inst->transparent_rpass_accum_fb);
GPU_framebuffer_bind(fbl->transparent_rpass_accum_fb);
if (effects->taa_current_sample == 1) {
GPU_framebuffer_clear_color(inst->transparent_rpass_accum_fb, clear);
GPU_framebuffer_clear_color(fbl->transparent_rpass_accum_fb, clear);
}
DRW_draw_pass(inst->transparent_accum_ps);
DRW_draw_pass(psl->transparent_accum_ps);
/* Restore default. */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}
source/blender/draw/engines/gooengine/eevee_mist.cc
+18 -14
View File
@@ -21,17 +21,20 @@
void EEVEE_mist_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
const DRWContextState *draw_ctx = DRW_context_state_get();
EEVEE_FramebufferList *fbl = vedata->fbl;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PassList *psl = vedata->psl;
EEVEE_PrivateData *g_data = stl->g_data;
Scene *scene = draw_ctx->scene;
/* Create FrameBuffer. */
/* Should be enough precision for many samples. */
DRW_texture_ensure_fullscreen_2d(&inst->mist_accum, GPU_R32F, DRWTextureFlag(0));
DRW_texture_ensure_fullscreen_2d(&txl->mist_accum, GPU_R32F, DRWTextureFlag(0));
GPU_framebuffer_ensure_config(&inst->mist_accum_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(inst->mist_accum)});
GPU_framebuffer_ensure_config(&fbl->mist_accum_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(txl->mist_accum)});
/* Mist settings. */
if (scene && scene->world) {
@@ -63,9 +66,9 @@ void EEVEE_mist_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
g_data->mist_falloff *= 0.5f;
/* Create Pass and shgroup. */
DRW_PASS_CREATE(inst->mist_accum_ps, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD);
DRW_PASS_CREATE(psl->mist_accum_ps, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD);
DRWShadingGroup *grp = DRW_shgroup_create(EEVEE_shaders_effect_mist_sh_get(),
inst->mist_accum_ps);
psl->mist_accum_ps);
DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
DRW_shgroup_uniform_block(grp, "renderpass_block", sldata->renderpass_ubo.combined);
@@ -75,21 +78,22 @@ void EEVEE_mist_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
void EEVEE_mist_output_accumulate(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_PassList *psl = vedata->psl;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
if (inst->mist_accum_fb != nullptr) {
GPU_framebuffer_bind(inst->mist_accum_fb);
if (fbl->mist_accum_fb != nullptr) {
GPU_framebuffer_bind(fbl->mist_accum_fb);
/* Clear texture. */
if (effects->taa_current_sample == 1) {
const float clear[4] = {0.0f, 0.0f, 0.0f, 0.0f};
GPU_framebuffer_clear_color(inst->mist_accum_fb, clear);
GPU_framebuffer_clear_color(fbl->mist_accum_fb, clear);
}
DRW_draw_pass(inst->mist_accum_ps);
DRW_draw_pass(psl->mist_accum_ps);
/* Restore */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}
source/blender/draw/engines/gooengine/eevee_motion_blur.cc
+59 -53
View File
@@ -39,8 +39,9 @@
int EEVEE_motion_blur_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_EffectsInfo *effects = stl->effects;
const DRWContextState *draw_ctx = DRW_context_state_get();
Scene *scene = draw_ctx->scene;
@@ -68,7 +69,7 @@ int EEVEE_motion_blur_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
eGPUTextureUsage usage = GPU_TEXTURE_USAGE_SHADER_READ | GPU_TEXTURE_USAGE_ATTACHMENT;
effects->velocity_tiles_x_tx = DRW_texture_pool_query_2d_ex(
tx_size[0], fs_size[1], GPU_RGBA16, usage, &draw_engine_eevee_type);
GPU_framebuffer_ensure_config(&inst->velocity_tiles_fb[0],
GPU_framebuffer_ensure_config(&fbl->velocity_tiles_fb[0],
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(effects->velocity_tiles_x_tx),
@@ -76,7 +77,7 @@ int EEVEE_motion_blur_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
effects->velocity_tiles_tx = DRW_texture_pool_query_2d_ex(
tx_size[0], tx_size[1], GPU_RGBA16, usage, &draw_engine_eevee_type);
GPU_framebuffer_ensure_config(&inst->velocity_tiles_fb[1],
GPU_framebuffer_ensure_config(&fbl->velocity_tiles_fb[1],
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(effects->velocity_tiles_tx),
@@ -89,15 +90,13 @@ int EEVEE_motion_blur_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
void EEVEE_motion_blur_step_set(EEVEE_Data *vedata, int step)
{
GOOENGINE_Instance *inst = vedata->instance;
BLI_assert(step < 3);
inst->effects->motion_blur_step = step;
vedata->stl->effects->motion_blur_step = step;
}
static void eevee_motion_blur_sync_camera(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
if (DRW_state_is_scene_render()) {
int mb_step = effects->motion_blur_step;
DRW_view_viewmat_get(nullptr, effects->motion_blur.camera[mb_step].viewmat, false);
@@ -111,8 +110,9 @@ static void eevee_motion_blur_sync_camera(EEVEE_Data *vedata)
void EEVEE_motion_blur_cache_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
EEVEE_MotionBlurData *mb_data = &effects->motion_blur;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
const DRWContextState *draw_ctx = DRW_context_state_get();
@@ -129,12 +129,12 @@ void EEVEE_motion_blur_cache_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *
DRWShadingGroup *grp;
{
DRW_PASS_CREATE(inst->velocity_tiles_x, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(inst->velocity_tiles, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->velocity_tiles_x, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->velocity_tiles, DRW_STATE_WRITE_COLOR);
/* Create max velocity tiles in 2 passes. One for X and one for Y */
GPUShader *sh = EEVEE_shaders_effect_motion_blur_velocity_tiles_sh_get();
grp = DRW_shgroup_create(sh, inst->velocity_tiles_x);
grp = DRW_shgroup_create(sh, psl->velocity_tiles_x);
DRW_shgroup_uniform_texture(grp, "velocityBuffer", effects->velocity_tx);
DRW_shgroup_uniform_ivec2_copy(
grp, "velocityBufferSize", blender::int2{int(fs_size[0]), int(fs_size[1])});
@@ -143,7 +143,7 @@ void EEVEE_motion_blur_cache_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *
DRW_shgroup_uniform_ivec2_copy(grp, "gatherStep", blender::int2{1, 0});
DRW_shgroup_call_procedural_triangles(grp, nullptr, 1);
grp = DRW_shgroup_create(sh, inst->velocity_tiles);
grp = DRW_shgroup_create(sh, psl->velocity_tiles);
DRW_shgroup_uniform_texture(grp, "velocityBuffer", effects->velocity_tiles_x_tx);
DRW_shgroup_uniform_ivec2_copy(
grp, "velocityBufferSize", blender::int2{tx_size[0], int(fs_size[1])});
@@ -151,12 +151,12 @@ void EEVEE_motion_blur_cache_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *
DRW_shgroup_call_procedural_triangles(grp, nullptr, 1);
/* Expand max tiles by keeping the max tile in each tile neighborhood. */
DRW_PASS_CREATE(inst->velocity_tiles_expand[0], DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(inst->velocity_tiles_expand[1], DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->velocity_tiles_expand[0], DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->velocity_tiles_expand[1], DRW_STATE_WRITE_COLOR);
for (int i = 0; i < 2; i++) {
GPUTexture *tile_tx = (i == 0) ? effects->velocity_tiles_tx : effects->velocity_tiles_x_tx;
GPUShader *sh_expand = EEVEE_shaders_effect_motion_blur_velocity_tiles_expand_sh_get();
grp = DRW_shgroup_create(sh_expand, inst->velocity_tiles_expand[i]);
grp = DRW_shgroup_create(sh_expand, psl->velocity_tiles_expand[i]);
DRW_shgroup_uniform_ivec2_copy(grp, "velocityBufferSize", tx_size);
DRW_shgroup_uniform_texture(grp, "velocityBuffer", tile_tx);
DRW_shgroup_uniform_vec2(grp, "viewportSize", DRW_viewport_size_get(), 1);
@@ -165,13 +165,13 @@ void EEVEE_motion_blur_cache_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *
}
}
{
DRW_PASS_CREATE(inst->motion_blur, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->motion_blur, DRW_STATE_WRITE_COLOR);
const GPUSamplerState state = GPUSamplerState::default_sampler();
int expand_steps = 1 + (max_ii(0, effects->motion_blur_max - 1) / EEVEE_VELOCITY_TILE_SIZE);
GPUTexture *tile_tx = (expand_steps & 1) ? effects->velocity_tiles_x_tx :
effects->velocity_tiles_tx;
grp = DRW_shgroup_create(EEVEE_shaders_effect_motion_blur_sh_get(), inst->motion_blur);
grp = DRW_shgroup_create(EEVEE_shaders_effect_motion_blur_sh_get(), psl->motion_blur);
DRW_shgroup_uniform_texture(grp, "utilTex", EEVEE_materials_get_util_tex());
DRW_shgroup_uniform_texture_ref_ex(grp, "colorBuffer", &effects->source_buffer, state);
DRW_shgroup_uniform_texture_ref_ex(grp, "depthBuffer", &dtxl->depth, state);
@@ -186,31 +186,31 @@ void EEVEE_motion_blur_cache_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *
DRW_shgroup_call_procedural_triangles(grp, nullptr, 1);
}
{
DRW_PASS_CREATE(inst->velocity_object, DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_EQUAL);
DRW_PASS_CREATE(psl->velocity_object, DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_EQUAL);
grp = DRW_shgroup_create(EEVEE_shaders_effect_motion_blur_object_sh_get(),
inst->velocity_object);
psl->velocity_object);
DRW_shgroup_uniform_mat4(grp, "prevViewProjMatrix", mb_data->camera[MB_PREV].persmat);
DRW_shgroup_uniform_mat4(grp, "currViewProjMatrix", mb_data->camera[MB_CURR].persmat);
DRW_shgroup_uniform_mat4(grp, "nextViewProjMatrix", mb_data->camera[MB_NEXT].persmat);
DRW_PASS_CREATE(inst->velocity_hair, DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_EQUAL);
DRW_PASS_CREATE(psl->velocity_hair, DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_EQUAL);
mb_data->hair_grp = grp = DRW_shgroup_create(EEVEE_shaders_effect_motion_blur_hair_sh_get(),
inst->velocity_hair);
psl->velocity_hair);
DRW_shgroup_uniform_mat4(grp, "prevViewProjMatrix", mb_data->camera[MB_PREV].persmat);
DRW_shgroup_uniform_mat4(grp, "currViewProjMatrix", mb_data->camera[MB_CURR].persmat);
DRW_shgroup_uniform_mat4(grp, "nextViewProjMatrix", mb_data->camera[MB_NEXT].persmat);
DRW_pass_link(inst->velocity_object, inst->velocity_hair);
DRW_pass_link(psl->velocity_object, psl->velocity_hair);
}
EEVEE_motion_blur_data_init(mb_data);
}
else {
inst->motion_blur = nullptr;
inst->velocity_object = nullptr;
inst->velocity_hair = nullptr;
psl->motion_blur = nullptr;
psl->velocity_object = nullptr;
psl->velocity_hair = nullptr;
}
}
@@ -220,11 +220,12 @@ void EEVEE_motion_blur_hair_cache_populate(EEVEE_ViewLayerData * /*sldata*/,
ParticleSystem *psys,
ModifierData *md)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
DRWShadingGroup *grp = nullptr;
if (!DRW_state_is_scene_render() || inst->velocity_hair == nullptr) {
if (!DRW_state_is_scene_render() || psl->velocity_hair == nullptr) {
return;
}
@@ -279,10 +280,11 @@ void EEVEE_motion_blur_curves_cache_populate(EEVEE_ViewLayerData * /*sldata*/,
Object *ob)
{
using namespace blender::draw;
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
if (!DRW_state_is_scene_render() || inst->velocity_hair == nullptr) {
if (!DRW_state_is_scene_render() || psl->velocity_hair == nullptr) {
return;
}
@@ -331,11 +333,12 @@ void EEVEE_motion_blur_cache_populate(EEVEE_ViewLayerData * /*sldata*/,
EEVEE_Data *vedata,
Object *ob)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
DRWShadingGroup *grp = nullptr;
if (!DRW_state_is_scene_render() || inst->velocity_object == nullptr) {
if (!DRW_state_is_scene_render() || psl->velocity_object == nullptr) {
return;
}
@@ -397,7 +400,7 @@ void EEVEE_motion_blur_cache_populate(EEVEE_ViewLayerData * /*sldata*/,
}
grp = DRW_shgroup_create(EEVEE_shaders_effect_motion_blur_object_sh_get(),
inst->velocity_object);
psl->velocity_object);
DRW_shgroup_uniform_mat4(grp, "prevModelMatrix", mb_data->obmat[MB_PREV]);
DRW_shgroup_uniform_mat4(grp, "currModelMatrix", mb_data->obmat[MB_CURR]);
DRW_shgroup_uniform_mat4(grp, "nextModelMatrix", mb_data->obmat[MB_NEXT]);
@@ -433,8 +436,8 @@ static void motion_blur_remove_vbo_reference_from_batch(blender::gpu::Batch *bat
void EEVEE_motion_blur_cache_finish(EEVEE_Data *vedata)
{
using namespace blender::draw;
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
GHashIterator ghi;
if ((effects->enabled_effects & EFFECT_MOTION_BLUR) == 0) {
@@ -449,7 +452,7 @@ void EEVEE_motion_blur_cache_finish(EEVEE_Data *vedata)
/* Need to be called after #DRW_render_instance_buffer_finish() */
/* Also we weed to have a correct FBO bound for #DRW_curves_update. */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(vedata->fbl->main_fb);
DRW_curves_update(*DRW_manager_get());
@@ -552,8 +555,8 @@ void EEVEE_motion_blur_cache_finish(EEVEE_Data *vedata)
void EEVEE_motion_blur_swap_data(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
GHashIterator ghi;
@@ -628,39 +631,42 @@ void EEVEE_motion_blur_swap_data(EEVEE_Data *vedata)
void EEVEE_motion_blur_draw(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
/* Motion Blur */
if ((effects->enabled_effects & EFFECT_MOTION_BLUR) != 0) {
/* Create velocity max tiles in 2 passes. One for each dimension. */
GPU_framebuffer_bind(inst->velocity_tiles_fb[0]);
DRW_draw_pass(inst->velocity_tiles_x);
GPU_framebuffer_bind(fbl->velocity_tiles_fb[0]);
DRW_draw_pass(psl->velocity_tiles_x);
GPU_framebuffer_bind(inst->velocity_tiles_fb[1]);
DRW_draw_pass(inst->velocity_tiles);
GPU_framebuffer_bind(fbl->velocity_tiles_fb[1]);
DRW_draw_pass(psl->velocity_tiles);
/* Expand the tiles by reading the neighborhood. Do as many passes as required. */
int buf = 0;
for (int i = effects->motion_blur_max; i > 0; i -= EEVEE_VELOCITY_TILE_SIZE) {
GPU_framebuffer_bind(inst->velocity_tiles_fb[buf]);
GPU_framebuffer_bind(fbl->velocity_tiles_fb[buf]);
/* Change viewport to avoid invoking more pixel shaders than necessary since in one of the
* buffer the texture is way bigger in height. This avoid creating another texture and
* reduce VRAM usage. */
int w = GPU_texture_width(effects->velocity_tiles_tx);
int h = GPU_texture_height(effects->velocity_tiles_tx);
GPU_framebuffer_viewport_set(inst->velocity_tiles_fb[buf], 0, 0, w, h);
GPU_framebuffer_viewport_set(fbl->velocity_tiles_fb[buf], 0, 0, w, h);
DRW_draw_pass(inst->velocity_tiles_expand[buf]);
DRW_draw_pass(psl->velocity_tiles_expand[buf]);
GPU_framebuffer_viewport_reset(inst->velocity_tiles_fb[buf]);
GPU_framebuffer_viewport_reset(fbl->velocity_tiles_fb[buf]);
buf = buf ? 0 : 1;
}
GPU_framebuffer_bind(effects->target_buffer);
DRW_draw_pass(inst->motion_blur);
DRW_draw_pass(psl->motion_blur);
SWAP_BUFFERS();
}
}
source/blender/draw/engines/gooengine/eevee_occlusion.cc
+52 -42
View File
@@ -28,9 +28,10 @@ static struct {
int EEVEE_occlusion_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_CommonUniformBuffer *common_data = &sldata->common_data;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
const DRWContextState *draw_ctx = DRW_context_state_get();
const Scene *scene_eval = DEG_get_evaluated_scene(draw_ctx->depsgraph);
@@ -43,7 +44,7 @@ int EEVEE_occlusion_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
}
if (scene_eval->eevee.flag & SCE_EEVEE_GTAO_ENABLED ||
inst->g_data->render_passes & EEVEE_RENDER_PASS_AO)
stl->g_data->render_passes & EEVEE_RENDER_PASS_AO)
{
const float *viewport_size = DRW_viewport_size_get();
const int fs_size[2] = {int(viewport_size[0]), int(viewport_size[1])};
@@ -68,14 +69,14 @@ int EEVEE_occlusion_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
effects->gtao_horizons_renderpass = DRW_texture_pool_query_2d_ex(
UNPACK2(effects->hiz_size), GPU_RGBA8, usage, &draw_engine_eevee_type);
GPU_framebuffer_ensure_config(
&inst->gtao_fb,
&fbl->gtao_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(effects->gtao_horizons_renderpass)});
if (G.debug_value == 6) {
effects->gtao_horizons_debug = DRW_texture_pool_query_2d(
UNPACK2(fs_size), GPU_RGBA8, &draw_engine_eevee_type);
GPU_framebuffer_ensure_config(
&inst->gtao_debug_fb,
&fbl->gtao_debug_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(effects->gtao_horizons_debug)});
}
else {
@@ -92,7 +93,7 @@ int EEVEE_occlusion_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
/* Cleanup */
effects->gtao_horizons_renderpass = e_data.dummy_horizon_tx;
effects->gtao_horizons = e_data.dummy_horizon_tx;
GPU_FRAMEBUFFER_FREE_SAFE(inst->gtao_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->gtao_fb);
common_data->ao_settings = 0.0f;
return 0;
@@ -100,26 +101,29 @@ int EEVEE_occlusion_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
void EEVEE_occlusion_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, uint tot_samples)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PassList *psl = vedata->psl;
EEVEE_EffectsInfo *effects = stl->effects;
const eGPUTextureFormat texture_format = (tot_samples > 128) ? GPU_R32F : GPU_R16F;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
/* Should be enough precision for many samples. */
DRW_texture_ensure_fullscreen_2d(&inst->ao_accum, texture_format, DRWTextureFlag(0));
DRW_texture_ensure_fullscreen_2d(&txl->ao_accum, texture_format, DRWTextureFlag(0));
GPU_framebuffer_ensure_config(&inst->ao_accum_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(inst->ao_accum)});
GPU_framebuffer_ensure_config(&fbl->ao_accum_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(txl->ao_accum)});
/* Accumulation pass */
DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD;
DRW_PASS_CREATE(inst->ao_accum_ps, state);
DRW_PASS_CREATE(psl->ao_accum_ps, state);
DRWShadingGroup *grp = DRW_shgroup_create(EEVEE_shaders_effect_ambient_occlusion_debug_sh_get(),
inst->ao_accum_ps);
psl->ao_accum_ps);
DRW_shgroup_uniform_texture(grp, "utilTex", EEVEE_materials_get_util_tex());
DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &inst->maxzbuffer);
DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &txl->maxzbuffer);
DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
DRW_shgroup_uniform_texture_ref(grp, "normalBuffer", &effects->ssr_normal_input);
DRW_shgroup_uniform_texture_ref(grp, "horizonBuffer", &effects->gtao_horizons_renderpass);
@@ -130,8 +134,10 @@ void EEVEE_occlusion_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata
void EEVEE_occlusion_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_EffectsInfo *effects = stl->effects;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
if ((effects->enabled_effects & EFFECT_GTAO) != 0) {
@@ -147,21 +153,21 @@ void EEVEE_occlusion_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
* the shading stage. This let us do correct shadowing for each diffuse / specular
* lobe present in the shader using the correct normal.
*/
DRW_PASS_CREATE(inst->ao_horizon_search, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->ao_horizon_search, DRW_STATE_WRITE_COLOR);
DRWShadingGroup *grp = DRW_shgroup_create(EEVEE_shaders_effect_ambient_occlusion_sh_get(),
inst->ao_horizon_search);
psl->ao_horizon_search);
DRW_shgroup_uniform_texture(grp, "utilTex", EEVEE_materials_get_util_tex());
DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &inst->maxzbuffer);
DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &txl->maxzbuffer);
DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
DRW_shgroup_uniform_block(grp, "renderpass_block", sldata->renderpass_ubo.combined);
DRW_shgroup_call_procedural_triangles(grp, nullptr, 1);
if (G.debug_value == 6) {
DRW_PASS_CREATE(inst->ao_horizon_debug, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->ao_horizon_debug, DRW_STATE_WRITE_COLOR);
grp = DRW_shgroup_create(EEVEE_shaders_effect_ambient_occlusion_debug_sh_get(),
inst->ao_horizon_debug);
psl->ao_horizon_debug);
DRW_shgroup_uniform_texture(grp, "utilTex", EEVEE_materials_get_util_tex());
DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &inst->maxzbuffer);
DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &txl->maxzbuffer);
DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
DRW_shgroup_uniform_texture_ref(grp, "normalBuffer", &effects->ssr_normal_input);
DRW_shgroup_uniform_texture_ref(grp, "horizonBuffer", &effects->gtao_horizons_renderpass);
@@ -174,24 +180,26 @@ void EEVEE_occlusion_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
void EEVEE_occlusion_compute(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
EEVEE_CommonUniformBuffer *common_data = &sldata->common_data;
if ((effects->enabled_effects & EFFECT_GTAO) != 0) {
GPU_framebuffer_bind(inst->gtao_fb);
GPU_framebuffer_bind(fbl->gtao_fb);
/** NOTE(fclem): Kind of fragile. We need this to make sure everything lines up
* nicely during planar reflection. */
if (common_data->ray_type != EEVEE_RAY_GLOSSY) {
const float *viewport_size = DRW_viewport_size_get();
GPU_framebuffer_viewport_set(inst->gtao_fb, 0, 0, UNPACK2(viewport_size));
GPU_framebuffer_viewport_set(fbl->gtao_fb, 0, 0, UNPACK2(viewport_size));
}
DRW_draw_pass(inst->ao_horizon_search);
DRW_draw_pass(psl->ao_horizon_search);
if (common_data->ray_type != EEVEE_RAY_GLOSSY) {
GPU_framebuffer_viewport_reset(inst->gtao_fb);
GPU_framebuffer_viewport_reset(fbl->gtao_fb);
}
if (GPU_mip_render_workaround() ||
@@ -202,49 +210,51 @@ void EEVEE_occlusion_compute(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
}
/* Restore */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}
void EEVEE_occlusion_draw_debug(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
if (((effects->enabled_effects & EFFECT_GTAO) != 0) && (G.debug_value == 6)) {
GPU_framebuffer_bind(inst->gtao_debug_fb);
DRW_draw_pass(inst->ao_horizon_debug);
GPU_framebuffer_bind(fbl->gtao_debug_fb);
DRW_draw_pass(psl->ao_horizon_debug);
/* Restore */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}
void EEVEE_occlusion_output_accumulate(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_PassList *psl = vedata->psl;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
if (inst->ao_accum_fb != nullptr) {
if (fbl->ao_accum_fb != nullptr) {
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
/* Update the min_max/horizon buffers so the refraction materials appear in it. */
EEVEE_create_minmax_buffer(vedata, dtxl->depth, -1);
EEVEE_occlusion_compute(sldata, vedata);
GPU_framebuffer_bind(inst->ao_accum_fb);
GPU_framebuffer_bind(fbl->ao_accum_fb);
/* Clear texture. */
if (effects->taa_current_sample == 1) {
const float clear[4] = {0.0f, 0.0f, 0.0f, 0.0f};
GPU_framebuffer_clear_color(inst->ao_accum_fb, clear);
GPU_framebuffer_clear_color(fbl->ao_accum_fb, clear);
}
DRW_draw_pass(inst->ao_accum_ps);
DRW_draw_pass(psl->ao_accum_ps);
/* Restore */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}
source/blender/draw/engines/gooengine/eevee_private.hh
+260 -253
View File
@@ -53,9 +53,9 @@ extern DrawEngineType draw_engine_eevee_type;
#define SWAP_DOUBLE_BUFFERS() \
{ \
if (effects->swap_double_buffer) { \
std::swap(inst->main_fb, inst->double_buffer_fb); \
std::swap(inst->main_color_fb, inst->double_buffer_color_fb); \
std::swap(inst->color, inst->color_double_buffer); \
std::swap(fbl->main_fb, fbl->double_buffer_fb); \
std::swap(fbl->main_color_fb, fbl->double_buffer_color_fb); \
std::swap(txl->color, txl->color_double_buffer); \
effects->swap_double_buffer = false; \
} \
} \
@@ -63,34 +63,34 @@ extern DrawEngineType draw_engine_eevee_type;
#define SWAP_BUFFERS() \
{ \
if (effects->target_buffer == inst->effect_color_fb) { \
if (effects->target_buffer == fbl->effect_color_fb) { \
SWAP_DOUBLE_BUFFERS(); \
effects->source_buffer = inst->color_post; \
effects->target_buffer = inst->main_color_fb; \
effects->source_buffer = txl->color_post; \
effects->target_buffer = fbl->main_color_fb; \
} \
else { \
SWAP_DOUBLE_BUFFERS(); \
effects->source_buffer = inst->color; \
effects->target_buffer = inst->effect_color_fb; \
effects->source_buffer = txl->color; \
effects->target_buffer = fbl->effect_color_fb; \
} \
} \
((void)0)
#define SWAP_BUFFERS_TAA() \
{ \
if (effects->target_buffer == inst->effect_color_fb) { \
std::swap(inst->effect_fb, inst->taa_history_fb); \
std::swap(inst->effect_color_fb, inst->taa_history_color_fb); \
std::swap(inst->color_post, inst->taa_history); \
effects->source_buffer = inst->taa_history; \
effects->target_buffer = inst->effect_color_fb; \
if (effects->target_buffer == fbl->effect_color_fb) { \
std::swap(fbl->effect_fb, fbl->taa_history_fb); \
std::swap(fbl->effect_color_fb, fbl->taa_history_color_fb); \
std::swap(txl->color_post, txl->taa_history); \
effects->source_buffer = txl->taa_history; \
effects->target_buffer = fbl->effect_color_fb; \
} \
else { \
std::swap(inst->main_fb, inst->taa_history_fb); \
std::swap(inst->main_color_fb, inst->taa_history_color_fb); \
std::swap(inst->color, inst->taa_history); \
effects->source_buffer = inst->taa_history; \
effects->target_buffer = inst->main_color_fb; \
std::swap(fbl->main_fb, fbl->taa_history_fb); \
std::swap(fbl->main_color_fb, fbl->taa_history_color_fb); \
std::swap(txl->color, txl->taa_history); \
effects->source_buffer = txl->taa_history; \
effects->target_buffer = fbl->main_color_fb; \
} \
} \
((void)0)
@@ -197,6 +197,234 @@ struct EEVEE_BoundBox {
float center[3], halfdim[3];
};
struct EEVEE_PassList {
/* Shadows */
DRWPass *shadow_pass;
DRWPass *shadow_accum_pass;
/* Probes */
DRWPass *probe_background;
DRWPass *probe_glossy_compute;
DRWPass *probe_diffuse_compute;
DRWPass *probe_visibility_compute;
DRWPass *probe_grid_fill;
DRWPass *probe_display;
DRWPass *probe_planar_downsample_ps;
/* Effects */
DRWPass *ao_horizon_search;
DRWPass *ao_horizon_debug;
DRWPass *ao_accum_ps;
DRWPass *mist_accum_ps;
DRWPass *motion_blur;
DRWPass *bloom_blit;
DRWPass *bloom_downsample_first;
DRWPass *bloom_downsample;
DRWPass *bloom_upsample;
DRWPass *bloom_resolve;
DRWPass *bloom_accum_ps;
DRWPass *dof_setup;
DRWPass *dof_flatten_tiles;
DRWPass *dof_dilate_tiles_minmax;
DRWPass *dof_dilate_tiles_minabs;
DRWPass *dof_reduce_copy;
DRWPass *dof_downsample;
DRWPass *dof_reduce;
DRWPass *dof_bokeh;
DRWPass *dof_gather_fg;
DRWPass *dof_gather_fg_holefill;
DRWPass *dof_gather_bg;
DRWPass *dof_scatter_fg;
DRWPass *dof_scatter_bg;
DRWPass *dof_filter;
DRWPass *dof_resolve;
DRWPass *volumetric_world_ps;
DRWPass *volumetric_objects_ps;
DRWPass *volumetric_scatter_ps;
DRWPass *volumetric_integration_ps;
DRWPass *volumetric_resolve_ps;
DRWPass *volumetric_accum_ps;
DRWPass *ssr_raytrace;
DRWPass *ssr_resolve;
DRWPass *ssr_resolve_probe;
DRWPass *ssr_resolve_refl;
DRWPass *sss_blur_ps;
DRWPass *sss_resolve_ps;
DRWPass *sss_translucency_ps;
DRWPass *color_copy_ps;
DRWPass *color_downsample_ps;
DRWPass *color_downsample_cube_ps;
DRWPass *velocity_object;
DRWPass *velocity_hair;
DRWPass *velocity_resolve;
DRWPass *velocity_tiles_x;
DRWPass *velocity_tiles;
DRWPass *velocity_tiles_expand[2];
DRWPass *taa_resolve;
DRWPass *alpha_checker;
/* HiZ */
DRWPass *maxz_downlevel_ps;
DRWPass *maxz_copydepth_ps;
DRWPass *maxz_copydepth_layer_ps;
/* Render-pass Accumulation. */
DRWPass *material_accum_ps;
DRWPass *background_accum_ps;
DRWPass *transparent_accum_ps;
DRWPass *cryptomatte_ps;
DRWPass *depth_ps;
DRWPass *depth_cull_ps;
DRWPass *depth_clip_ps;
DRWPass *depth_clip_cull_ps;
DRWPass *depth_refract_ps;
DRWPass *depth_refract_cull_ps;
DRWPass *depth_refract_clip_ps;
DRWPass *depth_refract_clip_cull_ps;
DRWPass *material_ps;
DRWPass *material_cull_ps;
DRWPass *material_refract_ps;
DRWPass *material_refract_cull_ps;
DRWPass *material_sss_ps;
DRWPass *material_sss_cull_ps;
DRWPass *transparent_pass;
DRWPass *background_ps;
DRWPass *update_noise_pass;
DRWPass *lookdev_glossy_pass;
DRWPass *lookdev_diffuse_pass;
DRWPass *renderpass_pass;
};
struct EEVEE_FramebufferList {
/* Effects */
GPUFrameBuffer *gtao_fb;
GPUFrameBuffer *gtao_debug_fb;
GPUFrameBuffer *downsample_fb;
GPUFrameBuffer *maxzbuffer_fb;
GPUFrameBuffer *bloom_blit_fb;
GPUFrameBuffer *bloom_down_fb[MAX_BLOOM_STEP];
GPUFrameBuffer *bloom_accum_fb[MAX_BLOOM_STEP - 1];
GPUFrameBuffer *bloom_pass_accum_fb;
GPUFrameBuffer *cryptomatte_fb;
GPUFrameBuffer *shadow_accum_fb;
GPUFrameBuffer *ssr_accum_fb;
GPUFrameBuffer *sss_blur_fb;
GPUFrameBuffer *sss_blit_fb;
GPUFrameBuffer *sss_resolve_fb;
GPUFrameBuffer *sss_clear_fb;
GPUFrameBuffer *sss_translucency_fb;
GPUFrameBuffer *sss_accum_fb;
GPUFrameBuffer *dof_setup_fb;
GPUFrameBuffer *dof_flatten_tiles_fb;
GPUFrameBuffer *dof_dilate_tiles_fb;
GPUFrameBuffer *dof_downsample_fb;
GPUFrameBuffer *dof_reduce_fb;
GPUFrameBuffer *dof_reduce_copy_fb;
GPUFrameBuffer *dof_bokeh_fb;
GPUFrameBuffer *dof_gather_fg_fb;
GPUFrameBuffer *dof_filter_fg_fb;
GPUFrameBuffer *dof_gather_fg_holefill_fb;
GPUFrameBuffer *dof_gather_bg_fb;
GPUFrameBuffer *dof_filter_bg_fb;
GPUFrameBuffer *dof_scatter_fg_fb;
GPUFrameBuffer *dof_scatter_bg_fb;
GPUFrameBuffer *volumetric_fb;
GPUFrameBuffer *volumetric_scat_fb;
GPUFrameBuffer *volumetric_integ_fb;
GPUFrameBuffer *volumetric_accum_fb;
GPUFrameBuffer *screen_tracing_fb;
GPUFrameBuffer *mist_accum_fb;
GPUFrameBuffer *material_accum_fb;
GPUFrameBuffer *renderpass_fb;
GPUFrameBuffer *ao_accum_fb;
GPUFrameBuffer *velocity_resolve_fb;
GPUFrameBuffer *velocity_fb;
GPUFrameBuffer *velocity_tiles_fb[2];
GPUFrameBuffer *update_noise_fb;
GPUFrameBuffer *planarref_fb;
GPUFrameBuffer *planar_downsample_fb;
GPUFrameBuffer *main_fb;
GPUFrameBuffer *main_color_fb;
GPUFrameBuffer *effect_fb;
GPUFrameBuffer *effect_color_fb;
GPUFrameBuffer *radiance_filtered_fb;
GPUFrameBuffer *double_buffer_fb;
GPUFrameBuffer *double_buffer_color_fb;
GPUFrameBuffer *double_buffer_depth_fb;
GPUFrameBuffer *transparent_rpass_fb;
GPUFrameBuffer *transparent_rpass_accum_fb;
GPUFrameBuffer *taa_history_fb;
GPUFrameBuffer *taa_history_color_fb;
};
struct EEVEE_TextureList {
/* Effects */
GPUTexture *color_post; /* R16_G16_B16 */
GPUTexture *mist_accum;
GPUTexture *ao_accum;
GPUTexture *sss_accum;
GPUTexture *env_accum;
GPUTexture *diff_color_accum;
GPUTexture *diff_light_accum;
GPUTexture *spec_color_accum;
GPUTexture *spec_light_accum;
GPUTexture *aov_surface_accum[MAX_AOVS];
GPUTexture *emit_accum;
GPUTexture *bloom_accum;
GPUTexture *ssr_accum;
GPUTexture *shadow_accum;
GPUTexture *transparent_accum;
GPUTexture *transparent_depth_tmp;
GPUTexture *transparent_color_tmp;
GPUTexture *cryptomatte;
GPUTexture *taa_history;
/* Could not be pool texture because of mipmapping. */
GPUTexture *dof_reduced_color;
GPUTexture *dof_reduced_coc;
GPUTexture *volume_prop_scattering;
GPUTexture *volume_prop_extinction;
GPUTexture *volume_prop_emission;
GPUTexture *volume_prop_phase;
GPUTexture *volume_scatter;
GPUTexture *volume_transmit;
GPUTexture *volume_scatter_history;
GPUTexture *volume_transmit_history;
GPUTexture *volume_scatter_accum;
GPUTexture *volume_transmittance_accum;
GPUTexture *lookdev_grid_tx;
GPUTexture *lookdev_cube_tx;
GPUTexture *planar_pool;
GPUTexture *planar_depth;
GPUTexture *maxzbuffer;
GPUTexture *filtered_radiance;
GPUTexture *renderpass;
GPUTexture *color; /* R16_G16_B16 */
GPUTexture *color_double_buffer;
GPUTexture *depth_double_buffer;
};
struct EEVEE_StorageList {
/* Effects */
EEVEE_EffectsInfo *effects;
EEVEE_PrivateData *g_data;
LightCache *lookdev_lightcache;
EEVEE_LightProbe *lookdev_cube_data;
EEVEE_LightGrid *lookdev_grid_data;
LightCacheTexture *lookdev_cube_mips;
};
/* ************ RENDERPASS UBO ************* */
struct EEVEE_RenderPassData {
int renderPassDiffuse;
@@ -589,6 +817,7 @@ struct EEVEE_EffectsInfo {
GPUTexture *bloom_upsample[MAX_BLOOM_STEP - 1];
GPUTexture *unf_source_buffer; /* pointer copy */
GPUTexture *unf_base_buffer; /* pointer copy */
/* Not allocated, just a copy of a *GPUtexture in EEVEE_TextureList. */
GPUTexture *source_buffer; /* latest updated texture */
GPUFrameBuffer *target_buffer; /* next target to render to */
GPUTexture *final_tx; /* Final color to transform to display color space. */
@@ -751,237 +980,13 @@ struct EEVEE_CryptomatteSample {
/* *********************************** */
struct GOOENGINE_Instance {
/* Shadows */
DRWPass *shadow_pass;
DRWPass *shadow_accum_pass;
/* Probes */
DRWPass *probe_background;
DRWPass *probe_glossy_compute;
DRWPass *probe_diffuse_compute;
DRWPass *probe_visibility_compute;
DRWPass *probe_grid_fill;
DRWPass *probe_display;
DRWPass *probe_planar_downsample_ps;
/* Effects */
DRWPass *ao_horizon_search;
DRWPass *ao_horizon_debug;
DRWPass *ao_accum_ps;
DRWPass *mist_accum_ps;
DRWPass *motion_blur;
DRWPass *bloom_blit;
DRWPass *bloom_downsample_first;
DRWPass *bloom_downsample;
DRWPass *bloom_upsample;
DRWPass *bloom_resolve;
DRWPass *bloom_accum_ps;
DRWPass *dof_setup;
DRWPass *dof_flatten_tiles;
DRWPass *dof_dilate_tiles_minmax;
DRWPass *dof_dilate_tiles_minabs;
DRWPass *dof_reduce_copy;
DRWPass *dof_downsample;
DRWPass *dof_reduce;
DRWPass *dof_bokeh;
DRWPass *dof_gather_fg;
DRWPass *dof_gather_fg_holefill;
DRWPass *dof_gather_bg;
DRWPass *dof_scatter_fg;
DRWPass *dof_scatter_bg;
DRWPass *dof_filter;
DRWPass *dof_resolve;
DRWPass *volumetric_world_ps;
DRWPass *volumetric_objects_ps;
DRWPass *volumetric_scatter_ps;
DRWPass *volumetric_integration_ps;
DRWPass *volumetric_resolve_ps;
DRWPass *volumetric_accum_ps;
DRWPass *ssr_raytrace;
DRWPass *ssr_resolve;
DRWPass *ssr_resolve_probe;
DRWPass *ssr_resolve_refl;
DRWPass *sss_blur_ps;
DRWPass *sss_resolve_ps;
DRWPass *sss_translucency_ps;
DRWPass *color_copy_ps;
DRWPass *color_downsample_ps;
DRWPass *color_downsample_cube_ps;
DRWPass *velocity_object;
DRWPass *velocity_hair;
DRWPass *velocity_resolve;
DRWPass *velocity_tiles_x;
DRWPass *velocity_tiles;
DRWPass *velocity_tiles_expand[2];
DRWPass *taa_resolve;
DRWPass *alpha_checker;
/* HiZ */
DRWPass *maxz_downlevel_ps;
DRWPass *maxz_copydepth_ps;
DRWPass *maxz_copydepth_layer_ps;
/* Render-pass Accumulation. */
DRWPass *material_accum_ps;
DRWPass *background_accum_ps;
DRWPass *transparent_accum_ps;
DRWPass *cryptomatte_ps;
DRWPass *depth_ps;
DRWPass *depth_cull_ps;
DRWPass *depth_clip_ps;
DRWPass *depth_clip_cull_ps;
DRWPass *depth_refract_ps;
DRWPass *depth_refract_cull_ps;
DRWPass *depth_refract_clip_ps;
DRWPass *depth_refract_clip_cull_ps;
DRWPass *material_ps;
DRWPass *material_cull_ps;
DRWPass *material_refract_ps;
DRWPass *material_refract_cull_ps;
DRWPass *material_sss_ps;
DRWPass *material_sss_cull_ps;
DRWPass *transparent_pass;
DRWPass *background_ps;
DRWPass *update_noise_pass;
DRWPass *lookdev_glossy_pass;
DRWPass *lookdev_diffuse_pass;
DRWPass *renderpass_pass;
/* Effects */
GPUFrameBuffer *gtao_fb;
GPUFrameBuffer *gtao_debug_fb;
GPUFrameBuffer *downsample_fb;
GPUFrameBuffer *maxzbuffer_fb;
GPUFrameBuffer *bloom_blit_fb;
GPUFrameBuffer *bloom_down_fb[MAX_BLOOM_STEP];
GPUFrameBuffer *bloom_accum_fb[MAX_BLOOM_STEP - 1];
GPUFrameBuffer *bloom_pass_accum_fb;
GPUFrameBuffer *cryptomatte_fb;
GPUFrameBuffer *shadow_accum_fb;
GPUFrameBuffer *ssr_accum_fb;
GPUFrameBuffer *sss_blur_fb;
GPUFrameBuffer *sss_blit_fb;
GPUFrameBuffer *sss_resolve_fb;
GPUFrameBuffer *sss_clear_fb;
GPUFrameBuffer *sss_translucency_fb;
GPUFrameBuffer *sss_accum_fb;
GPUFrameBuffer *dof_setup_fb;
GPUFrameBuffer *dof_flatten_tiles_fb;
GPUFrameBuffer *dof_dilate_tiles_fb;
GPUFrameBuffer *dof_downsample_fb;
GPUFrameBuffer *dof_reduce_fb;
GPUFrameBuffer *dof_reduce_copy_fb;
GPUFrameBuffer *dof_bokeh_fb;
GPUFrameBuffer *dof_gather_fg_fb;
GPUFrameBuffer *dof_filter_fg_fb;
GPUFrameBuffer *dof_gather_fg_holefill_fb;
GPUFrameBuffer *dof_gather_bg_fb;
GPUFrameBuffer *dof_filter_bg_fb;
GPUFrameBuffer *dof_scatter_fg_fb;
GPUFrameBuffer *dof_scatter_bg_fb;
GPUFrameBuffer *volumetric_fb;
GPUFrameBuffer *volumetric_scat_fb;
GPUFrameBuffer *volumetric_integ_fb;
GPUFrameBuffer *volumetric_accum_fb;
GPUFrameBuffer *screen_tracing_fb;
GPUFrameBuffer *mist_accum_fb;
GPUFrameBuffer *material_accum_fb;
GPUFrameBuffer *renderpass_fb;
GPUFrameBuffer *ao_accum_fb;
GPUFrameBuffer *velocity_resolve_fb;
GPUFrameBuffer *velocity_fb;
GPUFrameBuffer *velocity_tiles_fb[2];
GPUFrameBuffer *update_noise_fb;
GPUFrameBuffer *planarref_fb;
GPUFrameBuffer *planar_downsample_fb;
GPUFrameBuffer *main_fb;
GPUFrameBuffer *main_color_fb;
GPUFrameBuffer *effect_fb;
GPUFrameBuffer *effect_color_fb;
GPUFrameBuffer *radiance_filtered_fb;
GPUFrameBuffer *double_buffer_fb;
GPUFrameBuffer *double_buffer_color_fb;
GPUFrameBuffer *double_buffer_depth_fb;
GPUFrameBuffer *transparent_rpass_fb;
GPUFrameBuffer *transparent_rpass_accum_fb;
GPUFrameBuffer *taa_history_fb;
GPUFrameBuffer *taa_history_color_fb;
/* Effects */
GPUTexture *color_post; /* R16_G16_B16 */
GPUTexture *mist_accum;
GPUTexture *ao_accum;
GPUTexture *sss_accum;
GPUTexture *env_accum;
GPUTexture *diff_color_accum;
GPUTexture *diff_light_accum;
GPUTexture *spec_color_accum;
GPUTexture *spec_light_accum;
GPUTexture *aov_surface_accum[MAX_AOVS];
GPUTexture *emit_accum;
GPUTexture *bloom_accum;
GPUTexture *ssr_accum;
GPUTexture *shadow_accum;
GPUTexture *transparent_accum;
GPUTexture *transparent_depth_tmp;
GPUTexture *transparent_color_tmp;
GPUTexture *cryptomatte;
GPUTexture *taa_history;
/* Could not be pool texture because of mipmapping. */
GPUTexture *dof_reduced_color;
GPUTexture *dof_reduced_coc;
GPUTexture *volume_prop_scattering;
GPUTexture *volume_prop_extinction;
GPUTexture *volume_prop_emission;
GPUTexture *volume_prop_phase;
GPUTexture *volume_scatter;
GPUTexture *volume_transmit;
GPUTexture *volume_scatter_history;
GPUTexture *volume_transmit_history;
GPUTexture *volume_scatter_accum;
GPUTexture *volume_transmittance_accum;
GPUTexture *lookdev_grid_tx;
GPUTexture *lookdev_cube_tx;
GPUTexture *planar_pool;
GPUTexture *planar_depth;
GPUTexture *maxzbuffer;
GPUTexture *filtered_radiance;
GPUTexture *renderpass;
GPUTexture *color; /* R16_G16_B16 */
GPUTexture *color_double_buffer;
GPUTexture *depth_double_buffer;
/* Effects */
EEVEE_EffectsInfo *effects;
EEVEE_PrivateData *g_data;
LightCache *lookdev_lightcache;
EEVEE_LightProbe *lookdev_cube_data;
EEVEE_LightGrid *lookdev_grid_data;
LightCacheTexture *lookdev_cube_mips;
};
struct EEVEE_Data {
void *engine_type;
DRWViewportEmptyList *fbl;
DRWViewportEmptyList *txl;
DRWViewportEmptyList *psl;
DRWViewportEmptyList *stl;
GOOENGINE_Instance *instance;
EEVEE_FramebufferList *fbl;
EEVEE_TextureList *txl;
EEVEE_PassList *psl;
EEVEE_StorageList *stl;
void *instance_data;
char info[GPU_INFO_SIZE];
};
@@ -1100,7 +1105,9 @@ GPUTexture *EEVEE_materials_get_dummy_3d();
#endif
void EEVEE_materials_init(EEVEE_ViewLayerData *sldata,
EEVEE_Data *vedata);
EEVEE_Data *vedata,
EEVEE_StorageList *stl,
EEVEE_FramebufferList *fbl);
void EEVEE_materials_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
void EEVEE_materials_cache_populate(EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata,
@@ -1116,7 +1123,7 @@ void EEVEE_object_curves_cache_populate(EEVEE_Data *vedata,
bool *cast_shadow);
void EEVEE_materials_cache_finish(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
void EEVEE_materials_free();
void EEVEE_update_noise(EEVEE_Data *vedata, const double offsets[3]);
void EEVEE_update_noise(EEVEE_PassList *psl, EEVEE_FramebufferList *fbl, const double offsets[3]);
void EEVEE_material_renderpasses_init(EEVEE_Data *vedata);
void EEVEE_material_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, uint tot_samples);
void EEVEE_material_output_accumulate(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
@@ -1498,11 +1505,11 @@ void EEVEE_material_transparent_output_accumulate(EEVEE_Data *vedata);
*
* This method will create a shading group to perform the post-processing for the given
* `renderpass_type`. The post-processing will be done and the result will be stored in the
* `inst->renderpass` texture.
* `vedata->txl->renderpass` texture.
*
* Only invoke this function for passes that need post-processing.
*
* After invoking this function the active frame-buffer is set to `inst->renderpass_fb`.
* After invoking this function the active frame-buffer is set to `vedata->fbl->renderpass_fb`.
*/
void EEVEE_renderpasses_postprocess(EEVEE_ViewLayerData *sldata,
EEVEE_Data *vedata,
@@ -1521,7 +1528,7 @@ uint EEVEE_renderpasses_aov_hash(const ViewLayerAOV *aov);
void EEVEE_temporal_sampling_reset(EEVEE_Data *vedata);
void EEVEE_temporal_sampling_create_view(EEVEE_Data *vedata);
int EEVEE_temporal_sampling_sample_count_get(const Scene *scene, const GOOENGINE_Instance *inst);
int EEVEE_temporal_sampling_sample_count_get(const Scene *scene, const EEVEE_StorageList *stl);
int EEVEE_temporal_sampling_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
void EEVEE_temporal_sampling_offset_calc(const double ht_point[2],
float filter_size,
source/blender/draw/engines/gooengine/eevee_render.cc
+87 -99
View File
@@ -39,7 +39,9 @@
bool EEVEE_render_init(EEVEE_Data *ved, RenderEngine *engine, Depsgraph *depsgraph)
{
EEVEE_Data *vedata = (EEVEE_Data *)ved;
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_FramebufferList *fbl = vedata->fbl;
Scene *scene = DEG_get_evaluated_scene(depsgraph);
const float *size_orig = DRW_viewport_size_get();
float size_final[2];
@@ -52,10 +54,10 @@ bool EEVEE_render_init(EEVEE_Data *ved, RenderEngine *engine, Depsgraph *depsgra
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
/* Alloc transient data. */
if (!inst->g_data) {
inst->g_data = static_cast<EEVEE_PrivateData *>(MEM_callocN(sizeof(*inst->g_data), __func__));
if (!stl->g_data) {
stl->g_data = static_cast<EEVEE_PrivateData *>(MEM_callocN(sizeof(*stl->g_data), __func__));
}
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_PrivateData *g_data = stl->g_data;
g_data->background_alpha = DRW_state_draw_background() ? 1.0f : 0.0f;
g_data->valid_double_buffer = false;
copy_v2_v2(g_data->size_orig, size_orig);
@@ -102,15 +104,15 @@ bool EEVEE_render_init(EEVEE_Data *ved, RenderEngine *engine, Depsgraph *depsgra
/* TODO: 32 bit depth. */
DRW_texture_ensure_fullscreen_2d(&dtxl->depth, GPU_DEPTH24_STENCIL8, DRWTextureFlag(0));
DRW_texture_ensure_fullscreen_2d(&inst->color, GPU_RGBA32F, DRW_TEX_FILTER);
DRW_texture_ensure_fullscreen_2d(&txl->color, GPU_RGBA32F, DRW_TEX_FILTER);
GPU_framebuffer_ensure_config(
&dfbl->default_fb,
{GPU_ATTACHMENT_TEXTURE(dtxl->depth), GPU_ATTACHMENT_TEXTURE(inst->color)});
{GPU_ATTACHMENT_TEXTURE(dtxl->depth), GPU_ATTACHMENT_TEXTURE(txl->color)});
GPU_framebuffer_ensure_config(
&inst->main_fb, {GPU_ATTACHMENT_TEXTURE(dtxl->depth), GPU_ATTACHMENT_TEXTURE(inst->color)});
GPU_framebuffer_ensure_config(&inst->main_color_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(inst->color)});
&fbl->main_fb, {GPU_ATTACHMENT_TEXTURE(dtxl->depth), GPU_ATTACHMENT_TEXTURE(txl->color)});
GPU_framebuffer_ensure_config(&fbl->main_color_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(txl->color)});
/* Camera could change because of Motion blur. */
g_data->cam_original_ob = RE_GetCamera(engine->re);
@@ -121,8 +123,9 @@ bool EEVEE_render_init(EEVEE_Data *ved, RenderEngine *engine, Depsgraph *depsgra
void EEVEE_render_modules_init(EEVEE_Data *vedata, RenderEngine *engine, Depsgraph *depsgraph)
{
EEVEE_ViewLayerData *sldata = EEVEE_view_layer_data_ensure();
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PrivateData *g_data = vedata->stl->g_data;
EEVEE_FramebufferList *fbl = vedata->fbl;
/* TODO(sergey): Shall render hold pointer to an evaluated camera instead? */
Object *ob_camera_eval = DEG_get_evaluated_object(depsgraph, g_data->cam_original_ob);
EEVEE_render_view_sync(vedata, engine, depsgraph);
@@ -131,15 +134,14 @@ void EEVEE_render_modules_init(EEVEE_Data *vedata, RenderEngine *engine, Depsgra
* `EEVEE_effects_init` needs to go second for TAA. */
EEVEE_renderpasses_init(vedata);
EEVEE_effects_init(sldata, vedata, ob_camera_eval, false);
EEVEE_materials_init(sldata, vedata);
EEVEE_materials_init(sldata, vedata, stl, fbl);
EEVEE_shadows_init(sldata);
EEVEE_lightprobes_init(sldata, vedata);
}
void EEVEE_render_view_sync(EEVEE_Data *vedata, RenderEngine *engine, Depsgraph *depsgraph)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_PrivateData *g_data = vedata->stl->g_data;
/* Set the perspective & view matrix. */
float winmat[4][4], viewmat[4][4], viewinv[4][4];
@@ -180,8 +182,8 @@ void EEVEE_render_cache(void *vedata, Object *ob, RenderEngine *engine, Depsgrap
{
EEVEE_ViewLayerData *sldata = EEVEE_view_layer_data_ensure();
EEVEE_Data *data = static_cast<EEVEE_Data *>(vedata);
GOOENGINE_Instance *inst = data->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_StorageList *stl = data->stl;
EEVEE_PrivateData *g_data = stl->g_data;
EEVEE_LightProbesInfo *pinfo = sldata->probes;
bool cast_shadow = false;
@@ -257,15 +259,14 @@ static void eevee_render_color_result(RenderLayer *rl,
GPUFrameBuffer *framebuffer,
EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
RenderPass *rp = RE_pass_find_by_name(rl, render_pass_name, viewname);
if (rp == nullptr) {
return;
}
GPU_framebuffer_bind(framebuffer);
GPU_framebuffer_read_color(framebuffer,
inst->g_data->overscan_pixels + rect->xmin,
inst->g_data->overscan_pixels + rect->ymin,
vedata->stl->g_data->overscan_pixels + rect->xmin,
vedata->stl->g_data->overscan_pixels + rect->ymin,
BLI_rcti_size_x(rect),
BLI_rcti_size_y(rect),
num_channels,
@@ -280,9 +281,8 @@ static void eevee_render_result_combined(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData * /*sldata*/)
{
GOOENGINE_Instance *inst = vedata->instance;
eevee_render_color_result(
rl, viewname, rect, RE_PASSNAME_COMBINED, 4, inst->effects->final_fb, vedata);
rl, viewname, rect, RE_PASSNAME_COMBINED, 4, vedata->stl->effects->final_fb, vedata);
}
static void eevee_render_result_normal(RenderLayer *rl,
@@ -291,18 +291,17 @@ static void eevee_render_result_normal(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
const int current_sample = inst->effects->taa_current_sample;
const int current_sample = vedata->stl->effects->taa_current_sample;
/* Only read the center texel. */
if (current_sample > 1) {
return;
}
if ((inst->g_data->render_passes & EEVEE_RENDER_PASS_NORMAL) != 0) {
if ((vedata->stl->g_data->render_passes & EEVEE_RENDER_PASS_NORMAL) != 0) {
EEVEE_renderpasses_postprocess(sldata, vedata, EEVEE_RENDER_PASS_NORMAL, 0);
eevee_render_color_result(
rl, viewname, rect, RE_PASSNAME_NORMAL, 3, inst->renderpass_fb, vedata);
rl, viewname, rect, RE_PASSNAME_NORMAL, 3, vedata->fbl->renderpass_fb, vedata);
}
}
@@ -312,18 +311,17 @@ static void eevee_render_result_z(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
const int current_sample = inst->effects->taa_current_sample;
const int current_sample = vedata->stl->effects->taa_current_sample;
/* Only read the center texel. */
if (current_sample > 1) {
return;
}
if ((inst->g_data->render_passes & EEVEE_RENDER_PASS_Z) != 0) {
if ((vedata->stl->g_data->render_passes & EEVEE_RENDER_PASS_Z) != 0) {
EEVEE_renderpasses_postprocess(sldata, vedata, EEVEE_RENDER_PASS_Z, 0);
eevee_render_color_result(
rl, viewname, rect, RE_PASSNAME_Z, 1, inst->renderpass_fb, vedata);
rl, viewname, rect, RE_PASSNAME_Z, 1, vedata->fbl->renderpass_fb, vedata);
}
}
@@ -333,11 +331,10 @@ static void eevee_render_result_mist(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
if ((inst->g_data->render_passes & EEVEE_RENDER_PASS_MIST) != 0) {
if ((vedata->stl->g_data->render_passes & EEVEE_RENDER_PASS_MIST) != 0) {
EEVEE_renderpasses_postprocess(sldata, vedata, EEVEE_RENDER_PASS_MIST, 0);
eevee_render_color_result(
rl, viewname, rect, RE_PASSNAME_MIST, 1, inst->renderpass_fb, vedata);
rl, viewname, rect, RE_PASSNAME_MIST, 1, vedata->fbl->renderpass_fb, vedata);
}
}
@@ -347,11 +344,10 @@ static void eevee_render_result_shadow(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
if ((inst->g_data->render_passes & EEVEE_RENDER_PASS_SHADOW) != 0) {
if ((vedata->stl->g_data->render_passes & EEVEE_RENDER_PASS_SHADOW) != 0) {
EEVEE_renderpasses_postprocess(sldata, vedata, EEVEE_RENDER_PASS_SHADOW, 0);
eevee_render_color_result(
rl, viewname, rect, RE_PASSNAME_SHADOW, 3, inst->renderpass_fb, vedata);
rl, viewname, rect, RE_PASSNAME_SHADOW, 3, vedata->fbl->renderpass_fb, vedata);
}
}
@@ -361,11 +357,10 @@ static void eevee_render_result_occlusion(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
if ((inst->g_data->render_passes & EEVEE_RENDER_PASS_AO) != 0) {
if ((vedata->stl->g_data->render_passes & EEVEE_RENDER_PASS_AO) != 0) {
EEVEE_renderpasses_postprocess(sldata, vedata, EEVEE_RENDER_PASS_AO, 0);
eevee_render_color_result(
rl, viewname, rect, RE_PASSNAME_AO, 3, inst->renderpass_fb, vedata);
rl, viewname, rect, RE_PASSNAME_AO, 3, vedata->fbl->renderpass_fb, vedata);
}
}
@@ -375,16 +370,15 @@ static void eevee_render_result_bloom(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
if ((inst->effects->enabled_effects & EFFECT_BLOOM) == 0) {
if ((vedata->stl->effects->enabled_effects & EFFECT_BLOOM) == 0) {
/* Bloom is not enabled. */
return;
}
if ((inst->g_data->render_passes & EEVEE_RENDER_PASS_BLOOM) != 0) {
if ((vedata->stl->g_data->render_passes & EEVEE_RENDER_PASS_BLOOM) != 0) {
EEVEE_renderpasses_postprocess(sldata, vedata, EEVEE_RENDER_PASS_BLOOM, 0);
eevee_render_color_result(
rl, viewname, rect, RE_PASSNAME_BLOOM, 3, inst->renderpass_fb, vedata);
rl, viewname, rect, RE_PASSNAME_BLOOM, 3, vedata->fbl->renderpass_fb, vedata);
}
}
@@ -394,19 +388,18 @@ static void eevee_render_result_transparent(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
if ((inst->g_data->render_passes & EEVEE_RENDER_PASS_TRANSPARENT) != 0) {
if ((vedata->stl->g_data->render_passes & EEVEE_RENDER_PASS_TRANSPARENT) != 0) {
EEVEE_renderpasses_postprocess(sldata, vedata, EEVEE_RENDER_PASS_TRANSPARENT, 0);
eevee_render_color_result(
rl, viewname, rect, RE_PASSNAME_TRANSPARENT, 4, inst->renderpass_fb, vedata);
rl, viewname, rect, RE_PASSNAME_TRANSPARENT, 4, vedata->fbl->renderpass_fb, vedata);
}
}
#define EEVEE_RENDER_RESULT_MATERIAL_PASS(pass_name, eevee_pass_type) \
if ((inst->g_data->render_passes & EEVEE_RENDER_PASS_##eevee_pass_type) != 0) { \
if ((vedata->stl->g_data->render_passes & EEVEE_RENDER_PASS_##eevee_pass_type) != 0) { \
EEVEE_renderpasses_postprocess(sldata, vedata, EEVEE_RENDER_PASS_##eevee_pass_type, 0); \
eevee_render_color_result( \
rl, viewname, rect, RE_PASSNAME_##pass_name, 3, inst->renderpass_fb, vedata); \
rl, viewname, rect, RE_PASSNAME_##pass_name, 3, vedata->fbl->renderpass_fb, vedata); \
}
static void eevee_render_result_diffuse_color(RenderLayer *rl,
@@ -415,7 +408,6 @@ static void eevee_render_result_diffuse_color(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_RENDER_RESULT_MATERIAL_PASS(DIFFUSE_COLOR, DIFFUSE_COLOR)
}
@@ -425,7 +417,6 @@ static void eevee_render_result_diffuse_direct(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_RENDER_RESULT_MATERIAL_PASS(DIFFUSE_DIRECT, DIFFUSE_LIGHT)
}
@@ -435,7 +426,6 @@ static void eevee_render_result_specular_color(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_RENDER_RESULT_MATERIAL_PASS(GLOSSY_COLOR, SPECULAR_COLOR)
}
@@ -445,7 +435,6 @@ static void eevee_render_result_specular_direct(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_RENDER_RESULT_MATERIAL_PASS(GLOSSY_DIRECT, SPECULAR_LIGHT)
}
@@ -455,7 +444,6 @@ static void eevee_render_result_emission(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_RENDER_RESULT_MATERIAL_PASS(EMIT, EMIT)
}
@@ -465,7 +453,6 @@ static void eevee_render_result_environment(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_RENDER_RESULT_MATERIAL_PASS(ENVIRONMENT, ENVIRONMENT)
}
@@ -475,7 +462,6 @@ static void eevee_render_result_volume_light(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_RENDER_RESULT_MATERIAL_PASS(VOLUME_LIGHT, VOLUME_LIGHT)
}
@@ -485,8 +471,7 @@ static void eevee_render_result_aovs(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
if ((inst->g_data->render_passes & EEVEE_RENDER_PASS_AOV) != 0) {
if ((vedata->stl->g_data->render_passes & EEVEE_RENDER_PASS_AOV) != 0) {
const DRWContextState *draw_ctx = DRW_context_state_get();
ViewLayer *view_layer = draw_ctx->view_layer;
int aov_index = 0;
@@ -498,11 +483,11 @@ static void eevee_render_result_aovs(RenderLayer *rl,
switch (aov->type) {
case AOV_TYPE_COLOR:
eevee_render_color_result(
rl, viewname, rect, aov->name, 4, inst->renderpass_fb, vedata);
rl, viewname, rect, aov->name, 4, vedata->fbl->renderpass_fb, vedata);
break;
case AOV_TYPE_VALUE:
eevee_render_color_result(
rl, viewname, rect, aov->name, 1, inst->renderpass_fb, vedata);
rl, viewname, rect, aov->name, 1, vedata->fbl->renderpass_fb, vedata);
}
aov_index++;
}
@@ -517,45 +502,48 @@ static void eevee_render_result_cryptomatte(RenderLayer *rl,
EEVEE_Data *vedata,
EEVEE_ViewLayerData *sldata)
{
GOOENGINE_Instance *inst = vedata->instance;
if ((inst->g_data->render_passes & EEVEE_RENDER_PASS_CRYPTOMATTE) != 0) {
if ((vedata->stl->g_data->render_passes & EEVEE_RENDER_PASS_CRYPTOMATTE) != 0) {
EEVEE_cryptomatte_render_result(rl, viewname, rect, vedata, sldata);
}
}
static void eevee_render_draw_background(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PassList *psl = vedata->psl;
/* Prevent background to write to data buffers.
* NOTE: This also make sure the textures are bound to the right double buffer. */
GPU_framebuffer_ensure_config(&inst->main_fb,
GPU_framebuffer_ensure_config(&fbl->main_fb,
{GPU_ATTACHMENT_LEAVE,
GPU_ATTACHMENT_LEAVE,
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_NONE});
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
DRW_draw_pass(inst->background_ps);
DRW_draw_pass(psl->background_ps);
GPU_framebuffer_ensure_config(&inst->main_fb,
GPU_framebuffer_ensure_config(&fbl->main_fb,
{GPU_ATTACHMENT_LEAVE,
GPU_ATTACHMENT_LEAVE,
GPU_ATTACHMENT_TEXTURE(inst->effects->ssr_normal_input),
GPU_ATTACHMENT_TEXTURE(inst->effects->ssr_specrough_input),
GPU_ATTACHMENT_TEXTURE(inst->effects->sss_irradiance),
GPU_ATTACHMENT_TEXTURE(inst->effects->sss_radius),
GPU_ATTACHMENT_TEXTURE(inst->effects->sss_albedo)});
GPU_framebuffer_bind(inst->main_fb);
GPU_ATTACHMENT_TEXTURE(stl->effects->ssr_normal_input),
GPU_ATTACHMENT_TEXTURE(stl->effects->ssr_specrough_input),
GPU_ATTACHMENT_TEXTURE(stl->effects->sss_irradiance),
GPU_ATTACHMENT_TEXTURE(stl->effects->sss_radius),
GPU_ATTACHMENT_TEXTURE(stl->effects->sss_albedo)});
GPU_framebuffer_bind(fbl->main_fb);
}
void EEVEE_render_draw(EEVEE_Data *vedata, RenderEngine *engine, RenderLayer *rl, const rcti *rect)
{
using namespace blender::draw;
const char *viewname = RE_GetActiveRenderView(engine->re);
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_FramebufferList *fbl = vedata->fbl;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
EEVEE_ViewLayerData *sldata = EEVEE_view_layer_data_ensure();
@@ -564,17 +552,17 @@ void EEVEE_render_draw(EEVEE_Data *vedata, RenderEngine *engine, RenderLayer *rl
/* Need to be called after DRW_render_instance_buffer_finish() */
/* Also we weed to have a correct FBO bound for DRW_curves_update */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
DRW_curves_update(*DRW_manager_get());
/* Sort transparents before the loop. */
DRW_pass_sort_shgroup_z(inst->transparent_pass);
DRW_pass_sort_shgroup_z(psl->transparent_pass);
uint tot_sample = inst->g_data->render_sample_count_per_timestep;
uint tot_sample = stl->g_data->render_sample_count_per_timestep;
uint render_samples = 0;
/* SSR needs one iteration to start properly. */
if ((inst->effects->enabled_effects & EFFECT_SSR) && !inst->effects->ssr_was_valid_double_buffer) {
if ((stl->effects->enabled_effects & EFFECT_SSR) && !stl->effects->ssr_was_valid_double_buffer) {
tot_sample += 1;
}
@@ -586,8 +574,8 @@ void EEVEE_render_draw(EEVEE_Data *vedata, RenderEngine *engine, RenderLayer *rl
double offset[3] = {0.0, 0.0, 0.0};
double r[3];
if ((inst->effects->enabled_effects & EFFECT_SSR) && (render_samples == 1) &&
!inst->effects->ssr_was_valid_double_buffer)
if ((stl->effects->enabled_effects & EFFECT_SSR) && (render_samples == 1) &&
!stl->effects->ssr_was_valid_double_buffer)
{
/* SSR needs one iteration to start properly.
* This iteration was done, reset to the original target sample count. */
@@ -596,7 +584,7 @@ void EEVEE_render_draw(EEVEE_Data *vedata, RenderEngine *engine, RenderLayer *rl
/* Reset sampling (and accumulation) after the first sample to avoid
* washed out first bounce for SSR. */
EEVEE_temporal_sampling_reset(vedata);
inst->effects->ssr_was_valid_double_buffer = inst->g_data->valid_double_buffer;
stl->effects->ssr_was_valid_double_buffer = stl->g_data->valid_double_buffer;
}
/* Don't print every samples as it can lead to bad performance. (see #59649) */
else if ((render_samples % 25) == 0 || (render_samples + 1) == tot_sample) {
@@ -606,13 +594,13 @@ void EEVEE_render_draw(EEVEE_Data *vedata, RenderEngine *engine, RenderLayer *rl
}
/* Copy previous persmat to UBO data */
copy_m4_m4(sldata->common_data.prev_persmat, inst->effects->prev_persmat);
copy_m4_m4(sldata->common_data.prev_persmat, stl->effects->prev_persmat);
BLI_halton_3d(primes, offset, inst->effects->taa_current_sample, r);
EEVEE_update_noise(vedata, r);
EEVEE_temporal_sampling_matrices_calc(inst->effects, r);
EEVEE_volumes_set_jitter(sldata, inst->effects->taa_current_sample - 1);
EEVEE_materials_init(sldata, vedata);
BLI_halton_3d(primes, offset, stl->effects->taa_current_sample, r);
EEVEE_update_noise(psl, fbl, r);
EEVEE_temporal_sampling_matrices_calc(stl->effects, r);
EEVEE_volumes_set_jitter(sldata, stl->effects->taa_current_sample - 1);
EEVEE_materials_init(sldata, vedata, stl, fbl);
/* Refresh Probes
* Shadows needs to be updated for correct probes */
@@ -621,36 +609,36 @@ void EEVEE_render_draw(EEVEE_Data *vedata, RenderEngine *engine, RenderLayer *rl
EEVEE_lightprobes_refresh_planar(sldata, vedata);
/* Refresh Shadows */
EEVEE_shadows_draw(sldata, vedata, inst->effects->taa_view);
EEVEE_shadows_draw(sldata, vedata, stl->effects->taa_view);
/* Set matrices. */
DRW_view_set_active(inst->effects->taa_view);
DRW_view_set_active(stl->effects->taa_view);
/* Set ray type. */
sldata->common_data.ray_type = EEVEE_RAY_CAMERA;
sldata->common_data.ray_depth = 0.0f;
GPU_uniformbuf_update(sldata->common_ubo, &sldata->common_data);
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_clear_color_depth_stencil(inst->main_fb, clear_col, clear_depth, clear_stencil);
GPU_framebuffer_bind(fbl->main_fb);
GPU_framebuffer_clear_color_depth_stencil(fbl->main_fb, clear_col, clear_depth, clear_stencil);
/* Depth pre-pass. */
DRW_draw_pass(inst->depth_ps);
DRW_draw_pass(psl->depth_ps);
/* Create minmax texture */
EEVEE_create_minmax_buffer(vedata, dtxl->depth, -1);
EEVEE_occlusion_compute(sldata, vedata);
EEVEE_volumes_compute(sldata, vedata);
/* Shading pass */
eevee_render_draw_background(vedata);
GPU_framebuffer_bind(inst->main_fb);
DRW_draw_pass(inst->material_ps);
GPU_framebuffer_bind(fbl->main_fb);
DRW_draw_pass(psl->material_ps);
EEVEE_subsurface_data_render(sldata, vedata);
/* Effects pre-transparency */
EEVEE_subsurface_compute(sldata, vedata);
EEVEE_reflection_compute(sldata, vedata);
EEVEE_refraction_compute(sldata, vedata);
/* Opaque refraction */
DRW_draw_pass(inst->depth_refract_ps);
DRW_draw_pass(inst->material_refract_ps);
DRW_draw_pass(psl->depth_refract_ps);
DRW_draw_pass(psl->material_refract_ps);
/* Result NORMAL */
eevee_render_result_normal(rl, viewname, rect, vedata, sldata);
/* Volumetrics Resolve Opaque */
@@ -659,11 +647,11 @@ void EEVEE_render_draw(EEVEE_Data *vedata, RenderEngine *engine, RenderLayer *rl
EEVEE_renderpasses_output_accumulate(sldata, vedata, false);
/* Transparent */
EEVEE_material_transparent_output_accumulate(vedata);
GPU_framebuffer_texture_attach(inst->main_color_fb, dtxl->depth, 0, 0);
GPU_framebuffer_bind(inst->main_color_fb);
DRW_draw_pass(inst->transparent_pass);
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_texture_detach(inst->main_color_fb, dtxl->depth);
GPU_framebuffer_texture_attach(fbl->main_color_fb, dtxl->depth, 0, 0);
GPU_framebuffer_bind(fbl->main_color_fb);
DRW_draw_pass(psl->transparent_pass);
GPU_framebuffer_bind(fbl->main_fb);
GPU_framebuffer_texture_detach(fbl->main_color_fb, dtxl->depth);
/* Result Z */
eevee_render_result_z(rl, viewname, rect, vedata, sldata);
/* Post Process */
source/blender/draw/engines/gooengine/eevee_renderpasses.cc
+73 -65
View File
@@ -56,8 +56,8 @@ enum eRenderPassPostProcessType {
EEVEE_RENDER_PASS_ENVIRONMENT)
bool EEVEE_renderpasses_only_first_sample_pass_active(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PrivateData *g_data = stl->g_data;
return (g_data->render_passes & ~EEVEE_RENDERPASSES_POST_PROCESS_ON_FIRST_SAMPLE) == 0;
}
@@ -71,8 +71,8 @@ uint EEVEE_renderpasses_aov_hash(const ViewLayerAOV *aov)
void EEVEE_renderpasses_init(EEVEE_Data *vedata)
{
const DRWContextState *draw_ctx = DRW_context_state_get();
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PrivateData *g_data = stl->g_data;
ViewLayer *view_layer = draw_ctx->view_layer;
View3D *v3d = draw_ctx->v3d;
@@ -154,9 +154,11 @@ void EEVEE_renderpasses_output_init(EEVEE_ViewLayerData *sldata,
EEVEE_Data *vedata,
uint tot_samples)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
EEVEE_PrivateData *g_data = stl->g_data;
const bool needs_post_processing = (g_data->render_passes &
EEVEE_RENDERPASSES_WITH_POST_PROCESSING) > 0;
@@ -166,9 +168,9 @@ void EEVEE_renderpasses_output_init(EEVEE_ViewLayerData *sldata,
/* Should be enough to store the data needs for a single pass.
* Some passes will use less, but it is only relevant for final renderings and
* when renderpasses other than `EEVEE_RENDER_PASS_COMBINED` are requested */
DRW_texture_ensure_fullscreen_2d(&inst->renderpass, GPU_RGBA16F, DRWTextureFlag(0));
GPU_framebuffer_ensure_config(&inst->renderpass_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(inst->renderpass)});
DRW_texture_ensure_fullscreen_2d(&txl->renderpass, GPU_RGBA16F, DRWTextureFlag(0));
GPU_framebuffer_ensure_config(&fbl->renderpass_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(txl->renderpass)});
if ((g_data->render_passes & EEVEE_RENDERPASSES_MATERIAL) != 0) {
EEVEE_material_output_init(sldata, vedata, tot_samples);
@@ -196,15 +198,15 @@ void EEVEE_renderpasses_output_init(EEVEE_ViewLayerData *sldata,
}
/* We set a default texture as not all post processes uses the inputBuffer. */
g_data->renderpass_input = inst->color;
g_data->renderpass_col_input = inst->color;
g_data->renderpass_light_input = inst->color;
g_data->renderpass_transmittance_input = inst->color;
g_data->renderpass_input = txl->color;
g_data->renderpass_col_input = txl->color;
g_data->renderpass_light_input = txl->color;
g_data->renderpass_transmittance_input = txl->color;
}
else {
/* Free unneeded memory */
DRW_TEXTURE_FREE_SAFE(inst->renderpass);
GPU_FRAMEBUFFER_FREE_SAFE(inst->renderpass_fb);
DRW_TEXTURE_FREE_SAFE(txl->renderpass);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->renderpass_fb);
}
/* Cryptomatte doesn't use the GPU shader for post processing */
@@ -215,16 +217,16 @@ void EEVEE_renderpasses_output_init(EEVEE_ViewLayerData *sldata,
void EEVEE_renderpasses_cache_finish(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_PassList *psl = vedata->psl;
EEVEE_PrivateData *g_data = vedata->stl->g_data;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
const bool needs_post_processing = (g_data->render_passes &
EEVEE_RENDERPASSES_WITH_POST_PROCESSING) > 0;
if (needs_post_processing) {
DRW_PASS_CREATE(inst->renderpass_pass, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->renderpass_pass, DRW_STATE_WRITE_COLOR);
DRWShadingGroup *grp = DRW_shgroup_create(EEVEE_shaders_renderpasses_post_process_sh_get(),
inst->renderpass_pass);
psl->renderpass_pass);
DRW_shgroup_uniform_texture_ref(grp, "inputBuffer", &g_data->renderpass_input);
DRW_shgroup_uniform_texture_ref(grp, "inputColorBuffer", &g_data->renderpass_col_input);
DRW_shgroup_uniform_texture_ref(
@@ -240,7 +242,7 @@ void EEVEE_renderpasses_cache_finish(EEVEE_ViewLayerData *sldata, EEVEE_Data *ve
DRW_shgroup_call(grp, DRW_cache_fullscreen_quad_get(), nullptr);
}
else {
inst->renderpass_pass = nullptr;
psl->renderpass_pass = nullptr;
}
}
@@ -249,9 +251,12 @@ void EEVEE_renderpasses_postprocess(EEVEE_ViewLayerData * /*sldata*/,
eViewLayerEEVEEPassType renderpass_type,
int aov_index)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PrivateData *g_data = stl->g_data;
EEVEE_EffectsInfo *effects = stl->effects;
/* Compensate for taa_current_sample being incremented after last drawing in
* EEVEE_temporal_sampling_draw when DRW_state_is_image_render(). */
@@ -263,14 +268,14 @@ void EEVEE_renderpasses_postprocess(EEVEE_ViewLayerData * /*sldata*/,
const bool volumetric_active = eevee_renderpasses_volumetric_active(effects, g_data);
eRenderPassPostProcessType default_color_pass_type =
volumetric_active ? PASS_POST_ACCUMULATED_TRANSMITTANCE_COLOR : PASS_POST_ACCUMULATED_COLOR;
g_data->renderpass_transmittance_input = volumetric_active ? inst->volume_transmittance_accum :
inst->color;
g_data->renderpass_transmittance_input = volumetric_active ? txl->volume_transmittance_accum :
txl->color;
if (!volumetric_active && renderpass_type == EEVEE_RENDER_PASS_VOLUME_LIGHT) {
/* Early exit: Volumetric effect is off, but the volume light pass was requested. */
static float clear_col[4] = {0.0f};
GPU_framebuffer_bind(inst->renderpass_fb);
GPU_framebuffer_clear_color(inst->renderpass_fb, clear_col);
GPU_framebuffer_bind(fbl->renderpass_fb);
GPU_framebuffer_clear_color(fbl->renderpass_fb, clear_col);
return;
}
@@ -281,7 +286,7 @@ void EEVEE_renderpasses_postprocess(EEVEE_ViewLayerData * /*sldata*/,
}
case EEVEE_RENDER_PASS_AO: {
g_data->renderpass_postprocess = PASS_POST_AO;
g_data->renderpass_input = inst->ao_accum;
g_data->renderpass_input = txl->ao_accum;
break;
}
case EEVEE_RENDER_PASS_NORMAL: {
@@ -291,46 +296,46 @@ void EEVEE_renderpasses_postprocess(EEVEE_ViewLayerData * /*sldata*/,
}
case EEVEE_RENDER_PASS_MIST: {
g_data->renderpass_postprocess = PASS_POST_ACCUMULATED_VALUE;
g_data->renderpass_input = inst->mist_accum;
g_data->renderpass_input = txl->mist_accum;
break;
}
case EEVEE_RENDER_PASS_VOLUME_LIGHT: {
g_data->renderpass_postprocess = PASS_POST_ACCUMULATED_COLOR;
g_data->renderpass_input = inst->volume_scatter_accum;
g_data->renderpass_input = txl->volume_scatter_accum;
break;
}
case EEVEE_RENDER_PASS_SHADOW: {
g_data->renderpass_postprocess = PASS_POST_ACCUMULATED_VALUE;
g_data->renderpass_input = inst->shadow_accum;
g_data->renderpass_input = txl->shadow_accum;
break;
}
case EEVEE_RENDER_PASS_DIFFUSE_COLOR: {
g_data->renderpass_postprocess = default_color_pass_type;
g_data->renderpass_input = inst->diff_color_accum;
g_data->renderpass_input = txl->diff_color_accum;
break;
}
case EEVEE_RENDER_PASS_SPECULAR_COLOR: {
g_data->renderpass_postprocess = default_color_pass_type;
g_data->renderpass_input = inst->spec_color_accum;
g_data->renderpass_input = txl->spec_color_accum;
break;
}
case EEVEE_RENDER_PASS_ENVIRONMENT: {
g_data->renderpass_postprocess = default_color_pass_type;
g_data->renderpass_input = inst->env_accum;
g_data->renderpass_input = txl->env_accum;
break;
}
case EEVEE_RENDER_PASS_EMIT: {
g_data->renderpass_postprocess = default_color_pass_type;
g_data->renderpass_input = inst->emit_accum;
g_data->renderpass_input = txl->emit_accum;
break;
}
case EEVEE_RENDER_PASS_SPECULAR_LIGHT: {
g_data->renderpass_postprocess = PASS_POST_ACCUMULATED_LIGHT;
g_data->renderpass_input = inst->spec_light_accum;
g_data->renderpass_col_input = inst->spec_color_accum;
if ((inst->effects->enabled_effects & EFFECT_SSR) != 0) {
g_data->renderpass_input = txl->spec_light_accum;
g_data->renderpass_col_input = txl->spec_color_accum;
if ((stl->effects->enabled_effects & EFFECT_SSR) != 0) {
g_data->renderpass_postprocess = PASS_POST_TWO_LIGHT_BUFFERS;
g_data->renderpass_light_input = inst->ssr_accum;
g_data->renderpass_light_input = txl->ssr_accum;
}
else {
g_data->renderpass_postprocess = PASS_POST_ACCUMULATED_LIGHT;
@@ -339,11 +344,11 @@ void EEVEE_renderpasses_postprocess(EEVEE_ViewLayerData * /*sldata*/,
}
case EEVEE_RENDER_PASS_DIFFUSE_LIGHT: {
g_data->renderpass_postprocess = PASS_POST_ACCUMULATED_LIGHT;
g_data->renderpass_input = inst->diff_light_accum;
g_data->renderpass_col_input = inst->diff_color_accum;
if ((inst->effects->enabled_effects & EFFECT_SSS) != 0) {
g_data->renderpass_input = txl->diff_light_accum;
g_data->renderpass_col_input = txl->diff_color_accum;
if ((stl->effects->enabled_effects & EFFECT_SSS) != 0) {
g_data->renderpass_postprocess = PASS_POST_TWO_LIGHT_BUFFERS;
g_data->renderpass_light_input = inst->sss_accum;
g_data->renderpass_light_input = txl->sss_accum;
}
else {
g_data->renderpass_postprocess = PASS_POST_ACCUMULATED_LIGHT;
@@ -352,17 +357,17 @@ void EEVEE_renderpasses_postprocess(EEVEE_ViewLayerData * /*sldata*/,
}
case EEVEE_RENDER_PASS_AOV: {
g_data->renderpass_postprocess = PASS_POST_ACCUMULATED_COLOR_ALPHA;
g_data->renderpass_input = inst->aov_surface_accum[aov_index];
g_data->renderpass_input = txl->aov_surface_accum[aov_index];
break;
}
case EEVEE_RENDER_PASS_TRANSPARENT: {
g_data->renderpass_postprocess = PASS_POST_ACCUMULATED_COLOR_ALPHA;
g_data->renderpass_input = inst->transparent_accum;
g_data->renderpass_input = txl->transparent_accum;
break;
}
case EEVEE_RENDER_PASS_BLOOM: {
g_data->renderpass_postprocess = PASS_POST_ACCUMULATED_COLOR;
g_data->renderpass_input = inst->bloom_accum;
g_data->renderpass_input = txl->bloom_accum;
g_data->renderpass_current_sample = 1;
break;
}
@@ -370,17 +375,17 @@ void EEVEE_renderpasses_postprocess(EEVEE_ViewLayerData * /*sldata*/,
break;
}
}
GPU_framebuffer_bind(inst->renderpass_fb);
DRW_draw_pass(inst->renderpass_pass);
GPU_framebuffer_bind(fbl->renderpass_fb);
DRW_draw_pass(psl->renderpass_pass);
}
void EEVEE_renderpasses_output_accumulate(EEVEE_ViewLayerData *sldata,
EEVEE_Data *vedata,
bool post_effect)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
EEVEE_PrivateData *g_data = stl->g_data;
eViewLayerEEVEEPassType render_pass = g_data->render_passes;
if (!post_effect) {
@@ -414,16 +419,18 @@ void EEVEE_renderpasses_output_accumulate(EEVEE_ViewLayerData *sldata,
void EEVEE_renderpasses_draw(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get();
/* We can only draw a single render-pass. Light-passes also select their color pass
* (a second pass). We mask the light pass when a light pass is selected. */
const eViewLayerEEVEEPassType render_pass =
((inst->g_data->render_passes & EEVEE_RENDERPASSES_LIGHT_PASS) != 0) ?
(inst->g_data->render_passes & EEVEE_RENDERPASSES_LIGHT_PASS) :
inst->g_data->render_passes;
((stl->g_data->render_passes & EEVEE_RENDERPASSES_LIGHT_PASS) != 0) ?
(stl->g_data->render_passes & EEVEE_RENDERPASSES_LIGHT_PASS) :
stl->g_data->render_passes;
bool is_valid = (render_pass & EEVEE_RENDERPASSES_ALL) != 0;
bool needs_color_transfer = (render_pass & EEVEE_RENDERPASSES_COLOR_PASS) != 0 &&
@@ -436,8 +443,8 @@ void EEVEE_renderpasses_draw(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
is_valid = false;
}
const int current_sample = inst->effects->taa_current_sample;
const int total_samples = inst->effects->taa_total_sample;
const int current_sample = stl->effects->taa_current_sample;
const int total_samples = stl->effects->taa_total_sample;
if ((render_pass & EEVEE_RENDERPASSES_POST_PROCESS_ON_FIRST_SAMPLE) &&
(current_sample > 1 && total_samples != 1))
{
@@ -447,7 +454,7 @@ void EEVEE_renderpasses_draw(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
if (is_valid) {
EEVEE_renderpasses_postprocess(sldata, vedata, render_pass, 0);
GPU_framebuffer_bind(dfbl->default_fb);
DRW_transform_none(inst->renderpass);
DRW_transform_none(txl->renderpass);
}
else {
/* Draw state is not valid for this pass, clear the buffer */
@@ -455,19 +462,20 @@ void EEVEE_renderpasses_draw(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
GPU_framebuffer_bind(dfbl->default_fb);
GPU_framebuffer_clear_color(dfbl->default_fb, clear_color);
}
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
void EEVEE_renderpasses_draw_debug(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
GPUTexture *tx = nullptr;
/* Debug : Output buffer to view. */
switch (G.debug_value) {
case 1:
tx = inst->maxzbuffer;
tx = txl->maxzbuffer;
break;
case 2:
/* UNUSED */
@@ -479,7 +487,7 @@ void EEVEE_renderpasses_draw_debug(EEVEE_Data *vedata)
tx = effects->ssr_specrough_input;
break;
case 5:
tx = inst->color_double_buffer;
tx = txl->color_double_buffer;
break;
case 6:
tx = effects->gtao_horizons_renderpass;
source/blender/draw/engines/gooengine/eevee_screen_raytrace.cc
+78 -64
View File
@@ -21,9 +21,10 @@
int EEVEE_screen_raytrace_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_CommonUniformBuffer *common_data = &sldata->common_data;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_EffectsInfo *effects = stl->effects;
const float *viewport_size = DRW_viewport_size_get();
const DRWContextState *draw_ctx = DRW_context_state_get();
@@ -37,14 +38,14 @@ int EEVEE_screen_raytrace_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
effects->ssr_was_persp = is_persp;
DRW_viewport_request_redraw();
EEVEE_temporal_sampling_reset(vedata);
inst->g_data->valid_double_buffer = false;
stl->g_data->valid_double_buffer = false;
}
if (!effects->ssr_was_valid_double_buffer) {
DRW_viewport_request_redraw();
EEVEE_temporal_sampling_reset(vedata);
}
effects->ssr_was_valid_double_buffer = inst->g_data->valid_double_buffer;
effects->ssr_was_valid_double_buffer = stl->g_data->valid_double_buffer;
effects->reflection_trace_full = (scene_eval->eevee.flag & SCE_EEVEE_SSR_HALF_RESOLUTION) == 0;
common_data->ssr_thickness = scene_eval->eevee.ssr_thickness;
@@ -76,7 +77,7 @@ int EEVEE_screen_raytrace_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
effects->ssr_specrough_input = DRW_texture_pool_query_2d_ex(
UNPACK2(size_fs), format, usage, static_cast<DrawEngineType *>(owner));
GPU_framebuffer_texture_attach(inst->main_fb, effects->ssr_specrough_input, 2, 0);
GPU_framebuffer_texture_attach(fbl->main_fb, effects->ssr_specrough_input, 2, 0);
/* Ray-tracing output. */
effects->ssr_hit_output = DRW_texture_pool_query_2d_ex(
@@ -84,7 +85,7 @@ int EEVEE_screen_raytrace_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
effects->ssr_hit_depth = DRW_texture_pool_query_2d_ex(
UNPACK2(tracing_res), GPU_R16F, usage, static_cast<DrawEngineType *>(owner));
GPU_framebuffer_ensure_config(&inst->screen_tracing_fb,
GPU_framebuffer_ensure_config(&fbl->screen_tracing_fb,
{
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(effects->ssr_hit_output),
@@ -102,7 +103,7 @@ int EEVEE_screen_raytrace_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
}
/* Cleanup to release memory */
GPU_FRAMEBUFFER_FREE_SAFE(inst->screen_tracing_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->screen_tracing_fb);
effects->ssr_specrough_input = nullptr;
effects->ssr_hit_output = nullptr;
@@ -111,9 +112,11 @@ int EEVEE_screen_raytrace_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
void EEVEE_screen_raytrace_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
LightCache *lcache = inst->g_data->light_cache;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_EffectsInfo *effects = stl->effects;
LightCache *lcache = stl->g_data->light_cache;
if ((effects->enabled_effects & EFFECT_SSR) != 0) {
GPUShader *trace_shader = EEVEE_shaders_effect_reflection_trace_sh_get();
@@ -136,15 +139,15 @@ void EEVEE_screen_raytrace_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *v
* mipmap for each ray using its PDF. (filtered importance sampling)
* We then evaluate the lighting from the probes and mix the results together.
*/
DRW_PASS_CREATE(inst->ssr_raytrace, DRW_STATE_WRITE_COLOR);
DRWShadingGroup *grp = DRW_shgroup_create(trace_shader, inst->ssr_raytrace);
DRW_PASS_CREATE(psl->ssr_raytrace, DRW_STATE_WRITE_COLOR);
DRWShadingGroup *grp = DRW_shgroup_create(trace_shader, psl->ssr_raytrace);
DRW_shgroup_uniform_texture_ref(grp, "normalBuffer", &effects->ssr_normal_input);
DRW_shgroup_uniform_texture_ref(grp, "specroughBuffer", &effects->ssr_specrough_input);
DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &inst->maxzbuffer);
DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &txl->maxzbuffer);
#ifdef __APPLE__
/* planarDepth: Use dummy 2D array if not available */
if (inst->planar_depth != nullptr) {
DRW_shgroup_uniform_texture_ref(grp, "planarDepth", &inst->planar_depth);
if (txl->planar_depth != nullptr) {
DRW_shgroup_uniform_texture_ref(grp, "planarDepth", &txl->planar_depth);
}
else {
DRW_shgroup_uniform_texture(grp, "planarDepth", EEVEE_materials_get_dummy_2d_array());
@@ -171,19 +174,20 @@ void EEVEE_screen_raytrace_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *v
DRW_shgroup_uniform_texture(grp, "horizonBuffer", EEVEE_materials_get_util_tex());
}
/* probePlanars: 2D array fallback */
if (inst->planar_pool != nullptr) {
DRW_shgroup_uniform_texture_ref(grp, "probePlanars", &inst->planar_pool);
if (txl->planar_pool != nullptr) {
DRW_shgroup_uniform_texture_ref(grp, "probePlanars", &txl->planar_pool);
}
else {
DRW_shgroup_uniform_texture(grp, "probePlanars", EEVEE_materials_get_dummy_2d_array());
}
#else
DRW_shgroup_uniform_texture_ref(grp, "planarDepth", &inst->planar_depth);
DRW_shgroup_uniform_texture_ref(grp, "planarDepth", &txl->planar_depth);
DRW_shgroup_uniform_texture_ref(grp, "probeCubes", &lcache->cube_tx.tex);
DRW_shgroup_uniform_texture_ref(grp, "irradianceGrid", &lcache->grid_tx.tex);
DRW_shgroup_uniform_texture_ref(grp, "horizonBuffer", &effects->gtao_horizons);
DRW_shgroup_uniform_texture_ref(grp, "probePlanars", &inst->planar_pool);
DRW_shgroup_uniform_texture_ref(grp, "probePlanars", &txl->planar_pool);
#endif
DRW_shgroup_uniform_texture(grp, "utilTex", EEVEE_materials_get_util_tex());
DRW_shgroup_uniform_block(grp, "grid_block", sldata->grid_ubo);
DRW_shgroup_uniform_block(grp, "probe_block", sldata->probe_ubo);
@@ -204,14 +208,14 @@ void EEVEE_screen_raytrace_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *v
if (i == 0) {
/* Prepare Reflection Probes resolve pass. */
GPUShader *resolve_shader_probe = EEVEE_shaders_effect_reflection_resolve_probe_sh_get();
DRW_PASS_CREATE(inst->ssr_resolve_probe, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD);
grp = DRW_shgroup_create(resolve_shader_probe, inst->ssr_resolve_probe);
DRW_PASS_CREATE(psl->ssr_resolve_probe, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD);
grp = DRW_shgroup_create(resolve_shader_probe, psl->ssr_resolve_probe);
}
else if (i == 1) {
/* Prepare SSR resolve pass. */
GPUShader *resolve_shader_refl = EEVEE_shaders_effect_reflection_resolve_refl_sh_get();
DRW_PASS_CREATE(inst->ssr_resolve_refl, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD);
grp = DRW_shgroup_create(resolve_shader_refl, inst->ssr_resolve_refl);
DRW_PASS_CREATE(psl->ssr_resolve_refl, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD);
grp = DRW_shgroup_create(resolve_shader_refl, psl->ssr_resolve_refl);
}
DRW_shgroup_uniform_texture_ref(grp, "normalBuffer", &effects->ssr_normal_input);
@@ -225,32 +229,33 @@ void EEVEE_screen_raytrace_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *v
else {
DRW_shgroup_uniform_texture(grp, "probeCubes", EEVEE_materials_get_dummy_cube_array());
}
if (inst->planar_pool != nullptr) {
DRW_shgroup_uniform_texture_ref(grp, "probePlanars", &inst->planar_pool);
if (vedata->txl->planar_pool != nullptr) {
DRW_shgroup_uniform_texture_ref(grp, "probePlanars", &vedata->txl->planar_pool);
}
else {
DRW_shgroup_uniform_texture(grp, "probePlanars", EEVEE_materials_get_dummy_2d_array());
}
if (inst->planar_depth != nullptr) {
DRW_shgroup_uniform_texture_ref(grp, "planarDepth", &inst->planar_depth);
if (vedata->txl->planar_depth != nullptr) {
DRW_shgroup_uniform_texture_ref(grp, "planarDepth", &vedata->txl->planar_depth);
}
else {
DRW_shgroup_uniform_texture(grp, "planarDepth", EEVEE_materials_get_dummy_2d_array());
}
#else
DRW_shgroup_uniform_texture_ref(grp, "probeCubes", &lcache->cube_tx.tex);
DRW_shgroup_uniform_texture_ref(grp, "probePlanars", &inst->planar_pool);
DRW_shgroup_uniform_texture_ref(grp, "planarDepth", &inst->planar_depth);
DRW_shgroup_uniform_texture_ref(grp, "probePlanars", &vedata->txl->planar_pool);
DRW_shgroup_uniform_texture_ref(grp, "planarDepth", &vedata->txl->planar_depth);
#endif
DRW_shgroup_uniform_texture_ref_ex(grp, "hitBuffer", &effects->ssr_hit_output, no_filter);
DRW_shgroup_uniform_texture_ref_ex(grp, "hitDepth", &effects->ssr_hit_depth, no_filter);
DRW_shgroup_uniform_texture_ref(grp, "colorBuffer", &inst->filtered_radiance);
DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &inst->maxzbuffer);
DRW_shgroup_uniform_texture_ref(grp, "colorBuffer", &vedata->txl->filtered_radiance);
DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &vedata->txl->maxzbuffer);
DRW_shgroup_uniform_texture_ref(grp, "shadowCubeTexture", &sldata->shadow_cube_pool);
DRW_shgroup_uniform_texture_ref(grp, "shadowCascadeTexture", &sldata->shadow_cascade_pool);
DRW_shgroup_uniform_texture_ref(grp, "shadowCubeIDTexture", &sldata->shadow_cube_id_pool);
DRW_shgroup_uniform_texture_ref(
grp, "shadowCascadeIDTexture", &sldata->shadow_cascade_id_pool);
#ifdef __APPLE__
/* irradianceGrid: Check if texture is 2D array (not cube array).
* On Metal, we need to verify it's the correct type. */
@@ -287,18 +292,18 @@ void EEVEE_screen_raytrace_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *v
}
else {
/* Prepare standard reflections resolve pass. */
DRW_PASS_CREATE(inst->ssr_resolve, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD);
grp = DRW_shgroup_create(resolve_shader, inst->ssr_resolve);
DRW_PASS_CREATE(psl->ssr_resolve, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD);
grp = DRW_shgroup_create(resolve_shader, psl->ssr_resolve);
DRW_shgroup_uniform_texture_ref(grp, "normalBuffer", &effects->ssr_normal_input);
DRW_shgroup_uniform_texture_ref(grp, "specroughBuffer", &effects->ssr_specrough_input);
DRW_shgroup_uniform_texture_ref(grp, "probeCubes", &lcache->cube_tx.tex);
DRW_shgroup_uniform_texture_ref(grp, "probePlanars", &inst->planar_pool);
DRW_shgroup_uniform_texture_ref(grp, "planarDepth", &inst->planar_depth);
DRW_shgroup_uniform_texture_ref(grp, "probePlanars", &vedata->txl->planar_pool);
DRW_shgroup_uniform_texture_ref(grp, "planarDepth", &vedata->txl->planar_depth);
DRW_shgroup_uniform_texture_ref_ex(grp, "hitBuffer", &effects->ssr_hit_output, no_filter);
DRW_shgroup_uniform_texture_ref_ex(grp, "hitDepth", &effects->ssr_hit_depth, no_filter);
DRW_shgroup_uniform_texture_ref(grp, "colorBuffer", &inst->filtered_radiance);
DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &inst->maxzbuffer);
DRW_shgroup_uniform_texture_ref(grp, "colorBuffer", &txl->filtered_radiance);
DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &txl->maxzbuffer);
DRW_shgroup_uniform_texture_ref(grp, "shadowCubeTexture", &sldata->shadow_cube_pool);
DRW_shgroup_uniform_texture_ref(grp, "shadowCascadeTexture", &sldata->shadow_cascade_pool);
DRW_shgroup_uniform_texture_ref(grp, "shadowCubeIDTexture", &sldata->shadow_cube_id_pool);
@@ -332,42 +337,48 @@ void EEVEE_screen_raytrace_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *v
void EEVEE_refraction_compute(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
if ((effects->enabled_effects & EFFECT_REFRACT) != 0) {
EEVEE_effects_downsample_radiance_buffer(vedata, inst->color);
EEVEE_effects_downsample_radiance_buffer(vedata, txl->color);
/* Restore */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}
void EEVEE_reflection_compute(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_EffectsInfo *effects = stl->effects;
if (((effects->enabled_effects & EFFECT_SSR) != 0) && stl->g_data->valid_double_buffer) {
if (((effects->enabled_effects & EFFECT_SSR) != 0) && inst->g_data->valid_double_buffer) {
/* Ray-trace. */
GPU_framebuffer_bind(inst->screen_tracing_fb);
DRW_draw_pass(inst->ssr_raytrace);
GPU_framebuffer_bind(fbl->screen_tracing_fb);
DRW_draw_pass(psl->ssr_raytrace);
EEVEE_effects_downsample_radiance_buffer(vedata, inst->color_double_buffer);
EEVEE_effects_downsample_radiance_buffer(vedata, txl->color_double_buffer);
GPU_framebuffer_bind(inst->main_color_fb);
GPU_framebuffer_bind(fbl->main_color_fb);
if (effects->use_split_ssr_pass) {
/* Trace reflections for probes and SSR independently */
DRW_draw_pass(inst->ssr_resolve_probe);
DRW_draw_pass(inst->ssr_resolve_refl);
DRW_draw_pass(psl->ssr_resolve_probe);
DRW_draw_pass(psl->ssr_resolve_refl);
}
else {
DRW_draw_pass(inst->ssr_resolve);
DRW_draw_pass(psl->ssr_resolve);
}
/* Restore */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}
@@ -375,36 +386,39 @@ void EEVEE_reflection_output_init(EEVEE_ViewLayerData * /*sldata*/,
EEVEE_Data *vedata,
uint tot_samples)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_TextureList *txl = vedata->txl;
/* Create FrameBuffer. */
const eGPUTextureFormat texture_format = (tot_samples > 256) ? GPU_RGBA32F : GPU_RGBA16F;
DRW_texture_ensure_fullscreen_2d(&inst->ssr_accum, texture_format, DRWTextureFlag(0));
DRW_texture_ensure_fullscreen_2d(&txl->ssr_accum, texture_format, DRWTextureFlag(0));
GPU_framebuffer_ensure_config(&inst->ssr_accum_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(inst->ssr_accum)});
GPU_framebuffer_ensure_config(&fbl->ssr_accum_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(txl->ssr_accum)});
}
void EEVEE_reflection_output_accumulate(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
if (inst->g_data->valid_double_buffer) {
GPU_framebuffer_bind(inst->ssr_accum_fb);
if (stl->g_data->valid_double_buffer) {
GPU_framebuffer_bind(fbl->ssr_accum_fb);
/* Clear texture. */
if (effects->taa_current_sample == 1) {
const float clear[4] = {0.0f, 0.0f, 0.0f, 0.0f};
GPU_framebuffer_clear_color(inst->ssr_accum_fb, clear);
GPU_framebuffer_clear_color(fbl->ssr_accum_fb, clear);
}
if (effects->use_split_ssr_pass) {
DRW_draw_pass(inst->ssr_resolve_probe);
DRW_draw_pass(inst->ssr_resolve_refl);
DRW_draw_pass(psl->ssr_resolve_probe);
DRW_draw_pass(psl->ssr_resolve_refl);
}
else {
DRW_draw_pass(inst->ssr_resolve);
DRW_draw_pass(psl->ssr_resolve);
}
}
}
source/blender/draw/engines/gooengine/eevee_shaders.cc
+2 -3
View File
@@ -1421,7 +1421,6 @@ GPUMaterial *EEVEE_material_default_get(Scene *scene, Material *ma, int options)
GPUMaterial *EEVEE_material_get(
EEVEE_Data *vedata, Scene *scene, Material *ma, World *wo, int options)
{
GOOENGINE_Instance *inst = vedata->instance;
if ((ma && (!ma->use_nodes || !ma->nodetree)) || (wo && (!wo->use_nodes || !wo->nodetree))) {
options |= VAR_DEFAULT;
}
@@ -1446,12 +1445,12 @@ GPUMaterial *EEVEE_material_get(
/* Determine optimization status for remaining compilations counter. */
int optimization_status = GPU_material_optimization_status(mat);
if (optimization_status == GPU_MAT_OPTIMIZATION_QUEUED) {
inst->g_data->queued_optimise_shaders_count++;
vedata->stl->g_data->queued_optimise_shaders_count++;
}
break;
}
case GPU_MAT_QUEUED: {
inst->g_data->queued_shaders_count++;
vedata->stl->g_data->queued_shaders_count++;
GPUMaterial *default_mat = EEVEE_material_default_get(scene, ma, options);
/* Mark pending material with its default material for future cache warming. */
GPU_material_set_default(mat, default_mat);
source/blender/draw/engines/gooengine/eevee_shadows.cc
+25 -22
View File
@@ -91,8 +91,9 @@ void EEVEE_shadows_init(EEVEE_ViewLayerData *sldata)
void EEVEE_shadows_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_LightsInfo *linfo = sldata->lights;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PassList *psl = vedata->psl;
EEVEE_ShadowCasterBuffer *backbuffer = linfo->shcaster_backbuffer;
EEVEE_ShadowCasterBuffer *frontbuffer = linfo->shcaster_frontbuffer;
@@ -110,12 +111,11 @@ void EEVEE_shadows_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
INIT_MINMAX(linfo->shcaster_aabb.min, linfo->shcaster_aabb.max);
{
DRWState state = DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_SHADOW_OFFSET |
DRW_STATE_WRITE_COLOR;
DRW_PASS_CREATE(inst->shadow_pass, state);
DRWState state = DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_SHADOW_OFFSET | DRW_STATE_WRITE_COLOR;
DRW_PASS_CREATE(psl->shadow_pass, state);
inst->g_data->shadow_shgrp = DRW_shgroup_create(EEVEE_shaders_shadow_sh_get(),
inst->shadow_pass);
stl->g_data->shadow_shgrp = DRW_shgroup_create(EEVEE_shaders_shadow_sh_get(),
psl->shadow_pass);
}
}
@@ -205,8 +205,8 @@ static bool sphere_bbox_intersect(const BoundSphere *bs, const EEVEE_BoundBox *b
void EEVEE_shadows_update(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
EEVEE_LightsInfo *linfo = sldata->lights;
EEVEE_ShadowCasterBuffer *backbuffer = linfo->shcaster_backbuffer;
EEVEE_ShadowCasterBuffer *frontbuffer = linfo->shcaster_frontbuffer;
@@ -400,21 +400,23 @@ void EEVEE_shadow_output_init(EEVEE_ViewLayerData *sldata,
EEVEE_Data *vedata,
uint /*tot_samples*/)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_PassList *psl = vedata->psl;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
/* Create FrameBuffer. */
const eGPUTextureFormat texture_format = GPU_R32F;
DRW_texture_ensure_fullscreen_2d(&inst->shadow_accum, texture_format, DRWTextureFlag(0));
DRW_texture_ensure_fullscreen_2d(&txl->shadow_accum, texture_format, DRWTextureFlag(0));
GPU_framebuffer_ensure_config(&inst->shadow_accum_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(inst->shadow_accum)});
GPU_framebuffer_ensure_config(&fbl->shadow_accum_fb,
{GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(txl->shadow_accum)});
/* Create Pass and shgroup. */
DRW_PASS_CREATE(inst->shadow_accum_pass,
DRW_PASS_CREATE(psl->shadow_accum_pass,
DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_ALWAYS | DRW_STATE_BLEND_ADD_FULL);
DRWShadingGroup *grp = DRW_shgroup_create(EEVEE_shaders_shadow_accum_sh_get(),
inst->shadow_accum_pass);
psl->shadow_accum_pass);
DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
DRW_shgroup_uniform_texture(grp, "utilTex", EEVEE_materials_get_util_tex());
DRW_shgroup_uniform_block(grp, "probe_block", sldata->probe_ubo);
@@ -434,10 +436,12 @@ void EEVEE_shadow_output_init(EEVEE_ViewLayerData *sldata,
void EEVEE_shadow_output_accumulate(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_PassList *psl = vedata->psl;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
if (inst->shadow_accum_fb != nullptr) {
GPU_framebuffer_bind(inst->shadow_accum_fb);
if (fbl->shadow_accum_fb != nullptr) {
GPU_framebuffer_bind(fbl->shadow_accum_fb);
/* Clear texture. */
#ifdef __APPLE__
@@ -445,19 +449,18 @@ void EEVEE_shadow_output_accumulate(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data
* when switching between viewports/workspaces. This fixes issue where
* shadow intensity changes unexpectedly due to TAA not resetting properly. */
const float clear[4] = {0.0f, 0.0f, 0.0f, 0.0f};
GPU_framebuffer_clear_color(inst->shadow_accum_fb, clear);
GPU_framebuffer_clear_color(fbl->shadow_accum_fb, clear);
#else
EEVEE_EffectsInfo *effects = inst->effects;
if (effects->taa_current_sample == 1) {
const float clear[4] = {0.0f, 0.0f, 0.0f, 0.0f};
GPU_framebuffer_clear_color(inst->shadow_accum_fb, clear);
GPU_framebuffer_clear_color(fbl->shadow_accum_fb, clear);
}
#endif
DRW_draw_pass(inst->shadow_accum_pass);
DRW_draw_pass(psl->shadow_accum_pass);
/* Restore */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}
source/blender/draw/engines/gooengine/eevee_shadows_cascade.cc
+5 -4
View File
@@ -404,9 +404,10 @@ void EEVEE_shadows_draw_cascades(EEVEE_ViewLayerData *sldata,
DRWView *view,
int cascade_index)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
EEVEE_PrivateData *g_data = stl->g_data;
EEVEE_LightsInfo *linfo = sldata->lights;
EEVEE_Light *evli = linfo->light_data + linfo->shadow_cascade_light_indices[cascade_index];
@@ -437,6 +438,6 @@ void EEVEE_shadows_draw_cascades(EEVEE_ViewLayerData *sldata,
sldata->shadow_fb, sldata->shadow_cascade_id_pool, 1, layer, 0);
GPU_framebuffer_bind(sldata->shadow_fb);
GPU_framebuffer_clear_depth(sldata->shadow_fb, 1.0f);
DRW_draw_pass(inst->shadow_pass);
DRW_draw_pass(psl->shadow_pass);
}
}
source/blender/draw/engines/gooengine/eevee_shadows_cube.cc
+4 -3
View File
@@ -177,8 +177,9 @@ static bool spot_angle_fit_single_face(const EEVEE_Light *evli)
void EEVEE_shadows_draw_cubemap(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, int cube_index)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_PrivateData *g_data = inst->g_data;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PrivateData *g_data = stl->g_data;
EEVEE_LightsInfo *linfo = sldata->lights;
EEVEE_Light *evli = linfo->light_data + linfo->shadow_cube_light_indices[cube_index];
@@ -218,7 +219,7 @@ void EEVEE_shadows_draw_cubemap(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata,
sldata->shadow_fb, sldata->shadow_cube_id_pool, 1, layer, 0);
GPU_framebuffer_bind(sldata->shadow_fb);
GPU_framebuffer_clear_depth(sldata->shadow_fb, 1.0f);
DRW_draw_pass(inst->shadow_pass);
DRW_draw_pass(psl->shadow_pass);
}
BLI_BITMAP_SET(&linfo->sh_cube_update[0], cube_index, false);
source/blender/draw/engines/gooengine/eevee_subsurface.cc
+76 -64
View File
@@ -24,8 +24,10 @@ void EEVEE_subsurface_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data * /*veda
void EEVEE_subsurface_draw_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_TextureList *txl = vedata->txl;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
const float *viewport_size = DRW_viewport_size_get();
const int fs_size[2] = {int(viewport_size[0]), int(viewport_size[1])};
@@ -55,42 +57,42 @@ void EEVEE_subsurface_draw_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
* Blit depth instead and use sss_stencil's depth as depth texture,
* and dtxl->depth as stencil mask. */
GPU_framebuffer_ensure_config(
&inst->sss_blit_fb, {GPU_ATTACHMENT_TEXTURE(effects->sss_stencil), GPU_ATTACHMENT_NONE});
&fbl->sss_blit_fb, {GPU_ATTACHMENT_TEXTURE(effects->sss_stencil), GPU_ATTACHMENT_NONE});
stencil_tex = dtxl->depth;
}
GPU_framebuffer_ensure_config(
&inst->sss_blur_fb,
&fbl->sss_blur_fb,
{GPU_ATTACHMENT_TEXTURE(stencil_tex), GPU_ATTACHMENT_TEXTURE(effects->sss_blur)});
GPU_framebuffer_ensure_config(
&inst->sss_resolve_fb,
{GPU_ATTACHMENT_TEXTURE(stencil_tex), GPU_ATTACHMENT_TEXTURE(inst->color)});
&fbl->sss_resolve_fb,
{GPU_ATTACHMENT_TEXTURE(stencil_tex), GPU_ATTACHMENT_TEXTURE(txl->color)});
GPU_framebuffer_ensure_config(
&inst->sss_translucency_fb,
&fbl->sss_translucency_fb,
{GPU_ATTACHMENT_TEXTURE(stencil_tex), GPU_ATTACHMENT_TEXTURE(effects->sss_irradiance)});
GPU_framebuffer_ensure_config(&inst->sss_clear_fb,
GPU_framebuffer_ensure_config(&fbl->sss_clear_fb,
{GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(effects->sss_irradiance),
GPU_ATTACHMENT_TEXTURE(effects->sss_radius)});
if ((inst->g_data->render_passes & EEVEE_RENDER_PASS_DIFFUSE_LIGHT) != 0) {
if ((stl->g_data->render_passes & EEVEE_RENDER_PASS_DIFFUSE_LIGHT) != 0) {
EEVEE_subsurface_output_init(sldata, vedata, 0);
}
else {
GPU_FRAMEBUFFER_FREE_SAFE(inst->sss_accum_fb);
DRW_TEXTURE_FREE_SAFE(inst->sss_accum);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->sss_accum_fb);
DRW_TEXTURE_FREE_SAFE(txl->sss_accum);
}
}
else {
/* Cleanup to release memory */
GPU_FRAMEBUFFER_FREE_SAFE(inst->sss_blur_fb);
GPU_FRAMEBUFFER_FREE_SAFE(inst->sss_resolve_fb);
GPU_FRAMEBUFFER_FREE_SAFE(inst->sss_clear_fb);
GPU_FRAMEBUFFER_FREE_SAFE(inst->sss_accum_fb);
DRW_TEXTURE_FREE_SAFE(inst->sss_accum);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->sss_blur_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->sss_resolve_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->sss_clear_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->sss_accum_fb);
DRW_TEXTURE_FREE_SAFE(txl->sss_accum);
effects->sss_stencil = nullptr;
effects->sss_blur = nullptr;
effects->sss_irradiance = nullptr;
@@ -102,12 +104,14 @@ void EEVEE_subsurface_output_init(EEVEE_ViewLayerData * /*sldata*/,
EEVEE_Data *vedata,
uint /*tot_samples*/)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
const eGPUTextureFormat texture_format_light = GPU_RGBA32F;
const bool texture_created = inst->sss_accum == nullptr;
DRW_texture_ensure_fullscreen_2d(&inst->sss_accum, texture_format_light, DRWTextureFlag(0));
const bool texture_created = txl->sss_accum == nullptr;
DRW_texture_ensure_fullscreen_2d(&txl->sss_accum, texture_format_light, DRWTextureFlag(0));
GPUTexture *stencil_tex = effects->sss_stencil;
@@ -120,8 +124,8 @@ void EEVEE_subsurface_output_init(EEVEE_ViewLayerData * /*sldata*/,
}
GPU_framebuffer_ensure_config(
&inst->sss_accum_fb,
{GPU_ATTACHMENT_TEXTURE(stencil_tex), GPU_ATTACHMENT_TEXTURE(inst->sss_accum)});
&fbl->sss_accum_fb,
{GPU_ATTACHMENT_TEXTURE(stencil_tex), GPU_ATTACHMENT_TEXTURE(txl->sss_accum)});
/* Clear texture.
* Due to the late initialization of the SSS it can happen that the `taa_current_sample` is
@@ -130,16 +134,16 @@ void EEVEE_subsurface_output_init(EEVEE_ViewLayerData * /*sldata*/,
* are cleared. */
if (effects->taa_current_sample == 1 || texture_created) {
const float clear[4] = {0.0f, 0.0f, 0.0f, 0.0f};
GPU_framebuffer_bind(inst->sss_accum_fb);
GPU_framebuffer_clear_color(inst->sss_accum_fb, clear);
GPU_framebuffer_bind(fbl->sss_accum_fb);
GPU_framebuffer_clear_color(fbl->sss_accum_fb, clear);
}
}
void EEVEE_subsurface_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_CommonUniformBuffer *common_data = &sldata->common_data;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
EEVEE_PassList *psl = vedata->psl;
const DRWContextState *draw_ctx = DRW_context_state_get();
const Scene *scene_eval = DEG_get_evaluated_scene(draw_ctx->depsgraph);
@@ -151,9 +155,9 @@ void EEVEE_subsurface_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata
/* Screen Space SubSurface Scattering overview.
* TODO */
DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_STENCIL_EQUAL;
DRW_PASS_CREATE(inst->sss_blur_ps, state);
DRW_PASS_CREATE(inst->sss_resolve_ps, state | DRW_STATE_BLEND_ADD);
DRW_PASS_CREATE(inst->sss_translucency_ps, state | DRW_STATE_BLEND_ADD);
DRW_PASS_CREATE(psl->sss_blur_ps, state);
DRW_PASS_CREATE(psl->sss_resolve_ps, state | DRW_STATE_BLEND_ADD);
DRW_PASS_CREATE(psl->sss_translucency_ps, state | DRW_STATE_BLEND_ADD);
}
void EEVEE_subsurface_add_pass(EEVEE_ViewLayerData *sldata,
@@ -162,14 +166,15 @@ void EEVEE_subsurface_add_pass(EEVEE_ViewLayerData *sldata,
DRWShadingGroup *shgrp,
GPUMaterial *gpumat)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
GPUTexture **depth_src = GPU_depth_blitting_workaround() ? &effects->sss_stencil : &dtxl->depth;
GPUTexture *sss_tex_profile = nullptr;
GPUUniformBuf *sss_profile = GPU_material_sss_profile_get(
gpumat, inst->effects->sss_sample_count, &sss_tex_profile);
gpumat, stl->effects->sss_sample_count, &sss_tex_profile);
if (!sss_profile) {
BLI_assert_msg(0, "SSS pass requested but no SSS data was found");
@@ -191,7 +196,7 @@ void EEVEE_subsurface_add_pass(EEVEE_ViewLayerData *sldata,
GPUSamplerState state = GPUSamplerState::default_sampler();
DRWShadingGroup *grp = DRW_shgroup_create(EEVEE_shaders_subsurface_first_pass_sh_get(),
inst->sss_blur_ps);
psl->sss_blur_ps);
DRW_shgroup_uniform_texture(grp, "utilTex", EEVEE_materials_get_util_tex());
DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", depth_src);
DRW_shgroup_uniform_texture_ref_ex(grp, "sssIrradiance", &effects->sss_irradiance, state);
@@ -202,7 +207,7 @@ void EEVEE_subsurface_add_pass(EEVEE_ViewLayerData *sldata,
DRW_shgroup_stencil_mask(grp, sss_id);
DRW_shgroup_call_procedural_triangles(grp, nullptr, 1);
grp = DRW_shgroup_create(EEVEE_shaders_subsurface_second_pass_sh_get(), inst->sss_resolve_ps);
grp = DRW_shgroup_create(EEVEE_shaders_subsurface_second_pass_sh_get(), psl->sss_resolve_ps);
DRW_shgroup_uniform_texture(grp, "utilTex", EEVEE_materials_get_util_tex());
DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", depth_src);
DRW_shgroup_uniform_texture_ref_ex(grp, "sssIrradiance", &effects->sss_blur, state);
@@ -217,7 +222,7 @@ void EEVEE_subsurface_add_pass(EEVEE_ViewLayerData *sldata,
if (ma->blend_flag & MA_BL_TRANSLUCENCY) {
DRWShadingGroup *grp = DRW_shgroup_create(EEVEE_shaders_subsurface_translucency_sh_get(),
inst->sss_translucency_ps);
psl->sss_translucency_ps);
DRW_shgroup_uniform_texture(grp, "utilTex", EEVEE_materials_get_util_tex());
DRW_shgroup_uniform_texture(grp, "sssTexProfile", sss_tex_profile);
DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", depth_src);
@@ -236,16 +241,18 @@ void EEVEE_subsurface_add_pass(EEVEE_ViewLayerData *sldata,
void EEVEE_subsurface_data_render(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
if ((effects->enabled_effects & EFFECT_SSS) != 0) {
const float clear[4] = {0.0f, 0.0f, 0.0f, 0.0f};
/* Clear sss_data texture only... can this be done in a more clever way? */
GPU_framebuffer_bind(inst->sss_clear_fb);
GPU_framebuffer_clear_color(inst->sss_clear_fb, clear);
GPU_framebuffer_bind(fbl->sss_clear_fb);
GPU_framebuffer_clear_color(fbl->sss_clear_fb, clear);
GPU_framebuffer_ensure_config(&inst->main_fb,
GPU_framebuffer_ensure_config(&fbl->main_fb,
{GPU_ATTACHMENT_LEAVE,
GPU_ATTACHMENT_LEAVE,
GPU_ATTACHMENT_LEAVE,
@@ -254,11 +261,11 @@ void EEVEE_subsurface_data_render(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *
GPU_ATTACHMENT_TEXTURE(effects->sss_radius),
GPU_ATTACHMENT_TEXTURE(effects->sss_albedo)});
GPU_framebuffer_bind(inst->main_fb);
DRW_draw_pass(inst->material_sss_ps);
GPU_framebuffer_bind(fbl->main_fb);
DRW_draw_pass(psl->material_sss_ps);
/* Restore */
GPU_framebuffer_ensure_config(&inst->main_fb,
GPU_framebuffer_ensure_config(&fbl->main_fb,
{GPU_ATTACHMENT_LEAVE,
GPU_ATTACHMENT_LEAVE,
GPU_ATTACHMENT_LEAVE,
@@ -271,29 +278,32 @@ void EEVEE_subsurface_data_render(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *
void EEVEE_subsurface_compute(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_EffectsInfo *effects = stl->effects;
if ((effects->enabled_effects & EFFECT_SSS) != 0) {
const float clear[4] = {0.0f, 0.0f, 0.0f, 0.0f};
if (GPU_depth_blitting_workaround()) {
/* Copy depth channel */
GPU_framebuffer_blit(inst->main_fb, 0, inst->sss_blit_fb, 0, GPU_DEPTH_BIT);
GPU_framebuffer_blit(fbl->main_fb, 0, fbl->sss_blit_fb, 0, GPU_DEPTH_BIT);
}
else {
/* Copy stencil channel, could be avoided (see EEVEE_subsurface_init) */
GPU_framebuffer_blit(inst->main_fb, 0, inst->sss_blur_fb, 0, GPU_STENCIL_BIT);
GPU_framebuffer_blit(fbl->main_fb, 0, fbl->sss_blur_fb, 0, GPU_STENCIL_BIT);
}
if (!DRW_pass_is_empty(inst->sss_translucency_ps)) {
if (!DRW_pass_is_empty(psl->sss_translucency_ps)) {
/* We sample the shadow-maps using normal sampler. We need to disable Comparison mode.
* TODO(fclem): avoid this by using sampler objects. */
GPU_texture_compare_mode(sldata->shadow_cube_pool, false);
GPU_texture_compare_mode(sldata->shadow_cascade_pool, false);
GPU_framebuffer_bind(inst->sss_translucency_fb);
DRW_draw_pass(inst->sss_translucency_ps);
GPU_framebuffer_bind(fbl->sss_translucency_fb);
DRW_draw_pass(psl->sss_translucency_ps);
/* Reset original state. */
GPU_texture_compare_mode(sldata->shadow_cube_pool, true);
@@ -301,33 +311,35 @@ void EEVEE_subsurface_compute(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
}
/* 1. horizontal pass */
GPU_framebuffer_bind(inst->sss_blur_fb);
GPU_framebuffer_clear_color(inst->sss_blur_fb, clear);
DRW_draw_pass(inst->sss_blur_ps);
GPU_framebuffer_bind(fbl->sss_blur_fb);
GPU_framebuffer_clear_color(fbl->sss_blur_fb, clear);
DRW_draw_pass(psl->sss_blur_ps);
/* 2. vertical pass + Resolve */
GPU_framebuffer_texture_attach(inst->sss_resolve_fb, inst->color, 0, 0);
GPU_framebuffer_bind(inst->sss_resolve_fb);
DRW_draw_pass(inst->sss_resolve_ps);
GPU_framebuffer_texture_attach(fbl->sss_resolve_fb, txl->color, 0, 0);
GPU_framebuffer_bind(fbl->sss_resolve_fb);
DRW_draw_pass(psl->sss_resolve_ps);
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}
void EEVEE_subsurface_output_accumulate(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
if (((effects->enabled_effects & EFFECT_SSS) != 0) && (inst->sss_accum_fb != nullptr)) {
if (((effects->enabled_effects & EFFECT_SSS) != 0) && (fbl->sss_accum_fb != nullptr)) {
/* Copy stencil channel, could be avoided (see EEVEE_subsurface_init) */
GPU_framebuffer_blit(inst->main_fb, 0, inst->sss_accum_fb, 0, GPU_STENCIL_BIT);
GPU_framebuffer_blit(fbl->main_fb, 0, fbl->sss_accum_fb, 0, GPU_STENCIL_BIT);
/* Only do vertical pass + Resolve */
GPU_framebuffer_bind(inst->sss_accum_fb);
DRW_draw_pass(inst->sss_resolve_ps);
GPU_framebuffer_bind(fbl->sss_accum_fb);
DRW_draw_pass(psl->sss_resolve_ps);
/* Restore */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}
source/blender/draw/engines/gooengine/eevee_temporal_sampling.cc
+35 -32
View File
@@ -186,8 +186,8 @@ void EEVEE_temporal_sampling_matrices_calc(EEVEE_EffectsInfo *effects, const dou
void EEVEE_temporal_sampling_update_matrices(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_StorageList *stl = ((EEVEE_Data *)vedata)->stl;
EEVEE_EffectsInfo *effects = stl->effects;
double ht_point[2];
double ht_offset[2] = {0.0, 0.0};
@@ -202,15 +202,13 @@ void EEVEE_temporal_sampling_update_matrices(EEVEE_Data *vedata)
void EEVEE_temporal_sampling_reset(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
inst->effects->taa_render_sample = 1;
inst->effects->taa_current_sample = 1;
vedata->stl->effects->taa_render_sample = 1;
vedata->stl->effects->taa_current_sample = 1;
}
void EEVEE_temporal_sampling_create_view(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
/* Create a sub view to disable clipping planes (if any). */
const DRWView *default_view = DRW_view_default_get();
float viewmat[4][4], winmat[4][4];
@@ -220,7 +218,7 @@ void EEVEE_temporal_sampling_create_view(EEVEE_Data *vedata)
DRW_view_clip_planes_set(effects->taa_view, nullptr, 0);
}
int EEVEE_temporal_sampling_sample_count_get(const Scene *scene, const GOOENGINE_Instance *inst)
int EEVEE_temporal_sampling_sample_count_get(const Scene *scene, const EEVEE_StorageList *stl)
{
const bool is_render = DRW_state_is_image_render();
const DRWContextState *draw_ctx = DRW_context_state_get();
@@ -234,22 +232,22 @@ int EEVEE_temporal_sampling_sample_count_get(const Scene *scene, const GOOENGINE
int sample_count = is_render ? render_samples : scene->eevee.taa_samples;
int timesteps = is_render ? inst->g_data->render_timesteps : 1;
int timesteps = is_render ? stl->g_data->render_timesteps : 1;
sample_count = max_ii(0, sample_count);
sample_count = (sample_count == 0) ? TAA_MAX_SAMPLE : sample_count;
sample_count = divide_ceil_u(sample_count, timesteps);
int dof_sample_count = EEVEE_depth_of_field_sample_count_get(
inst->effects, sample_count, nullptr);
stl->effects, sample_count, nullptr);
sample_count = dof_sample_count * divide_ceil_u(sample_count, dof_sample_count);
return sample_count;
}
int EEVEE_temporal_sampling_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
int repro_flag = 0;
if (!e_data.inited) {
@@ -281,16 +279,16 @@ int EEVEE_temporal_sampling_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *v
/* Until we support reprojection, we need to make sure
* that the history buffer contains correct information. */
bool view_is_valid = inst->g_data->valid_double_buffer;
bool view_is_valid = stl->g_data->valid_double_buffer;
view_is_valid = view_is_valid && (inst->g_data->view_updated == false);
view_is_valid = view_is_valid && (stl->g_data->view_updated == false);
if (draw_ctx->evil_C != nullptr) {
wmWindowManager *wm = CTX_wm_manager(draw_ctx->evil_C);
view_is_valid = view_is_valid && (ED_screen_animation_no_scrub(wm) == nullptr);
}
effects->taa_total_sample = EEVEE_temporal_sampling_sample_count_get(scene_eval, inst);
effects->taa_total_sample = EEVEE_temporal_sampling_sample_count_get(scene_eval, stl);
if (EEVEE_renderpasses_only_first_sample_pass_active(vedata)) {
view_is_valid = false;
@@ -325,7 +323,7 @@ int EEVEE_temporal_sampling_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *v
}
}
else {
const bool all_shaders_compiled = inst->g_data->queued_shaders_count_prev == 0;
const bool all_shaders_compiled = stl->g_data->queued_shaders_count_prev == 0;
/* Fix Texture painting (see #79370) and shader compilation (see #78520). */
if (DRW_state_is_navigating() || !all_shaders_compiled) {
effects->taa_current_sample = 1;
@@ -346,16 +344,18 @@ int EEVEE_temporal_sampling_init(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *v
void EEVEE_temporal_sampling_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_EffectsInfo *effects = stl->effects;
if (effects->enabled_effects & EFFECT_TAA) {
GPUShader *sh = EEVEE_shaders_taa_resolve_sh_get(effects->enabled_effects);
DRW_PASS_CREATE(inst->taa_resolve, DRW_STATE_WRITE_COLOR);
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->taa_resolve);
DRW_PASS_CREATE(psl->taa_resolve, DRW_STATE_WRITE_COLOR);
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->taa_resolve);
DRW_shgroup_uniform_texture_ref(grp, "colorHistoryBuffer", &inst->taa_history);
DRW_shgroup_uniform_texture_ref(grp, "colorHistoryBuffer", &txl->taa_history);
DRW_shgroup_uniform_texture_ref(grp, "colorBuffer", &effects->source_buffer);
DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
DRW_shgroup_uniform_block(grp, "renderpass_block", sldata->renderpass_ubo.combined);
@@ -374,8 +374,11 @@ void EEVEE_temporal_sampling_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data
void EEVEE_temporal_sampling_draw(EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
if ((effects->enabled_effects & (EFFECT_TAA | EFFECT_TAA_REPROJECT)) != 0) {
if ((effects->enabled_effects & EFFECT_TAA) != 0 && effects->taa_current_sample != 1) {
@@ -388,10 +391,10 @@ void EEVEE_temporal_sampling_draw(EEVEE_Data *vedata)
}
GPU_framebuffer_bind(effects->target_buffer);
DRW_draw_pass(inst->taa_resolve);
DRW_draw_pass(psl->taa_resolve);
/* Restore the depth from sample 1. */
GPU_framebuffer_blit(inst->double_buffer_depth_fb, 0, inst->main_fb, 0, GPU_DEPTH_BIT);
GPU_framebuffer_blit(fbl->double_buffer_depth_fb, 0, fbl->main_fb, 0, GPU_DEPTH_BIT);
SWAP_BUFFERS_TAA();
}
@@ -399,22 +402,22 @@ void EEVEE_temporal_sampling_draw(EEVEE_Data *vedata)
/* Save the depth buffer for the next frame.
* This saves us from doing anything special
* in the other mode engines. */
GPU_framebuffer_blit(inst->main_fb, 0, inst->double_buffer_depth_fb, 0, GPU_DEPTH_BIT);
GPU_framebuffer_blit(fbl->main_fb, 0, fbl->double_buffer_depth_fb, 0, GPU_DEPTH_BIT);
/* Do reprojection for noise reduction */
/* TODO: do AA jitter if in only render view. */
if (!DRW_state_is_image_render() && (effects->enabled_effects & EFFECT_TAA_REPROJECT) != 0 &&
inst->g_data->valid_taa_history)
stl->g_data->valid_taa_history)
{
GPU_framebuffer_bind(effects->target_buffer);
DRW_draw_pass(inst->taa_resolve);
DRW_draw_pass(psl->taa_resolve);
SWAP_BUFFERS_TAA();
}
else {
GPUFrameBuffer *source_fb = (effects->target_buffer == inst->main_color_fb) ?
inst->effect_color_fb :
inst->main_color_fb;
GPU_framebuffer_blit(source_fb, 0, inst->taa_history_color_fb, 0, GPU_COLOR_BIT);
GPUFrameBuffer *source_fb = (effects->target_buffer == fbl->main_color_fb) ?
fbl->effect_color_fb :
fbl->main_color_fb;
GPU_framebuffer_blit(source_fb, 0, fbl->taa_history_color_fb, 0, GPU_COLOR_BIT);
}
}
source/blender/draw/engines/gooengine/eevee_volumes.cc
+131 -120
View File
@@ -64,8 +64,10 @@ void EEVEE_volumes_set_jitter(EEVEE_ViewLayerData *sldata, uint current_sample)
void EEVEE_volumes_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_EffectsInfo *effects = stl->effects;
EEVEE_CommonUniformBuffer *common_data = &sldata->common_data;
const DRWContextState *draw_ctx = DRW_context_state_get();
@@ -99,17 +101,17 @@ void EEVEE_volumes_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
(common_data->vol_tex_size[1] != tex_size[1]) ||
(common_data->vol_tex_size[2] != tex_size[2]))
{
DRW_TEXTURE_FREE_SAFE(inst->volume_prop_scattering);
DRW_TEXTURE_FREE_SAFE(inst->volume_prop_extinction);
DRW_TEXTURE_FREE_SAFE(inst->volume_prop_emission);
DRW_TEXTURE_FREE_SAFE(inst->volume_prop_phase);
DRW_TEXTURE_FREE_SAFE(inst->volume_scatter);
DRW_TEXTURE_FREE_SAFE(inst->volume_transmit);
DRW_TEXTURE_FREE_SAFE(inst->volume_scatter_history);
DRW_TEXTURE_FREE_SAFE(inst->volume_transmit_history);
GPU_FRAMEBUFFER_FREE_SAFE(inst->volumetric_fb);
GPU_FRAMEBUFFER_FREE_SAFE(inst->volumetric_scat_fb);
GPU_FRAMEBUFFER_FREE_SAFE(inst->volumetric_integ_fb);
DRW_TEXTURE_FREE_SAFE(txl->volume_prop_scattering);
DRW_TEXTURE_FREE_SAFE(txl->volume_prop_extinction);
DRW_TEXTURE_FREE_SAFE(txl->volume_prop_emission);
DRW_TEXTURE_FREE_SAFE(txl->volume_prop_phase);
DRW_TEXTURE_FREE_SAFE(txl->volume_scatter);
DRW_TEXTURE_FREE_SAFE(txl->volume_transmit);
DRW_TEXTURE_FREE_SAFE(txl->volume_scatter_history);
DRW_TEXTURE_FREE_SAFE(txl->volume_transmit_history);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->volumetric_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->volumetric_scat_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->volumetric_integ_fb);
copy_v3_v3_int(common_data->vol_tex_size, tex_size);
common_data->vol_inv_tex_size[0] = 1.0f / float(tex_size[0]);
@@ -118,7 +120,7 @@ void EEVEE_volumes_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
}
/* Like frostbite's paper, 5% blend of the new frame. */
common_data->vol_history_alpha = (inst->volume_prop_scattering == nullptr) ? 0.0f : 0.95f;
common_data->vol_history_alpha = (txl->volume_prop_scattering == nullptr) ? 0.0f : 0.95f;
/* Temporal Super sampling jitter */
const uint ht_primes[3] = {3, 7, 2};
@@ -202,8 +204,9 @@ void EEVEE_volumes_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
void EEVEE_volumes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
EEVEE_CommonUniformBuffer *common_data = &sldata->common_data;
const DRWContextState *draw_ctx = DRW_context_state_get();
@@ -237,8 +240,8 @@ void EEVEE_volumes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
*/
/* World pass is not additive as it also clear the buffer. */
DRW_PASS_CREATE(inst->volumetric_world_ps, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(inst->volumetric_objects_ps, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD);
DRW_PASS_CREATE(psl->volumetric_world_ps, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->volumetric_objects_ps, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD);
/* World Volumetric */
World *wo = scene->world;
@@ -248,7 +251,7 @@ void EEVEE_volumes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
GPUMaterial *mat = EEVEE_material_get(vedata, scene, nullptr, wo, VAR_MAT_VOLUME);
if (mat && GPU_material_has_volume_output(mat)) {
grp = DRW_shgroup_material_create(mat, inst->volumetric_world_ps);
grp = DRW_shgroup_material_create(mat, psl->volumetric_world_ps);
}
if (grp) {
@@ -272,7 +275,7 @@ void EEVEE_volumes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
if (grp == nullptr) {
/* If no world or volume material is present just clear the buffer with this drawcall */
grp = DRW_shgroup_create(EEVEE_shaders_volumes_clear_sh_get(), inst->volumetric_world_ps);
grp = DRW_shgroup_create(EEVEE_shaders_volumes_clear_sh_get(), psl->volumetric_world_ps);
DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
DRW_shgroup_uniform_block(grp, "grid_block", sldata->grid_ubo);
DRW_shgroup_uniform_block(grp, "probe_block", sldata->probe_ubo);
@@ -290,7 +293,6 @@ void EEVEE_volumes_cache_object_add(EEVEE_ViewLayerData *sldata,
Scene *scene,
Object *ob)
{
GOOENGINE_Instance *inst = vedata->instance;
Material *ma = BKE_object_material_get_eval(ob, 1);
if (ma == nullptr) {
@@ -325,7 +327,7 @@ void EEVEE_volumes_cache_object_add(EEVEE_ViewLayerData *sldata,
/* TODO(fclem): Reuse main shading group to avoid shading binding cost just like for surface
* shaders. */
DRWShadingGroup *grp = DRW_shgroup_create(sh, inst->volumetric_objects_ps);
DRWShadingGroup *grp = DRW_shgroup_create(sh, vedata->psl->volumetric_objects_ps);
grp = DRW_shgroup_volume_create_sub(scene, ob, grp, mat);
@@ -347,36 +349,36 @@ void EEVEE_volumes_cache_object_add(EEVEE_ViewLayerData *sldata,
/* TODO: Preemptive culling. */
DRW_shgroup_call_procedural_triangles(grp, ob, sldata->common_data.vol_tex_size[2]);
inst->effects->enabled_effects |= (EFFECT_VOLUMETRIC | EFFECT_POST_BUFFER);
vedata->stl->effects->enabled_effects |= (EFFECT_VOLUMETRIC | EFFECT_POST_BUFFER);
}
void EEVEE_volumes_cache_finish(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
LightCache *lcache = inst->g_data->light_cache;
EEVEE_PassList *psl = vedata->psl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
LightCache *lcache = vedata->stl->g_data->light_cache;
EEVEE_CommonUniformBuffer *common_data = &sldata->common_data;
if ((effects->enabled_effects & EFFECT_VOLUMETRIC) != 0) {
DRWShadingGroup *grp;
GPUShader *sh;
DRW_PASS_CREATE(inst->volumetric_scatter_ps, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->volumetric_scatter_ps, DRW_STATE_WRITE_COLOR);
sh = (common_data->vol_use_lights) ? EEVEE_shaders_volumes_scatter_with_lights_sh_get() :
EEVEE_shaders_volumes_scatter_sh_get();
grp = DRW_shgroup_create(sh, inst->volumetric_scatter_ps);
grp = DRW_shgroup_create(sh, psl->volumetric_scatter_ps);
DRW_shgroup_uniform_texture_ref(grp, "irradianceGrid", &lcache->grid_tx.tex);
DRW_shgroup_uniform_texture_ref(grp, "shadowCubeTexture", &sldata->shadow_cube_pool);
DRW_shgroup_uniform_texture_ref(grp, "shadowCascadeTexture", &sldata->shadow_cascade_pool);
DRW_shgroup_uniform_texture_ref(grp, "shadowCubeIDTexture", &sldata->shadow_cube_id_pool);
DRW_shgroup_uniform_texture_ref(
grp, "shadowCascadeIDTexture", &sldata->shadow_cascade_id_pool);
DRW_shgroup_uniform_texture_ref(grp, "volumeScattering", &inst->volume_prop_scattering);
DRW_shgroup_uniform_texture_ref(grp, "volumeExtinction", &inst->volume_prop_extinction);
DRW_shgroup_uniform_texture_ref(grp, "volumeEmission", &inst->volume_prop_emission);
DRW_shgroup_uniform_texture_ref(grp, "volumePhase", &inst->volume_prop_phase);
DRW_shgroup_uniform_texture_ref(grp, "historyScattering", &inst->volume_scatter_history);
DRW_shgroup_uniform_texture_ref(grp, "historyTransmittance", &inst->volume_transmit_history);
DRW_shgroup_uniform_texture_ref(grp, "shadowCascadeIDTexture", &sldata->shadow_cascade_id_pool);
DRW_shgroup_uniform_texture_ref(grp, "volumeScattering", &txl->volume_prop_scattering);
DRW_shgroup_uniform_texture_ref(grp, "volumeExtinction", &txl->volume_prop_extinction);
DRW_shgroup_uniform_texture_ref(grp, "volumeEmission", &txl->volume_prop_emission);
DRW_shgroup_uniform_texture_ref(grp, "volumePhase", &txl->volume_prop_phase);
DRW_shgroup_uniform_texture_ref(grp, "historyScattering", &txl->volume_scatter_history);
DRW_shgroup_uniform_texture_ref(grp, "historyTransmittance", &txl->volume_transmit_history);
DRW_shgroup_uniform_block(grp, "light_block", sldata->light_ubo);
DRW_shgroup_uniform_block(grp, "shadow_block", sldata->shadow_ubo);
DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
@@ -385,27 +387,27 @@ void EEVEE_volumes_cache_finish(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
DRW_shgroup_call_procedural_triangles(grp, nullptr, common_data->vol_tex_size[2]);
DRW_PASS_CREATE(inst->volumetric_integration_ps, DRW_STATE_WRITE_COLOR);
DRW_PASS_CREATE(psl->volumetric_integration_ps, DRW_STATE_WRITE_COLOR);
grp = DRW_shgroup_create(EEVEE_shaders_volumes_integration_sh_get(),
inst->volumetric_integration_ps);
DRW_shgroup_uniform_texture_ref(grp, "volumeScattering", &inst->volume_scatter);
DRW_shgroup_uniform_texture_ref(grp, "volumeExtinction", &inst->volume_transmit);
psl->volumetric_integration_ps);
DRW_shgroup_uniform_texture_ref(grp, "volumeScattering", &txl->volume_scatter);
DRW_shgroup_uniform_texture_ref(grp, "volumeExtinction", &txl->volume_transmit);
DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
DRW_shgroup_uniform_block(grp, "probe_block", sldata->probe_ubo);
DRW_shgroup_uniform_block(grp, "renderpass_block", sldata->renderpass_ubo.combined);
if (USE_VOLUME_OPTI) {
DRW_shgroup_uniform_image_ref(grp, "finalScattering_img", &inst->volume_scatter_history);
DRW_shgroup_uniform_image_ref(grp, "finalTransmittance_img", &inst->volume_transmit_history);
DRW_shgroup_uniform_image_ref(grp, "finalScattering_img", &txl->volume_scatter_history);
DRW_shgroup_uniform_image_ref(grp, "finalTransmittance_img", &txl->volume_transmit_history);
}
DRW_shgroup_call_procedural_triangles(
grp, nullptr, USE_VOLUME_OPTI ? 1 : common_data->vol_tex_size[2]);
DRW_PASS_CREATE(inst->volumetric_resolve_ps, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_CUSTOM);
DRW_PASS_CREATE(psl->volumetric_resolve_ps, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_CUSTOM);
grp = DRW_shgroup_create(EEVEE_shaders_volumes_resolve_sh_get(false),
inst->volumetric_resolve_ps);
DRW_shgroup_uniform_texture_ref(grp, "inScattering", &inst->volume_scatter);
DRW_shgroup_uniform_texture_ref(grp, "inTransmittance", &inst->volume_transmit);
psl->volumetric_resolve_ps);
DRW_shgroup_uniform_texture_ref(grp, "inScattering", &txl->volume_scatter);
DRW_shgroup_uniform_texture_ref(grp, "inTransmittance", &txl->volume_transmit);
DRW_shgroup_uniform_texture_ref(grp, "inSceneDepth", &e_data.depth_src);
DRW_shgroup_uniform_block(grp, "light_block", sldata->light_ubo);
DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
@@ -419,39 +421,40 @@ void EEVEE_volumes_cache_finish(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
void EEVEE_volumes_draw_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
EEVEE_CommonUniformBuffer *common_data = &sldata->common_data;
if ((effects->enabled_effects & EFFECT_VOLUMETRIC) != 0) {
int *tex_size = common_data->vol_tex_size;
if (inst->volume_prop_scattering == nullptr) {
if (txl->volume_prop_scattering == nullptr) {
/* Volume properties: We evaluate all volumetric objects
* and store their final properties into each froxel */
eGPUTextureUsage usage = GPU_TEXTURE_USAGE_ATTACHMENT | GPU_TEXTURE_USAGE_SHADER_READ;
inst->volume_prop_scattering = DRW_texture_create_3d_ex(tex_size[0],
txl->volume_prop_scattering = DRW_texture_create_3d_ex(tex_size[0],
tex_size[1],
tex_size[2],
GPU_R11F_G11F_B10F,
usage,
DRW_TEX_FILTER,
nullptr);
inst->volume_prop_extinction = DRW_texture_create_3d_ex(tex_size[0],
txl->volume_prop_extinction = DRW_texture_create_3d_ex(tex_size[0],
tex_size[1],
tex_size[2],
GPU_R11F_G11F_B10F,
usage,
DRW_TEX_FILTER,
nullptr);
inst->volume_prop_emission = DRW_texture_create_3d_ex(tex_size[0],
txl->volume_prop_emission = DRW_texture_create_3d_ex(tex_size[0],
tex_size[1],
tex_size[2],
GPU_R11F_G11F_B10F,
usage,
DRW_TEX_FILTER,
nullptr);
inst->volume_prop_phase = DRW_texture_create_3d_ex(
txl->volume_prop_phase = DRW_texture_create_3d_ex(
tex_size[0], tex_size[1], tex_size[2], GPU_RG16F, usage, DRW_TEX_FILTER, nullptr);
/* Volume scattering: We compute for each froxel the
@@ -459,14 +462,14 @@ void EEVEE_volumes_draw_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
* super sampling during this stage. */
eGPUTextureUsage usage_write = GPU_TEXTURE_USAGE_ATTACHMENT | GPU_TEXTURE_USAGE_SHADER_READ |
GPU_TEXTURE_USAGE_SHADER_WRITE;
inst->volume_scatter = DRW_texture_create_3d_ex(tex_size[0],
txl->volume_scatter = DRW_texture_create_3d_ex(tex_size[0],
tex_size[1],
tex_size[2],
GPU_R11F_G11F_B10F,
usage_write,
DRW_TEX_FILTER,
nullptr);
inst->volume_transmit = DRW_texture_create_3d_ex(tex_size[0],
txl->volume_transmit = DRW_texture_create_3d_ex(tex_size[0],
tex_size[1],
tex_size[2],
GPU_R11F_G11F_B10F,
@@ -478,14 +481,14 @@ void EEVEE_volumes_draw_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
* amount of scattered light and extinction coefficient at this
* given depth. We use these textures as double buffer
* for the volumetric history. */
inst->volume_scatter_history = DRW_texture_create_3d_ex(tex_size[0],
txl->volume_scatter_history = DRW_texture_create_3d_ex(tex_size[0],
tex_size[1],
tex_size[2],
GPU_R11F_G11F_B10F,
usage_write,
DRW_TEX_FILTER,
nullptr);
inst->volume_transmit_history = DRW_texture_create_3d_ex(tex_size[0],
txl->volume_transmit_history = DRW_texture_create_3d_ex(tex_size[0],
tex_size[1],
tex_size[2],
GPU_R11F_G11F_B10F,
@@ -494,33 +497,33 @@ void EEVEE_volumes_draw_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
nullptr);
}
GPU_framebuffer_ensure_config(&inst->volumetric_fb,
GPU_framebuffer_ensure_config(&fbl->volumetric_fb,
{GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(inst->volume_prop_scattering),
GPU_ATTACHMENT_TEXTURE(inst->volume_prop_extinction),
GPU_ATTACHMENT_TEXTURE(inst->volume_prop_emission),
GPU_ATTACHMENT_TEXTURE(inst->volume_prop_phase)});
GPU_framebuffer_ensure_config(&inst->volumetric_scat_fb,
GPU_ATTACHMENT_TEXTURE(txl->volume_prop_scattering),
GPU_ATTACHMENT_TEXTURE(txl->volume_prop_extinction),
GPU_ATTACHMENT_TEXTURE(txl->volume_prop_emission),
GPU_ATTACHMENT_TEXTURE(txl->volume_prop_phase)});
GPU_framebuffer_ensure_config(&fbl->volumetric_scat_fb,
{GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(inst->volume_scatter),
GPU_ATTACHMENT_TEXTURE(inst->volume_transmit)});
GPU_framebuffer_ensure_config(&inst->volumetric_integ_fb,
GPU_ATTACHMENT_TEXTURE(txl->volume_scatter),
GPU_ATTACHMENT_TEXTURE(txl->volume_transmit)});
GPU_framebuffer_ensure_config(&fbl->volumetric_integ_fb,
{GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(inst->volume_scatter_history),
GPU_ATTACHMENT_TEXTURE(inst->volume_transmit_history)});
GPU_ATTACHMENT_TEXTURE(txl->volume_scatter_history),
GPU_ATTACHMENT_TEXTURE(txl->volume_transmit_history)});
}
else {
DRW_TEXTURE_FREE_SAFE(inst->volume_prop_scattering);
DRW_TEXTURE_FREE_SAFE(inst->volume_prop_extinction);
DRW_TEXTURE_FREE_SAFE(inst->volume_prop_emission);
DRW_TEXTURE_FREE_SAFE(inst->volume_prop_phase);
DRW_TEXTURE_FREE_SAFE(inst->volume_scatter);
DRW_TEXTURE_FREE_SAFE(inst->volume_transmit);
DRW_TEXTURE_FREE_SAFE(inst->volume_scatter_history);
DRW_TEXTURE_FREE_SAFE(inst->volume_transmit_history);
GPU_FRAMEBUFFER_FREE_SAFE(inst->volumetric_fb);
GPU_FRAMEBUFFER_FREE_SAFE(inst->volumetric_scat_fb);
GPU_FRAMEBUFFER_FREE_SAFE(inst->volumetric_integ_fb);
DRW_TEXTURE_FREE_SAFE(txl->volume_prop_scattering);
DRW_TEXTURE_FREE_SAFE(txl->volume_prop_extinction);
DRW_TEXTURE_FREE_SAFE(txl->volume_prop_emission);
DRW_TEXTURE_FREE_SAFE(txl->volume_prop_phase);
DRW_TEXTURE_FREE_SAFE(txl->volume_scatter);
DRW_TEXTURE_FREE_SAFE(txl->volume_transmit);
DRW_TEXTURE_FREE_SAFE(txl->volume_scatter_history);
DRW_TEXTURE_FREE_SAFE(txl->volume_transmit_history);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->volumetric_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->volumetric_scat_fb);
GPU_FRAMEBUFFER_FREE_SAFE(fbl->volumetric_integ_fb);
}
effects->volume_scatter = e_data.dummy_scatter;
@@ -529,48 +532,52 @@ void EEVEE_volumes_draw_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
void EEVEE_volumes_compute(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
if ((effects->enabled_effects & EFFECT_VOLUMETRIC) != 0) {
/* We sample the shadow-maps using shadow sampler. We need to enable Comparison mode.
* TODO(fclem): avoid this by using sampler objects. */
GPU_texture_compare_mode(sldata->shadow_cube_pool, true);
GPU_texture_compare_mode(sldata->shadow_cascade_pool, true);
GPU_framebuffer_bind(inst->volumetric_fb);
DRW_draw_pass(inst->volumetric_world_ps);
DRW_draw_pass(inst->volumetric_objects_ps);
GPU_framebuffer_bind(fbl->volumetric_fb);
DRW_draw_pass(psl->volumetric_world_ps);
DRW_draw_pass(psl->volumetric_objects_ps);
GPU_framebuffer_bind(inst->volumetric_scat_fb);
DRW_draw_pass(inst->volumetric_scatter_ps);
GPU_framebuffer_bind(fbl->volumetric_scat_fb);
DRW_draw_pass(psl->volumetric_scatter_ps);
if (USE_VOLUME_OPTI) {
/* Avoid feedback loop assert. */
GPU_framebuffer_bind(inst->volumetric_fb);
GPU_framebuffer_bind(fbl->volumetric_fb);
}
else {
GPU_framebuffer_bind(inst->volumetric_integ_fb);
GPU_framebuffer_bind(fbl->volumetric_integ_fb);
}
DRW_draw_pass(inst->volumetric_integration_ps);
DRW_draw_pass(psl->volumetric_integration_ps);
std::swap(inst->volumetric_scat_fb, inst->volumetric_integ_fb);
std::swap(inst->volume_scatter, inst->volume_scatter_history);
std::swap(inst->volume_transmit, inst->volume_transmit_history);
std::swap(fbl->volumetric_scat_fb, fbl->volumetric_integ_fb);
std::swap(txl->volume_scatter, txl->volume_scatter_history);
std::swap(txl->volume_transmit, txl->volume_transmit_history);
effects->volume_scatter = inst->volume_scatter;
effects->volume_transmit = inst->volume_transmit;
effects->volume_scatter = txl->volume_scatter;
effects->volume_transmit = txl->volume_transmit;
/* Restore */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}
void EEVEE_volumes_resolve(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_PassList *psl = vedata->psl;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
if ((effects->enabled_effects & EFFECT_VOLUMETRIC) != 0) {
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
@@ -581,11 +588,11 @@ void EEVEE_volumes_resolve(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
}
/* Apply for opaque geometry. */
GPU_framebuffer_bind(inst->main_color_fb);
DRW_draw_pass(inst->volumetric_resolve_ps);
GPU_framebuffer_bind(fbl->main_color_fb);
DRW_draw_pass(psl->volumetric_resolve_ps);
/* Restore. */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}
@@ -615,30 +622,33 @@ GPUTexture *EEVEE_volumes_get_dummy_transmit()
void EEVEE_volumes_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, uint tot_samples)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_TextureList *txl = vedata->txl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PassList *psl = vedata->psl;
EEVEE_EffectsInfo *effects = stl->effects;
/* Create FrameBuffer. */
/* Should be enough precision for many samples. */
const eGPUTextureFormat texture_format_accum = (tot_samples > 128) ? GPU_RGBA32F : GPU_RGBA16F;
DRW_texture_ensure_fullscreen_2d(
&inst->volume_scatter_accum, texture_format_accum, DRWTextureFlag(0));
&txl->volume_scatter_accum, texture_format_accum, DRWTextureFlag(0));
DRW_texture_ensure_fullscreen_2d(
&inst->volume_transmittance_accum, texture_format_accum, DRWTextureFlag(0));
&txl->volume_transmittance_accum, texture_format_accum, DRWTextureFlag(0));
GPU_framebuffer_ensure_config(&inst->volumetric_accum_fb,
GPU_framebuffer_ensure_config(&fbl->volumetric_accum_fb,
{GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(inst->volume_scatter_accum),
GPU_ATTACHMENT_TEXTURE(inst->volume_transmittance_accum)});
GPU_ATTACHMENT_TEXTURE(txl->volume_scatter_accum),
GPU_ATTACHMENT_TEXTURE(txl->volume_transmittance_accum)});
/* Create Pass and shgroup. */
DRW_PASS_CREATE(inst->volumetric_accum_ps, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD_FULL);
DRW_PASS_CREATE(psl->volumetric_accum_ps, DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD_FULL);
DRWShadingGroup *grp = nullptr;
if ((effects->enabled_effects & EFFECT_VOLUMETRIC) != 0) {
grp = DRW_shgroup_create(EEVEE_shaders_volumes_resolve_sh_get(true), inst->volumetric_accum_ps);
DRW_shgroup_uniform_texture_ref(grp, "inScattering", &inst->volume_scatter);
DRW_shgroup_uniform_texture_ref(grp, "inTransmittance", &inst->volume_transmit);
grp = DRW_shgroup_create(EEVEE_shaders_volumes_resolve_sh_get(true), psl->volumetric_accum_ps);
DRW_shgroup_uniform_texture_ref(grp, "inScattering", &txl->volume_scatter);
DRW_shgroup_uniform_texture_ref(grp, "inTransmittance", &txl->volume_transmit);
DRW_shgroup_uniform_texture_ref(grp, "inSceneDepth", &e_data.depth_src);
DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
DRW_shgroup_uniform_block(grp, "renderpass_block", sldata->renderpass_ubo.combined);
@@ -646,30 +656,31 @@ void EEVEE_volumes_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata,
else {
/* There is no volumetrics in the scene. Use a shader to fill the accum textures with a default
* value. */
grp = DRW_shgroup_create(EEVEE_shaders_volumes_accum_sh_get(), inst->volumetric_accum_ps);
grp = DRW_shgroup_create(EEVEE_shaders_volumes_accum_sh_get(), psl->volumetric_accum_ps);
}
DRW_shgroup_call(grp, DRW_cache_fullscreen_quad_get(), nullptr);
}
void EEVEE_volumes_output_accumulate(EEVEE_ViewLayerData * /*sldata*/, EEVEE_Data *vedata)
{
GOOENGINE_Instance *inst = vedata->instance;
EEVEE_EffectsInfo *effects = inst->effects;
EEVEE_FramebufferList *fbl = vedata->fbl;
EEVEE_PassList *psl = vedata->psl;
EEVEE_EffectsInfo *effects = vedata->stl->effects;
if (inst->volumetric_accum_fb != nullptr) {
if (fbl->volumetric_accum_fb != nullptr) {
/* Accumulation pass. */
GPU_framebuffer_bind(inst->volumetric_accum_fb);
GPU_framebuffer_bind(fbl->volumetric_accum_fb);
/* Clear texture. */
if (effects->taa_current_sample == 1) {
const float clear[4] = {0.0f, 0.0f, 0.0f, 0.0f};
GPU_framebuffer_clear_color(inst->volumetric_accum_fb, clear);
GPU_framebuffer_clear_color(fbl->volumetric_accum_fb, clear);
}
DRW_draw_pass(inst->volumetric_accum_ps);
DRW_draw_pass(psl->volumetric_accum_ps);
/* Restore */
GPU_framebuffer_bind(inst->main_fb);
GPU_framebuffer_bind(fbl->main_fb);
}
}