archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
2c545c0409a9bd44e815dbbd4eb7038797e65b23
blender-archive/source/blender/draw/engines/eevee/eevee_private.h

1026 lines
38 KiB
C++
Raw Normal View History

Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
/*
* Copyright 2016, Blender Foundation.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* Contributor(s): Blender Institute
*
*/
/** \file eevee_private.h
* \ingroup DNA
*/
Cleanup: style & header guards
2017-05-08 11:44:58 +10:00
#ifndef __EEVEE_PRIVATE_H__
#define __EEVEE_PRIVATE_H__
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
#include "DNA_lightprobe_types.h"
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
struct Object;
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
struct EEVEE_BoundSphere;
struct EEVEE_ShadowCasterBuffer;
Proper implementation of compositor support for Draw Manager We need to move the render result logic outside the render engine code. It makes no sense for Eevee/Clay/... to have to re-implement the render resilt creation logic. Beside the original implementation really got it wrong, by ignoring the different render layers needed for the final render. Finally, there is no need to re-create the logic for views. So this was also fixed. Note 1: This will break still if the depsgraph of the needed view layers is not updated / created. We need to address this separately. For now if users want to test this, just show each view layer in the viewport at least once. Note 2: We are still getting depsgraph from scene and creating if needed. `BKE_scene_get_depsgraph(scene, view_layer, true);` according to Sergey we need to move the render depsgraph for the Render struct instead. I will do it separately as well.
2018-02-20 10:14:23 -03:00
struct RenderLayer;
struct RenderResult;
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
struct GPUFrameBuffer;
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
Draw Manager: Make use of texture reuse.
2017-05-16 03:03:58 +02:00
extern struct DrawEngineType draw_engine_eevee_type;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
/* Minimum UBO is 16384 bytes */
Eevee: Material code refactor. Separate material handling inside another file. Make use of enums to identify shader variations. Group all 64*64 LUTs into one array texture. Only update world probe if world changes.
2017-06-04 12:12:58 +02:00
#define MAX_PROBE 128 /* TODO : find size by dividing UBO max size by probe data size */
Eevee: Add Irradiance Grid support Early implementation. Slow and still has quality 3 ways of storing irradiance: - Spherical Harmonics: Have problem with directionnal lighting. - HL2 diffuse cube: Very low resolution but smooth transitions. - Diffuse cube: High storage requirement. Also include some name change.
2017-06-13 17:39:39 +02:00
#define MAX_GRID 64 /* TODO : find size by dividing UBO max size by grid data size */
Eevee: Initial implementation of planar reflections. Still pretty barebone: No roughness support, No normal distortion support.
2017-06-17 00:08:03 +02:00
#define MAX_PLANAR 16 /* TODO : find size by dividing UBO max size by grid data size */
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
#define MAX_LIGHT 128 /* TODO : find size by dividing UBO max size by light data size */
#define MAX_CASCADE_NUM 4
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
#define MAX_SHADOW 256 /* TODO : Make this depends on GL_MAX_ARRAY_TEXTURE_LAYERS */
#define MAX_SHADOW_CASCADE 8
#define MAX_SHADOW_CUBE (MAX_SHADOW - MAX_CASCADE_NUM * MAX_SHADOW_CASCADE)
Eevee: Add Bloom post process. Based on Kino/Bloom v2 - Bloom filter for Unity MIT license.
2017-05-07 14:27:43 +02:00
#define MAX_BLOOM_STEP 16
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
Eevee: Add Irradiance Grid support Early implementation. Slow and still has quality 3 ways of storing irradiance: - Spherical Harmonics: Have problem with directionnal lighting. - HL2 diffuse cube: Very low resolution but smooth transitions. - Diffuse cube: High storage requirement. Also include some name change.
2017-06-13 17:39:39 +02:00
/* Only define one of these. */
// #define IRRADIANCE_SH_L2
// #define IRRADIANCE_CUBEMAP
#define IRRADIANCE_HL2
Eevee: Overhaul the volumetric system. The system now uses several 3D textures in order to decouple every steps of the volumetric rendering. See https://www.ea.com/frostbite/news/physically-based-unified-volumetric-rendering-in-frostbite for more details. On the technical side, instead of using a compute shader to populate the 3D textures we use layered rendering with a geometry shader to render 1 fullscreen triangle per 3D texture slice.
2017-10-24 14:49:00 +02:00
#if defined(IRRADIANCE_SH_L2)
Draw manager: Cleanup, indentation in preprocessor
2017-11-29 10:22:53 +01:00
# define SHADER_IRRADIANCE "#define IRRADIANCE_SH_L2\n"
Eevee: Overhaul the volumetric system. The system now uses several 3D textures in order to decouple every steps of the volumetric rendering. See https://www.ea.com/frostbite/news/physically-based-unified-volumetric-rendering-in-frostbite for more details. On the technical side, instead of using a compute shader to populate the 3D textures we use layered rendering with a geometry shader to render 1 fullscreen triangle per 3D texture slice.
2017-10-24 14:49:00 +02:00
#elif defined(IRRADIANCE_CUBEMAP)
Draw manager: Cleanup, indentation in preprocessor
2017-11-29 10:22:53 +01:00
# define SHADER_IRRADIANCE "#define IRRADIANCE_CUBEMAP\n"
Eevee: Overhaul the volumetric system. The system now uses several 3D textures in order to decouple every steps of the volumetric rendering. See https://www.ea.com/frostbite/news/physically-based-unified-volumetric-rendering-in-frostbite for more details. On the technical side, instead of using a compute shader to populate the 3D textures we use layered rendering with a geometry shader to render 1 fullscreen triangle per 3D texture slice.
2017-10-24 14:49:00 +02:00
#elif defined(IRRADIANCE_HL2)
Draw manager: Cleanup, indentation in preprocessor
2017-11-29 10:22:53 +01:00
# define SHADER_IRRADIANCE "#define IRRADIANCE_HL2\n"
Eevee: Overhaul the volumetric system. The system now uses several 3D textures in order to decouple every steps of the volumetric rendering. See https://www.ea.com/frostbite/news/physically-based-unified-volumetric-rendering-in-frostbite for more details. On the technical side, instead of using a compute shader to populate the 3D textures we use layered rendering with a geometry shader to render 1 fullscreen triangle per 3D texture slice.
2017-10-24 14:49:00 +02:00
#endif
#define SHADER_DEFINES \
"#define EEVEE_ENGINE\n" \
"#define MAX_PROBE " STRINGIFY(MAX_PROBE) "\n" \
"#define MAX_GRID " STRINGIFY(MAX_GRID) "\n" \
"#define MAX_PLANAR " STRINGIFY(MAX_PLANAR) "\n" \
"#define MAX_LIGHT " STRINGIFY(MAX_LIGHT) "\n" \
"#define MAX_SHADOW " STRINGIFY(MAX_SHADOW) "\n" \
"#define MAX_SHADOW_CUBE " STRINGIFY(MAX_SHADOW_CUBE) "\n" \
"#define MAX_SHADOW_CASCADE " STRINGIFY(MAX_SHADOW_CASCADE) "\n" \
"#define MAX_CASCADE_NUM " STRINGIFY(MAX_CASCADE_NUM) "\n" \
SHADER_IRRADIANCE
Eevee: Effects: Split each effect in it's own file. This also: - make sure to only compile the shader needed by the active effects. - same thing for the shading groups. - disable TAA if motion blur is active (avoid infinite refresh).
2017-11-01 01:03:36 +01:00
#define SWAP_DOUBLE_BUFFERS() { \
if (effects->swap_double_buffer) { \
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
SWAP(struct GPUFrameBuffer *, fbl->main_fb, fbl->double_buffer_fb); \
SWAP(struct GPUFrameBuffer *, fbl->main_color_fb, fbl->double_buffer_color_fb); \
Eevee: Effects: Split each effect in it's own file. This also: - make sure to only compile the shader needed by the active effects. - same thing for the shading groups. - disable TAA if motion blur is active (avoid infinite refresh).
2017-11-01 01:03:36 +01:00
SWAP(GPUTexture *, txl->color, txl->color_double_buffer); \
effects->swap_double_buffer = false; \
} \
} ((void)0)
#define SWAP_BUFFERS() { \
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
if (effects->target_buffer == fbl->effect_color_fb) { \
Eevee: Effects: Split each effect in it's own file. This also: - make sure to only compile the shader needed by the active effects. - same thing for the shading groups. - disable TAA if motion blur is active (avoid infinite refresh).
2017-11-01 01:03:36 +01:00
SWAP_DOUBLE_BUFFERS(); \
effects->source_buffer = txl->color_post; \
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
effects->target_buffer = fbl->main_color_fb; \
Eevee: Effects: Split each effect in it's own file. This also: - make sure to only compile the shader needed by the active effects. - same thing for the shading groups. - disable TAA if motion blur is active (avoid infinite refresh).
2017-11-01 01:03:36 +01:00
} \
else { \
SWAP_DOUBLE_BUFFERS(); \
effects->source_buffer = txl->color; \
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
effects->target_buffer = fbl->effect_color_fb; \
Eevee: Effects: Split each effect in it's own file. This also: - make sure to only compile the shader needed by the active effects. - same thing for the shading groups. - disable TAA if motion blur is active (avoid infinite refresh).
2017-11-01 01:03:36 +01:00
} \
} ((void)0)
Eevee: Depth of Feild: Fix ringing issue of background objects There was an issue caused by Antialiasing being done after DoF. Move TAA after DOF and Motion Blur. Also certain pixel with lower CoC would be spread all over the background because the neighbooring pixel have higher CoC. So we need to apply some bilateral filtering when downsampling. Currently we limit the influence of neighbor pixels with a CoC inside the range [MaxCoC-2, MaxCoC].
2018-09-09 23:24:06 +02:00
#define SWAP_BUFFERS_TAA() { \
if (effects->target_buffer == fbl->effect_color_fb) { \
SWAP(struct GPUFrameBuffer *, fbl->effect_fb, fbl->taa_history_fb); \
SWAP(struct GPUFrameBuffer *, fbl->effect_color_fb, fbl->taa_history_color_fb); \
SWAP(GPUTexture *, txl->color_post, txl->taa_history); \
effects->source_buffer = txl->taa_history; \
effects->target_buffer = fbl->effect_color_fb; \
} \
else { \
SWAP(struct GPUFrameBuffer *, fbl->main_fb, fbl->taa_history_fb); \
SWAP(struct GPUFrameBuffer *, fbl->main_color_fb, fbl->taa_history_color_fb); \
SWAP(GPUTexture *, txl->color, txl->taa_history); \
effects->source_buffer = txl->taa_history; \
effects->target_buffer = fbl->main_color_fb; \
} \
} ((void)0)
EEVEE: LookDev overlays enabling The mirror ball and diffuse ball are only rendered when overlays are turned on and the lookdev overlay is turned on.
2018-05-29 09:08:32 +02:00
#define OVERLAY_ENABLED(v3d) ((v3d) && (v3d->flag2 & V3D_RENDER_OVERRIDE) == 0)
Cleanup: moving shading type into View3DShading. So all shading settings are in this struct and can be reused in the OpenGL render engine.
2018-07-11 14:20:39 +02:00
#define LOOK_DEV_MODE_ENABLED(v3d) ((v3d) && (v3d->shading.type == OB_MATERIAL))
Cleanup: flag checks
2018-07-05 22:56:18 +02:00
#define LOOK_DEV_OVERLAY_ENABLED(v3d) (LOOK_DEV_MODE_ENABLED(v3d) && OVERLAY_ENABLED(v3d) && (v3d->overlay.flag & V3D_OVERLAY_LOOK_DEV))
Viewport: in Lookdev shading, disable scene lights and world by default. Now we light with just a user defined HDRI by default, which is useful for material setup and texture painting and lighting without having to set up any scene lights. Previously it would use the scene world without lights by default, which in some files is just black.
2018-07-06 18:53:51 +02:00
#define USE_SCENE_LIGHT(v3d) ((!v3d) || (!LOOK_DEV_MODE_ENABLED(v3d)) || ((LOOK_DEV_MODE_ENABLED(v3d) && (v3d->shading.flag & V3D_SHADING_SCENE_LIGHTS))))
#define LOOK_DEV_STUDIO_LIGHT_ENABLED(v3d) (LOOK_DEV_MODE_ENABLED(v3d) && !(v3d->shading.flag & V3D_SHADING_SCENE_WORLD))
EEVEE: LookDev overlays enabling The mirror ball and diffuse ball are only rendered when overlays are turned on and the lookdev overlay is turned on.
2018-05-29 09:08:32 +02:00
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
#define OCTAHEDRAL_SIZE_FROM_CUBESIZE(cube_size) ((int)ceilf(sqrtf((cube_size * cube_size) * 6.0f)))
#define MIN_CUBE_LOD_LEVEL 3
#define MAX_PLANAR_LOD_LEVEL 9
Eevee: Improve material variation managment. - Unify variations between default shaders and material shader. - Only create default shader passes if needed. Downside is that we have a big array of passes and shading grp in the vedata ... And it will double in size each time a new variation flag is added.
2017-06-22 02:41:17 +02:00
/* World shader variations */
enum {
Eevee: Volumetrics: Fix enum flag.
2017-07-05 22:16:48 +02:00
VAR_WORLD_BACKGROUND = 0,
VAR_WORLD_PROBE = 1,
VAR_WORLD_VOLUME = 2,
Eevee: Improve material variation managment. - Unify variations between default shaders and material shader. - Only create default shader passes if needed. Downside is that we have a big array of passes and shading grp in the vedata ... And it will double in size each time a new variation flag is added.
2017-06-22 02:41:17 +02:00
};
/* Material shader variations */
enum {
EEvEE: LookDev
2018-05-25 08:06:36 +02:00
VAR_MAT_MESH = (1 << 0),
VAR_MAT_PROBE = (1 << 1),
VAR_MAT_HAIR = (1 << 2),
VAR_MAT_FLAT = (1 << 3),
VAR_MAT_BLEND = (1 << 4),
VAR_MAT_VSM = (1 << 5),
VAR_MAT_ESM = (1 << 6),
VAR_MAT_VOLUME = (1 << 7),
VAR_MAT_LOOKDEV = (1 << 8),
Eevee: Improve material variation managment. - Unify variations between default shaders and material shader. - Only create default shader passes if needed. Downside is that we have a big array of passes and shading grp in the vedata ... And it will double in size each time a new variation flag is added.
2017-06-22 02:41:17 +02:00
/* Max number of variation */
/* IMPORTANT : Leave it last and set
* it's value accordingly. */
EEvEE: LookDev
2018-05-25 08:06:36 +02:00
VAR_MAT_MAX = (1 << 9),
Eevee: Add support for Alpha clip and Hashed Alpha transparency. Hashed Alpha transparency offers a noisy output but has the benefit of being correctly ordered. Noise can be attenuated with Multisampling / AntiAliasing.
2017-07-09 12:01:29 +02:00
/* These are options that are not counted in VAR_MAT_MAX
* because they are not cumulative with the others above. */
EEvEE: LookDev
2018-05-25 08:06:36 +02:00
VAR_MAT_CLIP = (1 << 10),
VAR_MAT_HASH = (1 << 11),
VAR_MAT_MULT = (1 << 12),
VAR_MAT_SHADOW = (1 << 13),
VAR_MAT_REFRACT = (1 << 14),
VAR_MAT_SSS = (1 << 15),
VAR_MAT_TRANSLUC = (1 << 16),
VAR_MAT_SSSALBED = (1 << 17),
Eevee: Improve material variation managment. - Unify variations between default shaders and material shader. - Only create default shader passes if needed. Downside is that we have a big array of passes and shading grp in the vedata ... And it will double in size each time a new variation flag is added.
2017-06-22 02:41:17 +02:00
};
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
/* ************ PROBE UBO ************* */
/* They are the same struct as their Cache siblings.
* typedef'ing just to keep the naming consistent with
* other eevee types. */
typedef LightProbeCache EEVEE_LightProbe;
typedef LightGridCache EEVEE_LightGrid;
typedef struct EEVEE_PlanarReflection {
float plane_equation[4];
float clip_vec_x[3], attenuation_scale;
float clip_vec_y[3], attenuation_bias;
float clip_edge_x_pos, clip_edge_x_neg;
float clip_edge_y_pos, clip_edge_y_neg;
float facing_scale, facing_bias, clipsta, pad;
float reflectionmat[4][4]; /* Used for sampling the texture. */
float mtx[4][4]; /* Not used in shader. TODO move elsewhere. */
} EEVEE_PlanarReflection;
/* --------------------------------------- */
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
typedef struct EEVEE_BoundSphere {
float center[3], radius;
} EEVEE_BoundSphere;
typedef struct EEVEE_BoundBox {
float center[3], halfdim[3];
} EEVEE_BoundBox;
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
typedef struct EEVEE_PassList {
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
/* Shadows */
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
struct DRWPass *shadow_pass;
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
struct DRWPass *shadow_cube_copy_pass;
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
struct DRWPass *shadow_cube_store_pass;
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
struct DRWPass *shadow_cube_store_high_pass;
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
struct DRWPass *shadow_cascade_copy_pass;
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
struct DRWPass *shadow_cascade_store_pass;
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
struct DRWPass *shadow_cascade_store_high_pass;
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
/* Probes */
struct DRWPass *probe_background;
Eevee: Add Irradiance Grid support Early implementation. Slow and still has quality 3 ways of storing irradiance: - Spherical Harmonics: Have problem with directionnal lighting. - HL2 diffuse cube: Very low resolution but smooth transitions. - Diffuse cube: High storage requirement. Also include some name change.
2017-06-13 17:39:39 +02:00
struct DRWPass *probe_glossy_compute;
struct DRWPass *probe_diffuse_compute;
Eevee: Irradiance Visibility: Initial Implementation This augment the existing irradiance grid with a new visibility precomputation. We store a small shadowmap for each grid sample so that light does not leak through walls and such. The visibility parameter are similar to the one used by the Variance Shadow Map for point lights. Technical details: We store the visibility in the same texture (array) as the irradiance itself (in order to reduce the number of sampler). But the irradiance and the visibility are not the same data so we must encode them in order to use the same texture format. We use RGBA8 normalized texture and encode irradiance as RGBE (shared exponent). Using RGBE encoding instead of R11_G11_B10 may lead to some lighting changes, but quality seems to be nearly the same in my test cases. Using full RGBA16/32F maybe a future option but that will require much more memory and reduce the perf significantly. Visibility moments (VSM) are encoded as 16bits fixed point precision using a special range. This seems to retain enough precision for the needs. Also interpolation does not seems to be big problem (even though it's incorrect).
2017-12-02 14:28:29 +01:00
struct DRWPass *probe_visibility_compute;
Eevee: Probe Grid: Clear Grid buffers with world diffuse coefs. This make sure the values displayed by the "show data" sphere are initialized. Also this make the bounce lighting progress more apparent.
2017-09-28 21:17:57 +02:00
struct DRWPass *probe_grid_fill;
Eevee: Add Grid debug display.
2017-06-14 13:45:54 +02:00
struct DRWPass *probe_display;
Eevee: Add Planar reflection blurring. This method is very cheap and inaccurate. This will fill the gap untill better model is supported.
2017-06-26 20:37:41 +02:00
struct DRWPass *probe_planar_downsample_ps;
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
Eevee: Simple Camera Motion Blur. Disabled by default. Set ENABLE_EFFECT_MOTION_BLUR to 1 to enable. No fancy motion blur. Use depth and camera matrix to get the motion vectors. Then blur in this direction. Only available in camera view. Only Camera animation is supported, does not take into account the parents motion
2017-05-04 17:36:40 +02:00
/* Effects */
Eevee: Rework GTAO This includes big improvement: - The horizon search is decoupled from the BSDF evaluation. This means using multiple BSDF nodes have a much lower impact when enbaling AO. - The horizon search is optimized by splitting the search into 4 corners searching similar directions to help which GPU cache coherence. - The AO options are now uniforms and do not trigger shader recompilation (aka. freeze UI). - Include a quality slider similar to the SSR one. - Add a switch for disabling bounce light approximation. - Fix problem with Bent Normals when occlusion get very dark. - Add a denoise option to that takes the neighbors pixel values via glsl derivatives. This reduces noise but exhibit 2x2 blocky artifacts. The downside : Separating the horizon search uses more memory (~3MB for each samples on HD viewport). We could lower the bit depth to 4bit per horizon but it produce noticeable banding (might be fixed with some dithering).
2017-08-18 15:06:51 +02:00
struct DRWPass *ao_horizon_search;
Eevee: Fix AO in planar reflections.
2018-01-09 19:01:24 +01:00
struct DRWPass *ao_horizon_search_layer;
Eevee: Rework GTAO This includes big improvement: - The horizon search is decoupled from the BSDF evaluation. This means using multiple BSDF nodes have a much lower impact when enbaling AO. - The horizon search is optimized by splitting the search into 4 corners searching similar directions to help which GPU cache coherence. - The AO options are now uniforms and do not trigger shader recompilation (aka. freeze UI). - Include a quality slider similar to the SSR one. - Add a switch for disabling bounce light approximation. - Fix problem with Bent Normals when occlusion get very dark. - Add a denoise option to that takes the neighbors pixel values via glsl derivatives. This reduces noise but exhibit 2x2 blocky artifacts. The downside : Separating the horizon search uses more memory (~3MB for each samples on HD viewport). We could lower the bit depth to 4bit per horizon but it produce noticeable banding (might be fixed with some dithering).
2017-08-18 15:06:51 +02:00
struct DRWPass *ao_horizon_debug;
Eevee: Render: Add ambient occlusion pass support.
2018-02-03 00:00:19 +01:00
struct DRWPass *ao_accum_ps;
Eevee: Add mist pass support. Eevee: Render: Fix crash when not enabling mist pass.
2018-02-01 18:09:06 +01:00
struct DRWPass *mist_accum_ps;
Eevee: Simple Camera Motion Blur. Disabled by default. Set ENABLE_EFFECT_MOTION_BLUR to 1 to enable. No fancy motion blur. Use depth and camera matrix to get the motion vectors. Then blur in this direction. Only available in camera view. Only Camera animation is supported, does not take into account the parents motion
2017-05-04 17:36:40 +02:00
struct DRWPass *motion_blur;
Eevee: Add Bloom post process. Based on Kino/Bloom v2 - Bloom filter for Unity MIT license.
2017-05-07 14:27:43 +02:00
struct DRWPass *bloom_blit;
struct DRWPass *bloom_downsample_first;
struct DRWPass *bloom_downsample;
struct DRWPass *bloom_upsample;
struct DRWPass *bloom_resolve;
Eevee: Initial Depth Of Field commit.
2017-05-09 21:57:13 +02:00
struct DRWPass *dof_down;
struct DRWPass *dof_scatter;
struct DRWPass *dof_resolve;
Eevee: Volumetrics: Add Volume object support. This is quite basic as it only support boundbing boxes. But the material can refine the volume shape in anyway the user like. To overcome this limitation, a voxelisation should be done on the mesh (generating a SDF maybe?) and tested against every volumetric cell.
2017-10-27 16:20:33 +02:00
struct DRWPass *volumetric_world_ps;
struct DRWPass *volumetric_objects_ps;
Eevee: Overhaul the volumetric system. The system now uses several 3D textures in order to decouple every steps of the volumetric rendering. See https://www.ea.com/frostbite/news/physically-based-unified-volumetric-rendering-in-frostbite for more details. On the technical side, instead of using a compute shader to populate the 3D textures we use layered rendering with a geometry shader to render 1 fullscreen triangle per 3D texture slice.
2017-10-24 14:49:00 +02:00
struct DRWPass *volumetric_scatter_ps;
struct DRWPass *volumetric_integration_ps;
Eevee: Initial implementation of Volumetrics.
2017-07-03 16:38:14 +02:00
struct DRWPass *volumetric_resolve_ps;
Eevee: SSR: Output ssr datas to buffers. Output in 2 buffers Normals, Specular Color and roughness. This way we can raytrace in a defered fashion and blend the exact contribution of the specular lobe on top of the opaque pass.
2017-07-16 23:49:25 +02:00
struct DRWPass *ssr_raytrace;
struct DRWPass *ssr_resolve;
Eevee: Initial Separable Subsurface Scattering implementation. How to use: - Enable subsurface scattering in the render options. - Add Subsurface BSDF to your shader. - Check "Screen Space Subsurface Scattering" in the material panel options. This initial implementation has a few limitations: - only supports gaussian SSS. - Does not support principled shader. - The radius parameters is baked down to a number of samples and then put into an UBO. This means the radius input socket cannot be used. You need to tweak the default vector directly. - The "texture blur" is considered as always set to 1
2017-11-14 00:49:54 +01:00
struct DRWPass *sss_blur_ps;
struct DRWPass *sss_resolve_ps;
Eevee: Render: Add Subsurface Pass support.
2018-01-31 21:17:27 +01:00
struct DRWPass *sss_accum_ps;
Eevee: SSR: Add mipmap filtering and bias to reduce noise. Also fix the roughness factors.
2017-07-20 18:40:23 +02:00
struct DRWPass *color_downsample_ps;
Eevee: Fix problem with GPU_texture_generate_mipmap This function was called to recreate the lower mip level of the probe texture. But this is not it's usage and it introduced a stall. This patch add cubemap mipmap level regeneration in eevee_effects.c
2017-08-18 22:31:06 +02:00
struct DRWPass *color_downsample_cube_ps;
Eevee: Add Velocity pass. This pass create a velocity buffer which is basically a 2D motion vector texture. This is not yet used for rendering but will be usefull for motion blur and temporal reprojection.
2018-04-20 18:18:33 +02:00
struct DRWPass *velocity_resolve;
Eevee: Implement Temporal Anti Aliasing / Super Sampling This adds TAA to eevee. The only thing important to note is that we need to keep the unjittered depth buffer so that the other engines are composited correctly.
2017-09-25 20:14:07 +02:00
struct DRWPass *taa_resolve;
Eevee: Simple Camera Motion Blur. Disabled by default. Set ENABLE_EFFECT_MOTION_BLUR to 1 to enable. No fancy motion blur. Use depth and camera matrix to get the motion vectors. Then blur in this direction. Only available in camera view. Only Camera animation is supported, does not take into account the parents motion
2017-05-04 17:36:40 +02:00
Eevee: HiZ buffer: Split into two 24bit depth buffer This way we don't have float precision issue we had before and we save some bandwidth.
2017-07-21 14:27:16 +02:00
/* HiZ */
struct DRWPass *minz_downlevel_ps;
struct DRWPass *maxz_downlevel_ps;
struct DRWPass *minz_downdepth_ps;
struct DRWPass *maxz_downdepth_ps;
Eevee: Make MinmaxZ compatible with textureArray
2017-07-23 20:33:29 +02:00
struct DRWPass *minz_downdepth_layer_ps;
struct DRWPass *maxz_downdepth_layer_ps;
Eevee: HiZ buffer: Split into two 24bit depth buffer This way we don't have float precision issue we had before and we save some bandwidth.
2017-07-21 14:27:16 +02:00
struct DRWPass *minz_copydepth_ps;
struct DRWPass *maxz_copydepth_ps;
Eevee: Prepare for fullres tracing
2018-09-11 16:15:34 +02:00
struct DRWPass *maxz_copydepth_layer_ps;
Eevee: HiZ buffer: Split into two 24bit depth buffer This way we don't have float precision issue we had before and we save some bandwidth.
2017-07-21 14:27:16 +02:00
Object Mode: Add stencil test to remove object outlines inside the silouhette. It also adds nice occluded silouhette information for selected objects that are behind visible objects. This methods is really heavy because it needs to render the wires twices.
2017-03-18 01:55:41 +01:00
struct DRWPass *depth_pass;
struct DRWPass *depth_pass_cull;
Eevee: Add special shader for depth prespass. This way we can extend it to output more data (like motion vectors). Add a variation that uses clip distances.
2017-06-16 23:50:40 +02:00
struct DRWPass *depth_pass_clip;
struct DRWPass *depth_pass_clip_cull;
Eevee: Refraction: Make it available for opaque materials. Theses Materials are rendered after the SSR pass. The only difference with previous method is that they have a depth prepass (less overdraw) and are not sorted.
2017-08-09 23:48:42 +02:00
struct DRWPass *refract_depth_pass;
struct DRWPass *refract_depth_pass_cull;
struct DRWPass *refract_depth_pass_clip;
struct DRWPass *refract_depth_pass_clip_cull;
Eevee: Improve material variation managment. - Unify variations between default shaders and material shader. - Only create default shader passes if needed. Downside is that we have a big array of passes and shading grp in the vedata ... And it will double in size each time a new variation flag is added.
2017-06-22 02:41:17 +02:00
struct DRWPass *default_pass[VAR_MAT_MAX];
Eevee: Initial Separable Subsurface Scattering implementation. How to use: - Enable subsurface scattering in the render options. - Add Subsurface BSDF to your shader. - Check "Screen Space Subsurface Scattering" in the material panel options. This initial implementation has a few limitations: - only supports gaussian SSS. - Does not support principled shader. - The radius parameters is baked down to a number of samples and then put into an UBO. This means the radius input socket cannot be used. You need to tweak the default vector directly. - The "texture blur" is considered as always set to 1
2017-11-14 00:49:54 +01:00
struct DRWPass *sss_pass;
Eevee: Make default shaders works. - Added New Batch cache routine to get the split mesh for each material. (optimization needed) - Did some shader modifications to create default_frag and support a somwhat correct fresnel for lamps (to finish)
2017-04-25 18:46:59 +02:00
struct DRWPass *material_pass;
Eevee: Refraction: Make it available for opaque materials. Theses Materials are rendered after the SSR pass. The only difference with previous method is that they have a depth prepass (less overdraw) and are not sorted.
2017-08-09 23:48:42 +02:00
struct DRWPass *refract_pass;
Eevee: Transparency: Add support for blend ADD and MULTIPLY. This introduces a new transparency pass. It bypass the radial distance encoding in alpha for the transparent shaders.
2017-07-10 11:41:33 +02:00
struct DRWPass *transparent_pass;
Eevee: Draw background shader. Also fixes some remaining errors caused by some matrices not updated.
2017-05-04 17:39:50 +02:00
struct DRWPass *background_pass;
Eevee: Perf: Update noises (in utilTex) via GPU drawing. This leads to a ~3ms improvement of CPU time during drawing. This prevent the rendering from being stalled waiting for the texture data to be transfered.
2018-01-17 14:02:48 +01:00
struct DRWPass *update_noise_pass;
EEvEE: LookDev
2018-05-25 08:06:36 +02:00
struct DRWPass *lookdev_pass;
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
} EEVEE_PassList;
typedef struct EEVEE_FramebufferList {
Eevee: Simple Camera Motion Blur. Disabled by default. Set ENABLE_EFFECT_MOTION_BLUR to 1 to enable. No fancy motion blur. Use depth and camera matrix to get the motion vectors. Then blur in this direction. Only available in camera view. Only Camera animation is supported, does not take into account the parents motion
2017-05-04 17:36:40 +02:00
/* Effects */
Eevee: Rework GTAO This includes big improvement: - The horizon search is decoupled from the BSDF evaluation. This means using multiple BSDF nodes have a much lower impact when enbaling AO. - The horizon search is optimized by splitting the search into 4 corners searching similar directions to help which GPU cache coherence. - The AO options are now uniforms and do not trigger shader recompilation (aka. freeze UI). - Include a quality slider similar to the SSR one. - Add a switch for disabling bounce light approximation. - Fix problem with Bent Normals when occlusion get very dark. - Add a denoise option to that takes the neighbors pixel values via glsl derivatives. This reduces noise but exhibit 2x2 blocky artifacts. The downside : Separating the horizon search uses more memory (~3MB for each samples on HD viewport). We could lower the bit depth to 4bit per horizon but it produce noticeable banding (might be fixed with some dithering).
2017-08-18 15:06:51 +02:00
struct GPUFrameBuffer *gtao_fb;
struct GPUFrameBuffer *gtao_debug_fb;
Eevee: HiZ buffer: Split into two 24bit depth buffer This way we don't have float precision issue we had before and we save some bandwidth.
2017-07-21 14:27:16 +02:00
struct GPUFrameBuffer *downsample_fb;
Eevee: Initial implementation of Volumetrics.
2017-07-03 16:38:14 +02:00
struct GPUFrameBuffer *bloom_blit_fb;
struct GPUFrameBuffer *bloom_down_fb[MAX_BLOOM_STEP];
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
struct GPUFrameBuffer *bloom_accum_fb[MAX_BLOOM_STEP - 1];
Eevee: Initial Separable Subsurface Scattering implementation. How to use: - Enable subsurface scattering in the render options. - Add Subsurface BSDF to your shader. - Check "Screen Space Subsurface Scattering" in the material panel options. This initial implementation has a few limitations: - only supports gaussian SSS. - Does not support principled shader. - The radius parameters is baked down to a number of samples and then put into an UBO. This means the radius input socket cannot be used. You need to tweak the default vector directly. - The "texture blur" is considered as always set to 1
2017-11-14 00:49:54 +01:00
struct GPUFrameBuffer *sss_blur_fb;
Eevee: SSS: Fix issue with mac and stencil buffer blitting Adding a workaround in this case: we blit the depth buffer instead of the stencil buffer and use the copy as the texture. This is slower but at least it should work.
2018-10-25 22:13:46 +02:00
struct GPUFrameBuffer *sss_blit_fb;
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
struct GPUFrameBuffer *sss_resolve_fb;
Eevee: Initial Separable Subsurface Scattering implementation. How to use: - Enable subsurface scattering in the render options. - Add Subsurface BSDF to your shader. - Check "Screen Space Subsurface Scattering" in the material panel options. This initial implementation has a few limitations: - only supports gaussian SSS. - Does not support principled shader. - The radius parameters is baked down to a number of samples and then put into an UBO. This means the radius input socket cannot be used. You need to tweak the default vector directly. - The "texture blur" is considered as always set to 1
2017-11-14 00:49:54 +01:00
struct GPUFrameBuffer *sss_clear_fb;
Eevee: Render: Add Subsurface Pass support.
2018-01-31 21:17:27 +01:00
struct GPUFrameBuffer *sss_accum_fb;
Eevee: Initial Depth Of Field commit.
2017-05-09 21:57:13 +02:00
struct GPUFrameBuffer *dof_down_fb;
Eevee: Depht Of Field: Merge Scatter passes together. This means only one texture to draw to and only one sprite per pixel. The texture is twice as large and near and far planes are side by side. The sprite choose the biggest coc to expand to and is redirected to the area (layer) it belongs to. The fragment shader discard every pixel that does not belong to the correct layer.
2018-05-12 21:01:07 +02:00
struct GPUFrameBuffer *dof_scatter_fb;
Eevee: Initial implementation of Volumetrics.
2017-07-03 16:38:14 +02:00
struct GPUFrameBuffer *volumetric_fb;
Eevee: Overhaul the volumetric system. The system now uses several 3D textures in order to decouple every steps of the volumetric rendering. See https://www.ea.com/frostbite/news/physically-based-unified-volumetric-rendering-in-frostbite for more details. On the technical side, instead of using a compute shader to populate the 3D textures we use layered rendering with a geometry shader to render 1 fullscreen triangle per 3D texture slice.
2017-10-24 14:49:00 +02:00
struct GPUFrameBuffer *volumetric_scat_fb;
struct GPUFrameBuffer *volumetric_integ_fb;
Eevee: SSR: Output ssr datas to buffers. Output in 2 buffers Normals, Specular Color and roughness. This way we can raytrace in a defered fashion and blend the exact contribution of the specular lobe on top of the opaque pass.
2017-07-16 23:49:25 +02:00
struct GPUFrameBuffer *screen_tracing_fb;
Eevee: Add Screen Space Refraction. For the moment the only way to enable this is to: - enable Screen Space REFLECTIONS. - enable Screen Space Refraction in the SSR parameters. - enable Screen Space Refraction in the material tab.
2017-08-09 16:54:18 +02:00
struct GPUFrameBuffer *refract_fb;
Eevee: Add mist pass support. Eevee: Render: Fix crash when not enabling mist pass.
2018-02-01 18:09:06 +01:00
struct GPUFrameBuffer *mist_accum_fb;
Eevee: Render: Add ambient occlusion pass support.
2018-02-03 00:00:19 +01:00
struct GPUFrameBuffer *ao_accum_fb;
Eevee: Add Velocity pass. This pass create a velocity buffer which is basically a 2D motion vector texture. This is not yet used for rendering but will be usefull for motion blur and temporal reprojection.
2018-04-20 18:18:33 +02:00
struct GPUFrameBuffer *velocity_resolve_fb;
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
Eevee: Perf: Update noises (in utilTex) via GPU drawing. This leads to a ~3ms improvement of CPU time during drawing. This prevent the rendering from being stalled waiting for the texture data to be transfered.
2018-01-17 14:02:48 +01:00
struct GPUFrameBuffer *update_noise_fb;
Eevee: Initial implementation of planar reflections. Still pretty barebone: No roughness support, No normal distortion support.
2017-06-17 00:08:03 +02:00
struct GPUFrameBuffer *planarref_fb;
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
struct GPUFrameBuffer *planar_downsample_fb;
Eevee: Initial implementation of planar reflections. Still pretty barebone: No roughness support, No normal distortion support.
2017-06-17 00:08:03 +02:00
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
struct GPUFrameBuffer *main_fb;
struct GPUFrameBuffer *main_color_fb;
struct GPUFrameBuffer *effect_fb;
struct GPUFrameBuffer *effect_color_fb;
struct GPUFrameBuffer *double_buffer_fb;
struct GPUFrameBuffer *double_buffer_color_fb;
struct GPUFrameBuffer *double_buffer_depth_fb;
Eevee: Depth of Feild: Fix ringing issue of background objects There was an issue caused by Antialiasing being done after DoF. Move TAA after DOF and Motion Blur. Also certain pixel with lower CoC would be spread all over the background because the neighbooring pixel have higher CoC. So we need to apply some bilateral filtering when downsampling. Currently we limit the influence of neighbor pixels with a CoC inside the range [MaxCoC-2, MaxCoC].
2018-09-09 23:24:06 +02:00
struct GPUFrameBuffer *taa_history_fb;
struct GPUFrameBuffer *taa_history_color_fb;
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
} EEVEE_FramebufferList;
typedef struct EEVEE_TextureList {
Eevee: Add Bloom post process. Based on Kino/Bloom v2 - Bloom filter for Unity MIT license.
2017-05-07 14:27:43 +02:00
/* Effects */
struct GPUTexture *color_post; /* R16_G16_B16 */
Eevee: Add mist pass support. Eevee: Render: Fix crash when not enabling mist pass.
2018-02-01 18:09:06 +01:00
struct GPUTexture *mist_accum;
Eevee: Render: Add ambient occlusion pass support.
2018-02-03 00:00:19 +01:00
struct GPUTexture *ao_accum;
Eevee: Render: Add Subsurface Pass support.
2018-01-31 21:17:27 +01:00
struct GPUTexture *sss_dir_accum;
struct GPUTexture *sss_col_accum;
Eevee: Add Screen Space Refraction. For the moment the only way to enable this is to: - enable Screen Space REFLECTIONS. - enable Screen Space Refraction in the SSR parameters. - enable Screen Space Refraction in the material tab.
2017-08-09 16:54:18 +02:00
struct GPUTexture *refract_color;
Eevee: Depth of Feild: Fix ringing issue of background objects There was an issue caused by Antialiasing being done after DoF. Move TAA after DOF and Motion Blur. Also certain pixel with lower CoC would be spread all over the background because the neighbooring pixel have higher CoC. So we need to apply some bilateral filtering when downsampling. Currently we limit the influence of neighbor pixels with a CoC inside the range [MaxCoC-2, MaxCoC].
2018-09-09 23:24:06 +02:00
struct GPUTexture *taa_history;
Eevee: SSR: Output ssr datas to buffers. Output in 2 buffers Normals, Specular Color and roughness. This way we can raytrace in a defered fashion and blend the exact contribution of the specular lobe on top of the opaque pass.
2017-07-16 23:49:25 +02:00
Eevee: Overhaul the volumetric system. The system now uses several 3D textures in order to decouple every steps of the volumetric rendering. See https://www.ea.com/frostbite/news/physically-based-unified-volumetric-rendering-in-frostbite for more details. On the technical side, instead of using a compute shader to populate the 3D textures we use layered rendering with a geometry shader to render 1 fullscreen triangle per 3D texture slice.
2017-10-24 14:49:00 +02:00
struct GPUTexture *volume_prop_scattering;
struct GPUTexture *volume_prop_extinction;
struct GPUTexture *volume_prop_emission;
struct GPUTexture *volume_prop_phase;
struct GPUTexture *volume_scatter;
struct GPUTexture *volume_transmittance;
struct GPUTexture *volume_scatter_history;
struct GPUTexture *volume_transmittance_history;
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
struct GPUTexture *lookdev_grid_tx;
struct GPUTexture *lookdev_cube_tx;
Eevee: Initial implementation of planar reflections. Still pretty barebone: No roughness support, No normal distortion support.
2017-06-17 00:08:03 +02:00
struct GPUTexture *planar_pool;
Eevee: Planar Reflection: Remove distance approximation. This commit separate the depth texture into another texture array. This remove the need to output radial depth into alpha. Unfortunatly it's difficult to recover position from the non linear depth buffer when applying reflection without adding a bunch of stuff. This is in preparation of SSR planar reflections.
2017-07-23 14:03:27 +02:00
struct GPUTexture *planar_depth;
Eevee: Initial implementation of planar reflections. Still pretty barebone: No roughness support, No normal distortion support.
2017-06-17 00:08:03 +02:00
Eevee: HiZ buffer: Split into two 24bit depth buffer This way we don't have float precision issue we had before and we save some bandwidth.
2017-07-21 14:27:16 +02:00
struct GPUTexture *maxzbuffer;
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
struct GPUTexture *color; /* R16_G16_B16 */
Eevee: SSR: Add double buffer so we can read previous frame color. Also add simple reprojection and screen fade to the SSR resolve pass.
2017-07-19 14:22:03 +02:00
struct GPUTexture *color_double_buffer;
Eevee: Implement Temporal Anti Aliasing / Super Sampling This adds TAA to eevee. The only thing important to note is that we need to keep the unjittered depth buffer so that the other engines are composited correctly.
2017-09-25 20:14:07 +02:00
struct GPUTexture *depth_double_buffer;
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
} EEVEE_TextureList;
typedef struct EEVEE_StorageList {
Eevee: Simple Camera Motion Blur. Disabled by default. Set ENABLE_EFFECT_MOTION_BLUR to 1 to enable. No fancy motion blur. Use depth and camera matrix to get the motion vectors. Then blur in this direction. Only available in camera view. Only Camera animation is supported, does not take into account the parents motion
2017-05-04 17:36:40 +02:00
/* Effects */
struct EEVEE_EffectsInfo *effects;
Cleanup: rename struct for private engine data Also remove from pass list (there were some duplicate unused entries).
2017-04-29 16:52:12 +10:00
struct EEVEE_PrivateData *g_data;
EEVEE: LookDev storage list wrongly used
2018-05-28 17:18:27 +02:00
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
struct LightCache *lookdev_lightcache;
EEVEE_LightProbe *lookdev_cube_data;
EEVEE_LightGrid *lookdev_grid_data;
LightCacheTexture *lookdev_cube_mips;
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
} EEVEE_StorageList;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
/* ************ LIGHT UBO ************* */
typedef struct EEVEE_Light {
float position[3], dist;
float color[3], spec;
float spotsize, spotblend, radius, shadowid;
float rightvec[3], sizex;
float upvec[3], sizey;
float forwardvec[3], lamptype;
} EEVEE_Light;
Cycles/Eevee: Implement disk and ellipse shapes for area lamps The implementation is pretty straightforward. In Cycles, sampling the shapes is currently done w.r.t. area instead of solid angle. There is a paper on solid angle sampling for disks [1], but the described algorithm is based on simply sampling the enclosing square and rejecting samples outside of the disk, which is not exactly great for Cycles' RNG (we'd need to setup a LCG for the repeated sampling) and for GPU divergence. Even worse, the algorithm is only defined for disks. For ellipses, the basic idea still works, but a way to analytically calculate the solid angle is required. This is technically possible [2], but the calculation is extremely complex and still requires a lookup table for the Heuman Lambda function. Therefore, I've decided to not implement that for now, we could still look into it later on. In Eevee, the code uses the existing ltc_evaluate_disk to implement the lighting calculations. [1]: "Solid Angle Sampling of Disk and Cylinder Lights" [2]: "Analytical solution for the solid angle subtended at any point by an ellipse via a point source radiation vector potential" Reviewers: sergey, brecht, fclem Differential Revision: https://developer.blender.org/D3171
2018-05-24 03:50:16 +02:00
/* Special type for elliptic area lamps, matches lamps_lib.glsl */
#define LAMPTYPE_AREA_ELLIPSE 100.0f
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
typedef struct EEVEE_Shadow {
Eevee: Polishing of Exponential Shadow mapping Added exponent parameter to tweak light bleeding. Added depth bias to the shadow test. Added better blurring using 32 samples.
2017-06-02 20:50:04 +02:00
float near, far, bias, exp;
Eevee : SSS : Add Translucency support. This adds the possibility to simulate things like red ears with strong backlight or material with high scattering distances. To enable it you need to turn on the "Subsurface Translucency" option in the "Options" tab of the Material Panel (and of course to have "regular" SSS enabled in both render settings and material options). Since the effect is adding another overhead I prefer to make it optional. But this is open to discussion. Be aware that the effect only works for direct lights (so no indirect/world lighting) that have shadowmaps, and is affected by the "softness" of the shadowmap and resolution. Technical notes: This is inspired by http://www.iryoku.com/translucency/ but goes a bit beyond that. We do not use a sum of gaussian to apply in regards to the object thickness but we precompute a 1D kernel texture. This texture stores the light transmited to a point at the back of an infinite slab of material of variying thickness. We make the assumption that the slab is perpendicular to the light so that no fresnel or diffusion term is taken into account. The light is considered constant. If the setup is similar to the one assume during the profile baking, the realtime render matches cycles reference. Due to these assumptions the computed transmitted light is in most cases too bright for curvy objects. Finally we jitter the shadow map sample per pixel so we can simulate dispersion inside the medium. Radius of the dispersion is in world space and derived by from the "soft" shadowmap parameter. Idea for this come from this presentation http://www.iryoku.com/stare-into-the-future (slide 164).
2017-11-22 04:51:21 +01:00
float shadow_start, data_start, multi_shadow_count, shadow_blur;
Eevee: Shadows: Add Contact Shadows This add the possibility to add screen space raytraced shadows to fix light leaking cause by shadows maps. Theses inherit of the same artifacts as other screenspace methods.
2017-10-06 23:43:36 +02:00
float contact_dist, contact_bias, contact_spread, contact_thickness;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
} EEVEE_Shadow;
typedef struct EEVEE_ShadowCube {
float position[3], pad;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
} EEVEE_ShadowCube;
typedef struct EEVEE_ShadowCascade {
float shadowmat[MAX_CASCADE_NUM][4][4]; /* World->Lamp->NDC->Tex : used for sampling the shadow map. */
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
float split_start[4];
float split_end[4];
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
} EEVEE_ShadowCascade;
Eevee: Do shadow cube render in one pass.
2017-04-19 22:07:53 +02:00
typedef struct EEVEE_ShadowRender {
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
float position[3], pad;
float cube_texel_size;
float stored_texel_size;
float clip_near;
float clip_far;
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
int shadow_samples_len;
float shadow_samples_len_inv;
Eevee: Do shadow cube render in one pass.
2017-04-19 22:07:53 +02:00
} EEVEE_ShadowRender;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* This is just a really long bitflag with special function to access it. */
#define MAX_LIGHTBITS_FIELDS (MAX_LIGHT / 8)
typedef struct EEVEE_LightBits {
Cleanup: abbreviate unsigned types (draw manager)
2018-07-08 12:47:13 +02:00
uchar fields[MAX_LIGHTBITS_FIELDS];
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
} EEVEE_LightBits;
typedef struct EEVEE_ShadowCaster {
struct EEVEE_LightBits bits;
struct EEVEE_BoundBox bbox;
} EEVEE_ShadowCaster;
typedef struct EEVEE_ShadowCasterBuffer {
struct EEVEE_ShadowCaster *shadow_casters;
char *flags;
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
uint alloc_count;
uint count;
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
} EEVEE_ShadowCasterBuffer;
Eevee: Do shadow cube render in one pass.
2017-04-19 22:07:53 +02:00
/* ************ LIGHT DATA ************* */
typedef struct EEVEE_LampsInfo {
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
int num_light, cache_num_light;
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
int num_cube_layer, cache_num_cube_layer;
int num_cascade_layer, cache_num_cascade_layer;
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
int gpu_cube_len, gpu_cascade_len, gpu_shadow_len;
int cpu_cube_len, cpu_cascade_len;
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
int update_flag;
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
int shadow_cube_size, shadow_cascade_size, shadow_method;
Eevee: Shadow: Add high bitdepth option. This option is here for reducing the memory usage of shadow maps. Also lower bitdepth are quicker to process.
2017-09-02 02:27:28 +02:00
bool shadow_high_bitdepth;
Eevee: Shadows: Compute Octahedron size from CubeMap size. This was the otherway around before. But since we can have a different size* for cube texture now, we can compute the correct-ish texture size. This will give us on average the same texture appearance when we will add support for real cubemap shadows.
2018-05-04 15:59:01 +02:00
int shadow_cube_store_size;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
int current_shadow_cascade;
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
int current_shadow_face;
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
uint shadow_instance_count;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
float filter_size;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
/* List of lights in the scene. */
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
/* XXX This is fragile, can get out of sync quickly. */
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
struct Object *light_ref[MAX_LIGHT];
struct Object *shadow_cube_ref[MAX_SHADOW_CUBE];
struct Object *shadow_cascade_ref[MAX_SHADOW_CASCADE];
/* UBO Storage : data used by UBO */
struct EEVEE_Light light_data[MAX_LIGHT];
Eevee: Do shadow cube render in one pass.
2017-04-19 22:07:53 +02:00
struct EEVEE_ShadowRender shadow_render_data;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
struct EEVEE_Shadow shadow_data[MAX_SHADOW];
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
struct EEVEE_ShadowCube shadow_cube_data[MAX_SHADOW_CUBE];
struct EEVEE_ShadowCascade shadow_cascade_data[MAX_SHADOW_CASCADE];
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* Lights tracking */
int new_shadow_id[MAX_LIGHT]; /* To be able to convert old bitfield to new bitfield */
Merge branch 'master' into blender2.8
2018-09-19 18:19:49 +02:00
struct EEVEE_BoundSphere shadow_bounds[MAX_LIGHT]; /* Tightly packed light bounds */
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* Pointers only. */
struct EEVEE_ShadowCasterBuffer *shcaster_frontbuffer;
struct EEVEE_ShadowCasterBuffer *shcaster_backbuffer;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
} EEVEE_LampsInfo;
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* EEVEE_LampsInfo->shadow_casters_flag */
enum {
SHADOW_CASTER_PRUNED = (1 << 0),
SHADOW_CASTER_UPDATED = (1 << 1),
};
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
/* EEVEE_LampsInfo->update_flag */
enum {
LIGHT_UPDATE_SHADOW_CUBE = (1 << 0),
};
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
/* ************ PROBE DATA ************* */
Cleanup: style, duplicate includes
2018-04-28 09:01:34 +02:00
typedef struct EEVEE_LightProbeVisTest {
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
struct Collection *collection; /* Skip test if NULL */
EEVEE: LightProbe: Implement Visibility Group. Works on every probe type. The function to see is EEVEE_lightprobes_obj_visibility_cb. Set pinfo->vis_data.cached to true makes the computation faster for multiple views using the same group. We could even sort the probes by group for that mater to speed things up even more (only applies to dynamic probes like the planar reflections because other probes are only rendered one at a time).
2018-04-24 12:45:59 +02:00
bool invert;
bool cached; /* Reuse last test results */
} EEVEE_LightProbeVisTest;
Rename probe to light-probe Probe is a real general term, the new name is used often in docs online.
2017-06-12 20:59:54 +10:00
typedef struct EEVEE_LightProbesInfo {
Eevee: Material code refactor. Separate material handling inside another file. Make use of enums to identify shader variations. Group all 64*64 LUTs into one array texture. Only update world probe if world changes.
2017-06-04 12:12:58 +02:00
int num_cube, cache_num_cube;
Eevee: Add Irradiance Grid support Early implementation. Slow and still has quality 3 ways of storing irradiance: - Spherical Harmonics: Have problem with directionnal lighting. - HL2 diffuse cube: Very low resolution but smooth transitions. - Diffuse cube: High storage requirement. Also include some name change.
2017-06-13 17:39:39 +02:00
int num_grid, cache_num_grid;
Eevee: Initial implementation of planar reflections. Still pretty barebone: No roughness support, No normal distortion support.
2017-06-17 00:08:03 +02:00
int num_planar, cache_num_planar;
Eevee: Irradiance Grid: Allocate needed resources instead of a static chunck. This commit makes the irradiance pool and render target sizes depend on the number of irradiance sample in the whole ViewLayer.
2017-12-04 17:20:20 +01:00
int total_irradiance_samples; /* Total for all grids */
int cache_irradiance_size[3];
Eevee: Material code refactor. Separate material handling inside another file. Make use of enums to identify shader variations. Group all 64*64 LUTs into one array texture. Only update world probe if world changes.
2017-06-04 12:12:58 +02:00
int update_flag;
Eevee: Irradiance grid: support for non-blocking update and multiple bounces.
2017-06-14 18:52:53 +02:00
int updated_bounce;
Eevee : Add a setting for the number of indirect light bounce. This is used to tweak the overall spread of the lighting. It is a per renderlayer setting.
2017-10-01 02:19:10 +02:00
int num_bounce;
Eevee: Probe: Add Cubemap Resolution option.
2017-10-10 21:56:11 +02:00
int cubemap_res;
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
/* Update */
Eevee: Put all constant uniforms in a global UBO. This is an optimization / cleanup commit. The use of a global ubo remove lots of uniform lookups and only transfert data when needed. Lots of renaming for more consistent codestyle.
2018-01-21 17:25:10 +01:00
bool do_cube_update;
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
bool do_grid_update;
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
/* For rendering probes */
float probemat[6][4][4];
int layer;
Eevee: Replace Cubemaps by octahedron maps for env. probes. This enables us to use 2D texture arrays for multiple probes. There is a little artifact with very high roughness caused elongated pixel due to the projection (along every 90° meridian).
2017-05-29 22:03:57 +02:00
float texel_size;
float padding_size;
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
float samples_len;
float samples_len_inv;
Eevee: Irradiance Visibility: Initial Implementation This augment the existing irradiance grid with a new visibility precomputation. We store a small shadowmap for each grid sample so that light does not leak through walls and such. The visibility parameter are similar to the one used by the Variance Shadow Map for point lights. Technical details: We store the visibility in the same texture (array) as the irradiance itself (in order to reduce the number of sampler). But the irradiance and the visibility are not the same data so we must encode them in order to use the same texture format. We use RGBA8 normalized texture and encode irradiance as RGBE (shared exponent). Using RGBE encoding instead of R11_G11_B10 may lead to some lighting changes, but quality seems to be nearly the same in my test cases. Using full RGBA16/32F maybe a future option but that will require much more memory and reduce the perf significantly. Visibility moments (VSM) are encoded as 16bits fixed point precision using a special range. This seems to retain enough precision for the needs. Also interpolation does not seems to be big problem (even though it's incorrect).
2017-12-02 14:28:29 +01:00
float near_clip;
float far_clip;
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
float roughness;
float lodfactor;
Eevee: Refactor of shading code to be more modular. This will enable creating shading models more easily.
2017-06-28 16:31:25 +02:00
float lod_rt_max, lod_cube_max, lod_planar_max;
Eevee: Irradiance Visibility: Initial Implementation This augment the existing irradiance grid with a new visibility precomputation. We store a small shadowmap for each grid sample so that light does not leak through walls and such. The visibility parameter are similar to the one used by the Variance Shadow Map for point lights. Technical details: We store the visibility in the same texture (array) as the irradiance itself (in order to reduce the number of sampler). But the irradiance and the visibility are not the same data so we must encode them in order to use the same texture format. We use RGBA8 normalized texture and encode irradiance as RGBE (shared exponent). Using RGBE encoding instead of R11_G11_B10 may lead to some lighting changes, but quality seems to be nearly the same in my test cases. Using full RGBA16/32F maybe a future option but that will require much more memory and reduce the perf significantly. Visibility moments (VSM) are encoded as 16bits fixed point precision using a special range. This seems to retain enough precision for the needs. Also interpolation does not seems to be big problem (even though it's incorrect).
2017-12-02 14:28:29 +01:00
float visibility_range;
float visibility_blur;
Eevee: Probes: Add support for intensity tweak. This works for grid and cubemaps. The intensity is baked into the map itself. Thus you need to refresh/rebake the probe to see the changes.
2018-01-21 23:15:57 +01:00
float intensity_fac;
Eevee: Spherical Harmonic diffuse. For now it's done each frame and it's rather slow (16ms) but result will be cached soon.
2017-04-18 21:02:02 +02:00
int shres;
EEvEE: LookDev
2018-05-25 08:06:36 +02:00
int studiolight_index;
float studiolight_rot_z;
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
EEVEE_LightProbeVisTest planar_vis_tests[MAX_PLANAR];
Eevee: Material code refactor. Separate material handling inside another file. Make use of enums to identify shader variations. Group all 64*64 LUTs into one array texture. Only update world probe if world changes.
2017-06-04 12:12:58 +02:00
/* UBO Storage : data used by UBO */
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
EEVEE_LightProbe probe_data[MAX_PROBE];
EEVEE_LightGrid grid_data[MAX_GRID];
EEVEE_PlanarReflection planar_data[MAX_PLANAR];
Rename EEVEE visibility group > collection I think we should rename the DNA as well, and break the 0.01 files using this feature. But I will leave this decision to Clement.
2018-05-28 21:27:00 +02:00
/* Probe Visibility Collection */
EEVEE: LightProbe: Implement Visibility Group. Works on every probe type. The function to see is EEVEE_lightprobes_obj_visibility_cb. Set pinfo->vis_data.cached to true makes the computation faster for multiple views using the same group. We could even sort the probes by group for that mater to speed things up even more (only applies to dynamic probes like the planar reflections because other probes are only rendered one at a time).
2018-04-24 12:45:59 +02:00
EEVEE_LightProbeVisTest vis_data;
Rename probe to light-probe Probe is a real general term, the new name is used often in docs online.
2017-06-12 20:59:54 +10:00
} EEVEE_LightProbesInfo;
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
Rename probe to light-probe Probe is a real general term, the new name is used often in docs online.
2017-06-12 20:59:54 +10:00
/* EEVEE_LightProbesInfo->update_flag */
Eevee: Material code refactor. Separate material handling inside another file. Make use of enums to identify shader variations. Group all 64*64 LUTs into one array texture. Only update world probe if world changes.
2017-06-04 12:12:58 +02:00
enum {
PROBE_UPDATE_CUBE = (1 << 0),
Eevee : Probe Grid : Fix Update tagging.
2017-10-02 18:40:51 +02:00
PROBE_UPDATE_GRID = (1 << 1),
PROBE_UPDATE_ALL = 0xFFFFFF,
Eevee: Material code refactor. Separate material handling inside another file. Make use of enums to identify shader variations. Group all 64*64 LUTs into one array texture. Only update world probe if world changes.
2017-06-04 12:12:58 +02:00
};
Eevee: Simple Camera Motion Blur. Disabled by default. Set ENABLE_EFFECT_MOTION_BLUR to 1 to enable. No fancy motion blur. Use depth and camera matrix to get the motion vectors. Then blur in this direction. Only available in camera view. Only Camera animation is supported, does not take into account the parents motion
2017-05-04 17:36:40 +02:00
/* ************ EFFECTS DATA ************* */
Eevee: Use named EEVEE_EffectsFlag for effects flag.
2018-03-26 10:02:53 +02:00
typedef enum EEVEE_EffectsFlag {
EFFECT_MOTION_BLUR = (1 << 0),
EFFECT_BLOOM = (1 << 1),
EFFECT_DOF = (1 << 2),
EFFECT_VOLUMETRIC = (1 << 3),
EFFECT_SSR = (1 << 4),
EFFECT_DOUBLE_BUFFER = (1 << 5), /* Not really an effect but a feature */
EFFECT_REFRACT = (1 << 6),
EFFECT_GTAO = (1 << 7),
EFFECT_TAA = (1 << 8),
EFFECT_POST_BUFFER = (1 << 9), /* Not really an effect but a feature */
EFFECT_NORMAL_BUFFER = (1 << 10), /* Not really an effect but a feature */
EFFECT_SSS = (1 << 11),
Eevee: Add Velocity pass. This pass create a velocity buffer which is basically a 2D motion vector texture. This is not yet used for rendering but will be usefull for motion blur and temporal reprojection.
2018-04-20 18:18:33 +02:00
EFFECT_VELOCITY_BUFFER = (1 << 12), /* Not really an effect but a feature */
Eevee: TAA Reprojection: Initial implementation This "improve" the viewport experience by reducing the noise from random sampling effects (SSAO, Contact Shadows, SSR) when moving the viewport or during playback. This does not do Anti Aliasing because this would conflict with the outline pass. We could enable AA jittering in "only render" mode though. There are many things to improve but this is a solid basis to build upon.
2018-04-20 18:24:14 +02:00
EFFECT_TAA_REPROJECT = (1 << 13), /* should be mutually exclusive with EFFECT_TAA */
EFFECT_DEPTH_DOUBLE_BUFFER = (1 << 14), /* Not really an effect but a feature */
Eevee: Use named EEVEE_EffectsFlag for effects flag.
2018-03-26 10:02:53 +02:00
} EEVEE_EffectsFlag;
Eevee: Simple Camera Motion Blur. Disabled by default. Set ENABLE_EFFECT_MOTION_BLUR to 1 to enable. No fancy motion blur. Use depth and camera matrix to get the motion vectors. Then blur in this direction. Only available in camera view. Only Camera animation is supported, does not take into account the parents motion
2017-05-04 17:36:40 +02:00
typedef struct EEVEE_EffectsInfo {
Eevee: Use named EEVEE_EffectsFlag for effects flag.
2018-03-26 10:02:53 +02:00
EEVEE_EffectsFlag enabled_effects;
Eevee: Effects: Split each effect in it's own file. This also: - make sure to only compile the shader needed by the active effects. - same thing for the shading groups. - disable TAA if motion blur is active (avoid infinite refresh).
2017-11-01 01:03:36 +01:00
bool swap_double_buffer;
Eevee: SSS: Add Quality settings. Samples : pretty self explanatory. Jitter Threshold : Reduce cache misses and improve performance (greatly) by lowering this value. This settings let user decide how many samples should be jittered (rotated) to reduce banding artifacts.
2017-11-14 02:17:34 +01:00
/* SSSS */
int sss_sample_count;
Eevee: SSS: Add separated Albedo option. This option prevent from automatically blurring the albedo color applied to the SSS. While this is great for preserving details it can bleed more light onto the nearby objects since the blurring will be done on pure "white" irradiance. This issue is to be tackled in a separate commit.
2017-11-24 22:29:18 +01:00
bool sss_separate_albedo;
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
struct GPUTexture *sss_data; /* Textures from pool */
struct GPUTexture *sss_albedo;
struct GPUTexture *sss_blur;
struct GPUTexture *sss_stencil;
Eevee: Volumetrics: Add volumetric support to alpha blended meshes.
2017-10-24 17:52:20 +02:00
/* Volumetrics */
Eevee: Volumetrics: Request aditional frames when no TAA is enabled.
2017-10-24 18:18:14 +02:00
int volume_current_sample;
Eevee: SSR: Output ssr datas to buffers. Output in 2 buffers Normals, Specular Color and roughness. This way we can raytrace in a defered fashion and blend the exact contribution of the specular lobe on top of the opaque pass.
2017-07-16 23:49:25 +02:00
/* SSR */
Eevee: SSR: Add fullscreen raytrace.
2017-07-21 15:06:29 +02:00
bool reflection_trace_full;
Eevee: Fix wrong SSR reprojection when switching orthographic view We just reset the temporal sampling and avoid using the previous frame for SSR at all.
2018-07-20 22:43:30 +02:00
bool ssr_was_persp;
Eevee: SSR: Optimise Texture fetches and solve noise issue. There was some remaining issue caused by neighbor re-use. Randomizing them every _prime_number_ of iterations fixes this.
2018-01-16 13:13:30 +01:00
int ssr_neighbor_ofs;
Eevee: SSR: Enhance the halfres raytrace. This make the halfres raytrace actually converge to an antialiased image by jittering the source pixel.
2018-01-16 13:18:04 +01:00
int ssr_halfres_ofs[2];
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
struct GPUTexture *ssr_normal_input; /* Textures from pool */
struct GPUTexture *ssr_specrough_input;
struct GPUTexture *ssr_hit_output;
struct GPUTexture *ssr_pdf_output;
Eevee: Implement Temporal Anti Aliasing / Super Sampling This adds TAA to eevee. The only thing important to note is that we need to keep the unjittered depth buffer so that the other engines are composited correctly.
2017-09-25 20:14:07 +02:00
/* Temporal Anti Aliasing */
Eevee: TAA Reprojection: Initial implementation This "improve" the viewport experience by reducing the noise from random sampling effects (SSAO, Contact Shadows, SSR) when moving the viewport or during playback. This does not do Anti Aliasing because this would conflict with the outline pass. We could enable AA jittering in "only render" mode though. There are many things to improve but this is a solid basis to build upon.
2018-04-20 18:24:14 +02:00
int taa_reproject_sample;
Eevee: Implement Temporal Anti Aliasing / Super Sampling This adds TAA to eevee. The only thing important to note is that we need to keep the unjittered depth buffer so that the other engines are composited correctly.
2017-09-25 20:14:07 +02:00
int taa_current_sample;
Eevee: Make Ogl render sampling more correct Result is less noisy ogl renders. What this patch does: - the draw loops gets accumulated into the output buffer. - disable TXAA persmat jittering in ogl render since ogl render already does that. - make noise texture update correct accross all draw loops. Previously it was reset between each FSAA samples.
2018-01-05 10:25:00 +01:00
int taa_render_sample;
Eevee: Implement Temporal Anti Aliasing / Super Sampling This adds TAA to eevee. The only thing important to note is that we need to keep the unjittered depth buffer so that the other engines are composited correctly.
2017-09-25 20:14:07 +02:00
int taa_total_sample;
float taa_alpha;
Eevee : Fix ghosting from probe data when toggling "only render".
2017-10-02 20:02:21 +02:00
bool prev_drw_support;
Eevee: Implement Temporal Anti Aliasing / Super Sampling This adds TAA to eevee. The only thing important to note is that we need to keep the unjittered depth buffer so that the other engines are composited correctly.
2017-09-25 20:14:07 +02:00
float prev_drw_persmat[4][4];
float overide_persmat[4][4];
float overide_persinv[4][4];
float overide_winmat[4][4];
float overide_wininv[4][4];
Eevee: Ambient Occlusion: Initial implementation. Implement GTAO (Ground Truth Ambient Occlusion) which is a special case of Horizon Based Ambient Occlusion that is more physically accurate. Also add a bent normal option to sample indirect irradiance (diffuse lighting) with the least occluded direction.
2017-06-22 03:10:39 +02:00
/* Ambient Occlusion */
Eevee: Fix AO in planar reflections.
2018-01-09 19:01:24 +01:00
int ao_depth_layer;
struct GPUTexture *ao_src_depth; /* pointer copy */
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
struct GPUTexture *gtao_horizons; /* Textures from pool */
struct GPUTexture *gtao_horizons_debug;
Eevee: Add Bloom post process. Based on Kino/Bloom v2 - Bloom filter for Unity MIT license.
2017-05-07 14:27:43 +02:00
/* Motion Blur */
Eevee: Simple Camera Motion Blur. Disabled by default. Set ENABLE_EFFECT_MOTION_BLUR to 1 to enable. No fancy motion blur. Use depth and camera matrix to get the motion vectors. Then blur in this direction. Only available in camera view. Only Camera animation is supported, does not take into account the parents motion
2017-05-04 17:36:40 +02:00
float current_ndc_to_world[4][4];
float past_world_to_ndc[4][4];
Eevee: Post process parameters. -Display almost all parameters. -Made some small adjustment to motion blur to support FOV motion blur. -Made DOF max radius a parameter.
2017-05-10 15:58:18 +02:00
int motion_blur_samples;
Eevee: Add Velocity pass. This pass create a velocity buffer which is basically a 2D motion vector texture. This is not yet used for rendering but will be usefull for motion blur and temporal reprojection.
2018-04-20 18:18:33 +02:00
/* Velocity Pass */
float velocity_curr_persinv[4][4];
float velocity_past_persmat[4][4];
struct GPUTexture *velocity_tx; /* Texture from pool */
Eevee: Initial Depth Of Field commit.
2017-05-09 21:57:13 +02:00
/* Depth Of Field */
float dof_near_far[2];
float dof_params[3];
Eevee: Post process parameters. -Display almost all parameters. -Made some small adjustment to motion blur to support FOV motion blur. -Made DOF max radius a parameter.
2017-05-10 15:58:18 +02:00
float dof_bokeh[4];
Eevee: Depth of field: Smooth out bokeh shape. Due to the scatter operation being done at half resolution, undersampling is visible at bokeh shape edges (because of the hard cut). This commit adds a smoothing function to minimize the problem. Also optimize the bokeh shape parametrization by precomputing a lot of constants.
2018-05-12 00:58:53 +02:00
float dof_bokeh_sides[4];
Eevee: Initial Depth Of Field commit.
2017-05-09 21:57:13 +02:00
int dof_target_size[2];
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
struct GPUTexture *dof_down_near; /* Textures from pool */
struct GPUTexture *dof_down_far;
struct GPUTexture *dof_coc;
Eevee: Depht Of Field: Merge Scatter passes together. This means only one texture to draw to and only one sprite per pixel. The texture is twice as large and near and far planes are side by side. The sprite choose the biggest coc to expand to and is redirected to the area (layer) it belongs to. The fragment shader discard every pixel that does not belong to the correct layer.
2018-05-12 21:01:07 +02:00
struct GPUTexture *dof_blur;
Eevee: Fix Missing alpha when rendering with DOF NOTE: There is a float imprecision near the focus plane due to the current technique used for DOF. This makes the alpha channel transparent on nearly in focus objects even when they should not. This artifact should be fixed when the DOF will use scatter as gather for low brightness areas. Fix T57042 : Eevee does not render alpha when DOF is turned on
2018-10-15 16:04:33 +02:00
struct GPUTexture *dof_blur_alpha;
Eevee: Fix prev_persmat being used by multiple viewport.
2018-02-26 20:08:48 +01:00
/* Other */
float prev_persmat[4][4];
Eevee: Add Bloom post process. Based on Kino/Bloom v2 - Bloom filter for Unity MIT license.
2017-05-07 14:27:43 +02:00
/* Bloom */
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
int bloom_iteration_len;
Eevee: Add Bloom post process. Based on Kino/Bloom v2 - Bloom filter for Unity MIT license.
2017-05-07 14:27:43 +02:00
float source_texel_size[2];
float blit_texel_size[2];
float downsamp_texel_size[MAX_BLOOM_STEP][2];
Eevee: Bloom: Add Bloom Color Moar artistic control yay!
2017-08-19 02:40:02 +02:00
float bloom_color[3];
Eevee: Bloom: Add Clamp setting It's purpose is to limit the amount of light that spread across the screen. Not entierly sure if it's very usefull, but it sure help to avoid to drown the screen in bloom.
2017-08-19 02:39:16 +02:00
float bloom_clamp;
Eevee: Add Bloom post process. Based on Kino/Bloom v2 - Bloom filter for Unity MIT license.
2017-05-07 14:27:43 +02:00
float bloom_sample_scale;
float bloom_curve_threshold[4];
float unf_source_texel_size[2];
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
struct GPUTexture *bloom_blit; /* Textures from pool */
struct GPUTexture *bloom_downsample[MAX_BLOOM_STEP];
struct GPUTexture *bloom_upsample[MAX_BLOOM_STEP - 1];
Eevee: Add Bloom post process. Based on Kino/Bloom v2 - Bloom filter for Unity MIT license.
2017-05-07 14:27:43 +02:00
struct GPUTexture *unf_source_buffer; /* pointer copy */
struct GPUTexture *unf_base_buffer; /* pointer copy */
/* Not alloced, just a copy of a *GPUtexture in EEVEE_TextureList. */
struct GPUTexture *source_buffer; /* latest updated texture */
struct GPUFrameBuffer *target_buffer; /* next target to render to */
Eevee: Initial Final Render support. TAA / multiple samples is not working at the moment.
2018-01-29 18:16:11 +01:00
struct GPUTexture *final_tx; /* Final color to transform to display color space. */
struct GPUFrameBuffer *final_fb; /* Framebuffer with final_tx as attachement. */
Eevee: Simple Camera Motion Blur. Disabled by default. Set ENABLE_EFFECT_MOTION_BLUR to 1 to enable. No fancy motion blur. Use depth and camera matrix to get the motion vectors. Then blur in this direction. Only available in camera view. Only Camera animation is supported, does not take into account the parents motion
2017-05-04 17:36:40 +02:00
} EEVEE_EffectsInfo;
Eevee: Put all constant uniforms in a global UBO. This is an optimization / cleanup commit. The use of a global ubo remove lots of uniform lookups and only transfert data when needed. Lots of renaming for more consistent codestyle.
2018-01-21 17:25:10 +01:00
/* ***************** COMMON DATA **************** */
/* Common uniform buffer containing all "constant" data over the whole drawing pipeline. */
/* !! CAUTION !!
Cleanup: typos
2018-07-03 09:08:00 +02:00
* - [i]vec3 need to be padded to [i]vec4 (even in ubo declaration).
Eevee: Put all constant uniforms in a global UBO. This is an optimization / cleanup commit. The use of a global ubo remove lots of uniform lookups and only transfert data when needed. Lots of renaming for more consistent codestyle.
2018-01-21 17:25:10 +01:00
* - Make sure that [i]vec4 start at a multiple of 16 bytes.
* - Arrays of vec2/vec3 are padded as arrays of vec4.
* - sizeof(bool) == sizeof(int) in GLSL so use int in C */
typedef struct EEVEE_CommonUniformBuffer {
float prev_persmat[4][4]; /* mat4 */
float view_vecs[2][4]; /* vec4[2] */
float mip_ratio[10][4]; /* vec2[10] */
/* Ambient Occlusion */
/* -- 16 byte aligned -- */
float ao_dist, pad1, ao_factor, pad2; /* vec4 */
float ao_offset, ao_bounce_fac, ao_quality, ao_settings; /* vec4 */
/* Volumetric */
/* -- 16 byte aligned -- */
int vol_tex_size[3], pad3; /* ivec3 */
float vol_depth_param[3], pad4; /* vec3 */
float vol_inv_tex_size[3], pad5; /* vec3 */
float vol_jitter[3], pad6; /* vec3 */
float vol_coord_scale[2], pad7[2]; /* vec2 */
/* -- 16 byte aligned -- */
float vol_history_alpha; /* float */
float vol_light_clamp; /* float */
float vol_shadow_steps; /* float */
int vol_use_lights; /* bool */
/* Screen Space Reflections */
/* -- 16 byte aligned -- */
float ssr_quality, ssr_thickness, ssr_pixelsize[2]; /* vec4 */
float ssr_border_fac; /* float */
float ssr_max_roughness; /* float */
float ssr_firefly_fac; /* float */
float ssr_brdf_bias; /* float */
int ssr_toggle; /* bool */
/* SubSurface Scattering */
float sss_jitter_threshold; /* float */
int sss_toggle; /* bool */
/* Specular */
int spec_toggle; /* bool */
/* Lamps */
int la_num_light; /* int */
/* Probes */
int prb_num_planar; /* int */
int prb_num_render_cube; /* int */
int prb_num_render_grid; /* int */
int prb_irradiance_vis_size; /* int */
float prb_lod_cube_max; /* float */
float prb_lod_planar_max; /* float */
Eevee: Prepare for fullres tracing
2018-09-11 16:15:34 +02:00
/* Misc */
int hiz_mip_offset; /* int */
Eevee: Put all constant uniforms in a global UBO. This is an optimization / cleanup commit. The use of a global ubo remove lots of uniform lookups and only transfert data when needed. Lots of renaming for more consistent codestyle.
2018-01-21 17:25:10 +01:00
} EEVEE_CommonUniformBuffer;
Eevee: Add new clipping UBO. This fixes problems with the planar reflections.
2018-03-10 00:02:01 +01:00
/* ***************** CLIP PLANES DATA **************** */
typedef struct EEVEE_ClipPlanesUniformBuffer {
float clip_planes[1][4]; /* must be less than MAX_CLIP_PLANES */
} EEVEE_ClipPlanesUniformBuffer;
Eevee: Put shadows and probes inside SceneLayerEngineData This remove the duplication of data for each viewport improving memory usage.
2017-05-30 22:29:20 +02:00
/* ************** SCENE LAYER DATA ************** */
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
typedef struct EEVEE_ViewLayerData {
Eevee: Put shadows and probes inside SceneLayerEngineData This remove the duplication of data for each viewport improving memory usage.
2017-05-30 22:29:20 +02:00
/* Lamps */
struct EEVEE_LampsInfo *lamps;
struct GPUUniformBuffer *light_ubo;
struct GPUUniformBuffer *shadow_ubo;
struct GPUUniformBuffer *shadow_render_ubo;
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
struct GPUUniformBuffer *shadow_samples_ubo;
Eevee: Put shadows and probes inside SceneLayerEngineData This remove the duplication of data for each viewport improving memory usage.
2017-05-30 22:29:20 +02:00
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
struct GPUFrameBuffer *shadow_cube_target_fb;
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
struct GPUFrameBuffer *shadow_cube_store_fb;
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
struct GPUFrameBuffer *shadow_cascade_target_fb;
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
struct GPUFrameBuffer *shadow_cascade_store_fb;
Eevee: Put shadows and probes inside SceneLayerEngineData This remove the duplication of data for each viewport improving memory usage.
2017-05-30 22:29:20 +02:00
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
struct GPUTexture *shadow_cube_target;
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
struct GPUTexture *shadow_cube_blur;
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
struct GPUTexture *shadow_cascade_target;
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
struct GPUTexture *shadow_cascade_blur;
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
struct GPUTexture *shadow_cube_pool;
struct GPUTexture *shadow_cascade_pool;
Eevee: Put shadows and probes inside SceneLayerEngineData This remove the duplication of data for each viewport improving memory usage.
2017-05-30 22:29:20 +02:00
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
struct EEVEE_ShadowCasterBuffer shcasters_buffers[2];
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
Eevee: Put shadows and probes inside SceneLayerEngineData This remove the duplication of data for each viewport improving memory usage.
2017-05-30 22:29:20 +02:00
/* Probes */
Rename probe to light-probe Probe is a real general term, the new name is used often in docs online.
2017-06-12 20:59:54 +10:00
struct EEVEE_LightProbesInfo *probes;
Eevee: Put shadows and probes inside SceneLayerEngineData This remove the duplication of data for each viewport improving memory usage.
2017-05-30 22:29:20 +02:00
struct GPUUniformBuffer *probe_ubo;
Eevee: Add Irradiance Grid support Early implementation. Slow and still has quality 3 ways of storing irradiance: - Spherical Harmonics: Have problem with directionnal lighting. - HL2 diffuse cube: Very low resolution but smooth transitions. - Diffuse cube: High storage requirement. Also include some name change.
2017-06-13 17:39:39 +02:00
struct GPUUniformBuffer *grid_ubo;
Eevee: Initial implementation of planar reflections. Still pretty barebone: No roughness support, No normal distortion support.
2017-06-17 00:08:03 +02:00
struct GPUUniformBuffer *planar_ubo;
Eevee: Put shadows and probes inside SceneLayerEngineData This remove the duplication of data for each viewport improving memory usage.
2017-05-30 22:29:20 +02:00
Eevee: Put all constant uniforms in a global UBO. This is an optimization / cleanup commit. The use of a global ubo remove lots of uniform lookups and only transfert data when needed. Lots of renaming for more consistent codestyle.
2018-01-21 17:25:10 +01:00
/* Common Uniform Buffer */
struct EEVEE_CommonUniformBuffer common_data;
struct GPUUniformBuffer *common_ubo;
Eevee: Add new clipping UBO. This fixes problems with the planar reflections.
2018-03-10 00:02:01 +01:00
struct EEVEE_ClipPlanesUniformBuffer clip_data;
struct GPUUniformBuffer *clip_ubo;
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
struct LightCache *fallback_lightcache;
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
} EEVEE_ViewLayerData;
Eevee: Put shadows and probes inside SceneLayerEngineData This remove the duplication of data for each viewport improving memory usage.
2017-05-30 22:29:20 +02:00
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
/* ************ OBJECT DATA ************ */
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
typedef struct EEVEE_LightData {
short light_id, shadow_id;
} EEVEE_LightData;
typedef struct EEVEE_ShadowCubeData {
short light_id, shadow_id, cube_id, layer_id;
} EEVEE_ShadowCubeData;
typedef struct EEVEE_ShadowCascadeData {
short light_id, shadow_id, cascade_id, layer_id;
float viewprojmat[MAX_CASCADE_NUM][4][4]; /* World->Lamp->NDC : used for rendering the shadow map. */
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
float projmat[MAX_CASCADE_NUM][4][4];
float viewmat[4][4], viewinv[4][4];
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
float radius[MAX_CASCADE_NUM];
} EEVEE_ShadowCascadeData;
/* Theses are the structs stored inside Objects.
* It works with even if the object is in multiple layers
* because we don't get the same "Object *" for each layer. */
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
typedef struct EEVEE_LampEngineData {
DrawData: Change drawdata to a generic struct shared accross ID types This makes tagging much more generic and make the world updates more in line with the new tagging system (Depsgraph).
2018-07-10 14:14:55 +02:00
DrawData dd;
Refactor object engine data storage Main idea is to make specific engine types be a subclass of generic ObjectEngineData structure. This required following changes: - Have extra size argument to engine data allocation function. Not sure whether there is less error-prone way of doing this. - Add init() callback to engine data allocation function. Additionally, added some extra checks to Eevee's engine data getters, so we do not silently cast lamp data to lightprobe data. Reviewers: dfelinto, fclem Differential Revision: https://developer.blender.org/D3027
2018-01-29 16:28:24 +01:00
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
bool need_update;
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* This needs to be out of the union to avoid undefined behaviour. */
short prev_cube_shadow_id;
union {
struct EEVEE_LightData ld;
struct EEVEE_ShadowCubeData scd;
struct EEVEE_ShadowCascadeData scad;
} data;
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
} EEVEE_LampEngineData;
Rename probe to light-probe Probe is a real general term, the new name is used often in docs online.
2017-06-12 20:59:54 +10:00
typedef struct EEVEE_LightProbeEngineData {
DrawData: Change drawdata to a generic struct shared accross ID types This makes tagging much more generic and make the world updates more in line with the new tagging system (Depsgraph).
2018-07-10 14:14:55 +02:00
DrawData dd;
Refactor object engine data storage Main idea is to make specific engine types be a subclass of generic ObjectEngineData structure. This required following changes: - Have extra size argument to engine data allocation function. Not sure whether there is less error-prone way of doing this. - Add init() callback to engine data allocation function. Additionally, added some extra checks to Eevee's engine data getters, so we do not silently cast lamp data to lightprobe data. Reviewers: dfelinto, fclem Differential Revision: https://developer.blender.org/D3027
2018-01-29 16:28:24 +01:00
Eevee: First commit of Probe support.
2017-06-08 21:48:50 +02:00
bool need_update;
Rename probe to light-probe Probe is a real general term, the new name is used often in docs online.
2017-06-12 20:59:54 +10:00
} EEVEE_LightProbeEngineData;
Eevee: First commit of Probe support.
2017-06-08 21:48:50 +02:00
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
typedef struct EEVEE_ObjectEngineData {
DrawData: Change drawdata to a generic struct shared accross ID types This makes tagging much more generic and make the world updates more in line with the new tagging system (Depsgraph).
2018-07-10 14:14:55 +02:00
DrawData dd;
Refactor object engine data storage Main idea is to make specific engine types be a subclass of generic ObjectEngineData structure. This required following changes: - Have extra size argument to engine data allocation function. Not sure whether there is less error-prone way of doing this. - Add init() callback to engine data allocation function. Additionally, added some extra checks to Eevee's engine data getters, so we do not silently cast lamp data to lightprobe data. Reviewers: dfelinto, fclem Differential Revision: https://developer.blender.org/D3027
2018-01-29 16:28:24 +01:00
EEVEE: LightProbe: Implement Visibility Group. Works on every probe type. The function to see is EEVEE_lightprobes_obj_visibility_cb. Set pinfo->vis_data.cached to true makes the computation faster for multiple views using the same group. We could even sort the probes by group for that mater to speed things up even more (only applies to dynamic probes like the planar reflections because other probes are only rendered one at a time).
2018-04-24 12:45:59 +02:00
Object *ob; /* self reference */
EEVEE_LightProbeVisTest *test_data;
bool ob_vis, ob_vis_dirty;
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
bool need_update;
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
uint shadow_caster_id;
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
} EEVEE_ObjectEngineData;
DrawData: Change drawdata to a generic struct shared accross ID types This makes tagging much more generic and make the world updates more in line with the new tagging system (Depsgraph).
2018-07-10 14:14:55 +02:00
typedef struct EEVEE_WorldEngineData {
DrawData dd;
} EEVEE_WorldEngineData;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
/* *********************************** */
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
typedef struct EEVEE_Data {
Draw Manager: Use engine type pointer instead of engine name. Faster search
2017-04-03 19:32:05 +02:00
void *engine_type;
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
EEVEE_FramebufferList *fbl;
EEVEE_TextureList *txl;
EEVEE_PassList *psl;
EEVEE_StorageList *stl;
} EEVEE_Data;
Cleanup: rename struct for private engine data Also remove from pass list (there were some duplicate unused entries).
2017-04-29 16:52:12 +10:00
typedef struct EEVEE_PrivateData {
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
struct DRWShadingGroup *shadow_shgrp;
Draw Engines: Make g_data struct part of the viewport storage This makes viewport cache construction independant from each others and will allow multithread down the road.
2017-03-26 20:13:34 +02:00
struct DRWShadingGroup *depth_shgrp;
struct DRWShadingGroup *depth_shgrp_cull;
Eevee: Add special shader for depth prespass. This way we can extend it to output more data (like motion vectors). Add a variation that uses clip distances.
2017-06-16 23:50:40 +02:00
struct DRWShadingGroup *depth_shgrp_clip;
struct DRWShadingGroup *depth_shgrp_clip_cull;
Eevee: Refraction: Make it available for opaque materials. Theses Materials are rendered after the SSR pass. The only difference with previous method is that they have a depth prepass (less overdraw) and are not sorted.
2017-08-09 23:48:42 +02:00
struct DRWShadingGroup *refract_depth_shgrp;
struct DRWShadingGroup *refract_depth_shgrp_cull;
struct DRWShadingGroup *refract_depth_shgrp_clip;
struct DRWShadingGroup *refract_depth_shgrp_clip_cull;
Eevee: Probes: Add data display for cubemaps.
2017-06-15 00:10:34 +02:00
struct DRWShadingGroup *cube_display_shgrp;
Object Mode : Add probes data outlines and selectability This required some small changes to the data display shaders so that they match the way the object mode renders them. Strangely enough, I had to remove the normal attribute from the display code because it was being not bound as soon as I created another rendering call in object mode. The problem may be deeper but I did not have time for this so I derive the normal from the sphere pos.
2017-09-30 19:34:23 +02:00
struct DRWShadingGroup *planar_display_shgrp;
Eevee: Optimize scene with a large number of objects. Using a GHash to store the shgroup of every Material. This way we do not duplicates the DRWShadingGroups allocations on every object.
2017-06-05 22:05:21 +02:00
struct GHash *material_hash;
Eevee: Planar reflection: Fix normal deformation for background pixels. Now it matches world cubemap perfectly.
2017-06-24 05:24:59 +02:00
float background_alpha; /* TODO find a better place for this. */
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
/* Chosen lightcache: can come from Lookdev or the viewlayer. */
struct LightCache *light_cache;
Eevee: Add Planar reflection blurring. This method is very cheap and inaccurate. This will fill the gap untill better model is supported.
2017-06-26 20:37:41 +02:00
/* For planar probes */
Eevee: Put all constant uniforms in a global UBO. This is an optimization / cleanup commit. The use of a global ubo remove lots of uniform lookups and only transfert data when needed. Lots of renaming for more consistent codestyle.
2018-01-21 17:25:10 +01:00
float planar_texel_size[2];
Eevee: SSR: Add double buffer so we can read previous frame color. Also add simple reprojection and screen fade to the SSR resolve pass.
2017-07-19 14:22:03 +02:00
/* For double buffering */
Eevee: Implement Temporal Anti Aliasing / Super Sampling This adds TAA to eevee. The only thing important to note is that we need to keep the unjittered depth buffer so that the other engines are composited correctly.
2017-09-25 20:14:07 +02:00
bool view_updated;
Eevee: SSR: Add double buffer so we can read previous frame color. Also add simple reprojection and screen fade to the SSR resolve pass.
2017-07-19 14:22:03 +02:00
bool valid_double_buffer;
Eevee: Depth of Feild: Fix ringing issue of background objects There was an issue caused by Antialiasing being done after DoF. Move TAA after DOF and Motion Blur. Also certain pixel with lower CoC would be spread all over the background because the neighbooring pixel have higher CoC. So we need to apply some bilateral filtering when downsampling. Currently we limit the influence of neighbor pixels with a CoC inside the range [MaxCoC-2, MaxCoC].
2018-09-09 23:24:06 +02:00
bool valid_taa_history;
Eevee: Initial Final Render support. TAA / multiple samples is not working at the moment.
2018-01-29 18:16:11 +01:00
/* Render Matrices */
float persmat[4][4], persinv[4][4];
float viewmat[4][4], viewinv[4][4];
float winmat[4][4], wininv[4][4];
EEVEE: LookDev storage list wrongly used
2018-05-28 17:18:27 +02:00
float studiolight_matrix[3][3];
Eevee: Add mist pass support. Eevee: Render: Fix crash when not enabling mist pass.
2018-02-01 18:09:06 +01:00
/* Mist Settings */
float mist_start, mist_inv_dist, mist_falloff;
Viewport: use Filmic without scene exposure/gamma/curves for workbench. This ignores the scene color managment view settings for solid mode and lookdev when not using scene lights and world. The scene settings are intended for tweaking renders and should not affect studio lighting and matcaps. There may be cases where a simple sRGB transform is better than Filmic and we could add configuration for this. Not sure if it really matters and it may be better if we just assume matcaps and studiolights are all created for one view transform. Differential Revision: https://developer.blender.org/D3569
2018-07-30 15:44:25 +02:00
/* Color Management */
bool use_color_view_settings;
Cleanup: rename struct for private engine data Also remove from pass list (there were some duplicate unused entries).
2017-04-29 16:52:12 +10:00
} EEVEE_PrivateData; /* Transient data */
Draw Engines: Make g_data struct part of the viewport storage This makes viewport cache construction independant from each others and will allow multithread down the road.
2017-03-26 20:13:34 +02:00
Eevee: Cleanup. Group data functions into one file.
2017-06-03 00:53:47 +02:00
/* eevee_data.c */
Eevee: Fix assert when baking lightprobes. The GPU context was freed before all framebuffer attached to it were deleted. Fix T56117
2018-07-27 17:33:53 +02:00
void EEVEE_view_layer_data_free(void *sldata);
Eevee: Stop depsgraph update callback form allocating unneeded memory
2017-11-29 11:00:50 +01:00
EEVEE_ViewLayerData *EEVEE_view_layer_data_get(void);
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
EEVEE_ViewLayerData *EEVEE_view_layer_data_ensure_ex(struct ViewLayer *view_layer);
Eevee: Cleanup, naming For functions which will allocate requested data if it does not exist yet "_ensure" is to be used instead of "_get". "_get" functions should return NULL in cases when requested data does not exist yet.
2017-11-29 10:36:58 +01:00
EEVEE_ViewLayerData *EEVEE_view_layer_data_ensure(void);
Eevee: Stop depsgraph update callback form allocating unneeded memory
2017-11-29 11:00:50 +01:00
EEVEE_ObjectEngineData *EEVEE_object_data_get(Object *ob);
Eevee: Cleanup, naming For functions which will allocate requested data if it does not exist yet "_ensure" is to be used instead of "_get". "_get" functions should return NULL in cases when requested data does not exist yet.
2017-11-29 10:36:58 +01:00
EEVEE_ObjectEngineData *EEVEE_object_data_ensure(Object *ob);
Eevee: Stop depsgraph update callback form allocating unneeded memory
2017-11-29 11:00:50 +01:00
EEVEE_LightProbeEngineData *EEVEE_lightprobe_data_get(Object *ob);
Eevee: Cleanup, naming For functions which will allocate requested data if it does not exist yet "_ensure" is to be used instead of "_get". "_get" functions should return NULL in cases when requested data does not exist yet.
2017-11-29 10:36:58 +01:00
EEVEE_LightProbeEngineData *EEVEE_lightprobe_data_ensure(Object *ob);
Eevee: Stop depsgraph update callback form allocating unneeded memory
2017-11-29 11:00:50 +01:00
EEVEE_LampEngineData *EEVEE_lamp_data_get(Object *ob);
Eevee: Cleanup, naming For functions which will allocate requested data if it does not exist yet "_ensure" is to be used instead of "_get". "_get" functions should return NULL in cases when requested data does not exist yet.
2017-11-29 10:36:58 +01:00
EEVEE_LampEngineData *EEVEE_lamp_data_ensure(Object *ob);
DrawData: Change drawdata to a generic struct shared accross ID types This makes tagging much more generic and make the world updates more in line with the new tagging system (Depsgraph).
2018-07-10 14:14:55 +02:00
EEVEE_WorldEngineData *EEVEE_world_data_get(World *wo);
EEVEE_WorldEngineData *EEVEE_world_data_ensure(World *wo);
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
Eevee: Material code refactor. Separate material handling inside another file. Make use of enums to identify shader variations. Group all 64*64 LUTs into one array texture. Only update world probe if world changes.
2017-06-04 12:12:58 +02:00
/* eevee_materials.c */
Eevee: Initial implementation of Volumetrics.
2017-07-03 16:38:14 +02:00
struct GPUTexture *EEVEE_materials_get_util_tex(void); /* XXX */
Eevee: Put all constant uniforms in a global UBO. This is an optimization / cleanup commit. The use of a global ubo remove lots of uniform lookups and only transfert data when needed. Lots of renaming for more consistent codestyle.
2018-01-21 17:25:10 +01:00
void EEVEE_materials_init(EEVEE_ViewLayerData *sldata, EEVEE_StorageList *stl, EEVEE_FramebufferList *fbl);
Eevee: Update to support shader deferred compilation. World probe is tagged to refresh when it it's shader is updated. Probes are recomputed only after all meshes shaders have been compiled.
2018-03-06 02:19:28 +01:00
void EEVEE_materials_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Shadows: Only tag as shadow caster if a shadow is cast. This leads to great improvement if the scene have moving objects without shadows (shadows disabled in the material panel).
2018-05-01 19:32:24 +02:00
void EEVEE_materials_cache_populate(EEVEE_Data *vedata, EEVEE_ViewLayerData *sldata, Object *ob, bool *cast_shadow);
Eevee: Hair: Make hairs visible even if the show emitter option is disabled.
2018-06-02 12:06:24 +02:00
void EEVEE_hair_cache_populate(EEVEE_Data *vedata, EEVEE_ViewLayerData *sldata, Object *ob, bool *cast_shadow);
Eevee: Optimize scene with a large number of objects. Using a GHash to store the shgroup of every Material. This way we do not duplicates the DRWShadingGroups allocations on every object.
2017-06-05 22:05:21 +02:00
void EEVEE_materials_cache_finish(EEVEE_Data *vedata);
Rename probe to light-probe Probe is a real general term, the new name is used often in docs online.
2017-06-12 20:59:54 +10:00
struct GPUMaterial *EEVEE_material_world_lightprobe_get(struct Scene *scene, struct World *wo);
Eevee: Material code refactor. Separate material handling inside another file. Make use of enums to identify shader variations. Group all 64*64 LUTs into one array texture. Only update world probe if world changes.
2017-06-04 12:12:58 +02:00
struct GPUMaterial *EEVEE_material_world_background_get(struct Scene *scene, struct World *wo);
Eevee: Overhaul the volumetric system. The system now uses several 3D textures in order to decouple every steps of the volumetric rendering. See https://www.ea.com/frostbite/news/physically-based-unified-volumetric-rendering-in-frostbite for more details. On the technical side, instead of using a compute shader to populate the 3D textures we use layered rendering with a geometry shader to render 1 fullscreen triangle per 3D texture slice.
2017-10-24 14:49:00 +02:00
struct GPUMaterial *EEVEE_material_world_volume_get(struct Scene *scene, struct World *wo);
Eevee: Transparency: Add support for blend ADD and MULTIPLY. This introduces a new transparency pass. It bypass the radial distance encoding in alpha for the transparent shaders.
2017-07-10 11:41:33 +02:00
struct GPUMaterial *EEVEE_material_mesh_get(
Eevee: Volumetrics: Add volumetric support to alpha blended meshes.
2017-10-24 17:52:20 +02:00
struct Scene *scene, Material *ma, EEVEE_Data *vedata,
Eevee : SSS : Add Translucency support. This adds the possibility to simulate things like red ears with strong backlight or material with high scattering distances. To enable it you need to turn on the "Subsurface Translucency" option in the "Options" tab of the Material Panel (and of course to have "regular" SSS enabled in both render settings and material options). Since the effect is adding another overhead I prefer to make it optional. But this is open to discussion. Be aware that the effect only works for direct lights (so no indirect/world lighting) that have shadowmaps, and is affected by the "softness" of the shadowmap and resolution. Technical notes: This is inspired by http://www.iryoku.com/translucency/ but goes a bit beyond that. We do not use a sum of gaussian to apply in regards to the object thickness but we precompute a 1D kernel texture. This texture stores the light transmited to a point at the back of an infinite slab of material of variying thickness. We make the assumption that the slab is perpendicular to the light so that no fresnel or diffusion term is taken into account. The light is considered constant. If the setup is similar to the one assume during the profile baking, the realtime render matches cycles reference. Due to these assumptions the computed transmitted light is in most cases too bright for curvy objects. Finally we jitter the shadow map sample per pixel so we can simulate dispersion inside the medium. Radius of the dispersion is in world space and derived by from the "soft" shadowmap parameter. Idea for this come from this presentation http://www.iryoku.com/stare-into-the-future (slide 164).
2017-11-22 04:51:21 +01:00
bool use_blend, bool use_multiply, bool use_refract, bool use_sss, bool use_translucency, int shadow_method);
Cleanup: whitespace, long lines, duplicate include
2018-05-26 10:41:25 +02:00
struct GPUMaterial *EEVEE_material_mesh_volume_get(
struct Scene *scene, Material *ma);
struct GPUMaterial *EEVEE_material_mesh_depth_get(
struct Scene *scene, Material *ma, bool use_hashed_alpha, bool is_shadow);
Eevee: Add Variance Shadow Mapping This is an alternative to ESM. It does not suffer the same bleeding artifacts.
2017-09-01 18:39:39 +02:00
struct GPUMaterial *EEVEE_material_hair_get(struct Scene *scene, Material *ma, int shadow_method);
Eevee: Material code refactor. Separate material handling inside another file. Make use of enums to identify shader variations. Group all 64*64 LUTs into one array texture. Only update world probe if world changes.
2017-06-04 12:12:58 +02:00
void EEVEE_materials_free(void);
Eevee: Improve material variation managment. - Unify variations between default shaders and material shader. - Only create default shader passes if needed. Downside is that we have a big array of passes and shading grp in the vedata ... And it will double in size each time a new variation flag is added.
2017-06-22 02:41:17 +02:00
void EEVEE_draw_default_passes(EEVEE_PassList *psl);
Eevee: Style: More Const correctness.
2018-02-03 23:45:53 +01:00
void EEVEE_update_noise(EEVEE_PassList *psl, EEVEE_FramebufferList *fbl, const double offsets[3]);
Eevee: Material code refactor. Separate material handling inside another file. Make use of enums to identify shader variations. Group all 64*64 LUTs into one array texture. Only update world probe if world changes.
2017-06-04 12:12:58 +02:00
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
/* eevee_lights.c */
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
void EEVEE_lights_init(EEVEE_ViewLayerData *sldata);
DRW: Refactor simple instancing. Instead of creating a new instancing shading group without attrib, we now have instancing calls. The benefits is that they can be culled. They can be used in conjuction with the standard and generate calls but shader must support it (which is generally not the case). We store a pointer to the actual count so that the number can be tweaked between redraw. This will makes multi layer rendering more efficient.
2018-03-01 19:27:38 +01:00
void EEVEE_lights_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
void EEVEE_lights_cache_add(EEVEE_ViewLayerData *sldata, struct Object *ob);
Eevee: Fix wrong shadow Orco mapping.
2017-09-12 15:06:07 +02:00
void EEVEE_lights_cache_shcaster_add(
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
EEVEE_ViewLayerData *sldata, EEVEE_StorageList *stl, struct GPUBatch *geom, Object *ob);
Eevee: Transparency: Add support for Clip and Stochastic shadows.
2017-07-11 01:10:57 +02:00
void EEVEE_lights_cache_shcaster_material_add(
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
EEVEE_ViewLayerData *sldata, EEVEE_PassList *psl,
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
struct GPUMaterial *gpumat, struct GPUBatch *geom, struct Object *ob,
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
float *alpha_threshold);
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
void EEVEE_lights_cache_shcaster_object_add(EEVEE_ViewLayerData *sldata, struct Object *ob);
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
void EEVEE_lights_cache_finish(EEVEE_ViewLayerData *sldata);
void EEVEE_lights_update(EEVEE_ViewLayerData *sldata);
void EEVEE_draw_shadows(EEVEE_ViewLayerData *sldata, EEVEE_PassList *psl);
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
void EEVEE_lights_free(void);
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
Rename probe to light-probe Probe is a real general term, the new name is used often in docs online.
2017-06-12 20:59:54 +10:00
/* eevee_lightprobes.c */
EEVEE: LightProbe: Implement Visibility Group. Works on every probe type. The function to see is EEVEE_lightprobes_obj_visibility_cb. Set pinfo->vis_data.cached to true makes the computation faster for multiple views using the same group. We could even sort the probes by group for that mater to speed things up even more (only applies to dynamic probes like the planar reflections because other probes are only rendered one at a time).
2018-04-24 12:45:59 +02:00
bool EEVEE_lightprobes_obj_visibility_cb(bool vis_in, void *user_data);
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
void EEVEE_lightprobes_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
void EEVEE_lightprobes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
void EEVEE_lightprobes_cache_add(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, Object *ob);
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
void EEVEE_lightprobes_cache_finish(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
void EEVEE_lightprobes_refresh(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Render: Make sure all probes are refreshed before rendering.
2018-02-03 01:50:38 +01:00
void EEVEE_lightprobes_refresh_planar(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Rename probe to light-probe Probe is a real general term, the new name is used often in docs online.
2017-06-12 20:59:54 +10:00
void EEVEE_lightprobes_free(void);
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
void EEVEE_lightbake_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, GPUTexture *rt_color, GPUTexture *rt_depth);
void EEVEE_lightbake_render_world(
EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, struct GPUFrameBuffer *face_fb[6]);
void EEVEE_lightbake_render_scene(
EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, struct GPUFrameBuffer *face_fb[6],
const float pos[3], float near_clip, float far_clip);
void EEVEE_lightbake_filter_glossy(
EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, struct GPUTexture *rt_color, struct GPUFrameBuffer *fb,
int probe_idx, float intensity, int maxlevel);
void EEVEE_lightbake_filter_diffuse(
EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, struct GPUTexture *rt_color, struct GPUFrameBuffer *fb,
int grid_offset, float intensity);
void EEVEE_lightbake_filter_visibility(
EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, struct GPUTexture *rt_depth, struct GPUFrameBuffer *fb,
int grid_offset, float clipsta, float clipend, float vis_range, float vis_blur, int vis_size);
void EEVEE_lightprobes_grid_data_from_object(Object *ob, EEVEE_LightGrid *prb_data, int *offset);
void EEVEE_lightprobes_cube_data_from_object(Object *ob, EEVEE_LightProbe *prb_data);
void EEVEE_lightprobes_planar_data_from_object(Object *ob, EEVEE_PlanarReflection *eplanar, EEVEE_LightProbeVisTest *vis_test);
Eevee: Effects: Split each effect in it's own file. This also: - make sure to only compile the shader needed by the active effects. - same thing for the shading groups. - disable TAA if motion blur is active (avoid infinite refresh).
2017-11-01 01:03:36 +01:00
/* eevee_depth_of_field.c */
Eevee: Initial Final Render support. TAA / multiple samples is not working at the moment.
2018-01-29 18:16:11 +01:00
int EEVEE_depth_of_field_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, Object *camera);
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
void EEVEE_depth_of_field_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Effects: Split each effect in it's own file. This also: - make sure to only compile the shader needed by the active effects. - same thing for the shading groups. - disable TAA if motion blur is active (avoid infinite refresh).
2017-11-01 01:03:36 +01:00
void EEVEE_depth_of_field_draw(EEVEE_Data *vedata);
void EEVEE_depth_of_field_free(void);
/* eevee_bloom.c */
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
int EEVEE_bloom_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
void EEVEE_bloom_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Effects: Split each effect in it's own file. This also: - make sure to only compile the shader needed by the active effects. - same thing for the shading groups. - disable TAA if motion blur is active (avoid infinite refresh).
2017-11-01 01:03:36 +01:00
void EEVEE_bloom_draw(EEVEE_Data *vedata);
void EEVEE_bloom_free(void);
/* eevee_occlusion.c */
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
int EEVEE_occlusion_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Render: Add ambient occlusion pass support.
2018-02-03 00:00:19 +01:00
void EEVEE_occlusion_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
void EEVEE_occlusion_output_accumulate(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
void EEVEE_occlusion_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Fix AO in planar reflections.
2018-01-09 19:01:24 +01:00
void EEVEE_occlusion_compute(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, struct GPUTexture *depth_src, int layer);
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
void EEVEE_occlusion_draw_debug(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Effects: Split each effect in it's own file. This also: - make sure to only compile the shader needed by the active effects. - same thing for the shading groups. - disable TAA if motion blur is active (avoid infinite refresh).
2017-11-01 01:03:36 +01:00
void EEVEE_occlusion_free(void);
/* eevee_screen_raytrace.c */
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
int EEVEE_screen_raytrace_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
void EEVEE_screen_raytrace_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
void EEVEE_refraction_compute(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
void EEVEE_reflection_compute(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Effects: Split each effect in it's own file. This also: - make sure to only compile the shader needed by the active effects. - same thing for the shading groups. - disable TAA if motion blur is active (avoid infinite refresh).
2017-11-01 01:03:36 +01:00
void EEVEE_screen_raytrace_free(void);
Eevee: Initial Separable Subsurface Scattering implementation. How to use: - Enable subsurface scattering in the render options. - Add Subsurface BSDF to your shader. - Check "Screen Space Subsurface Scattering" in the material panel options. This initial implementation has a few limitations: - only supports gaussian SSS. - Does not support principled shader. - The radius parameters is baked down to a number of samples and then put into an UBO. This means the radius input socket cannot be used. You need to tweak the default vector directly. - The "texture blur" is considered as always set to 1
2017-11-14 00:49:54 +01:00
/* eevee_subsurface.c */
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
int EEVEE_subsurface_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
void EEVEE_subsurface_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Render: Add Subsurface Pass support.
2018-01-31 21:17:27 +01:00
void EEVEE_subsurface_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Put all constant uniforms in a global UBO. This is an optimization / cleanup commit. The use of a global ubo remove lots of uniform lookups and only transfert data when needed. Lots of renaming for more consistent codestyle.
2018-01-21 17:25:10 +01:00
void EEVEE_subsurface_add_pass(
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, uint sss_id, struct GPUUniformBuffer *sss_profile);
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
void EEVEE_subsurface_data_render(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
void EEVEE_subsurface_compute(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Render: Add Subsurface Pass support.
2018-01-31 21:17:27 +01:00
void EEVEE_subsurface_output_accumulate(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Initial Separable Subsurface Scattering implementation. How to use: - Enable subsurface scattering in the render options. - Add Subsurface BSDF to your shader. - Check "Screen Space Subsurface Scattering" in the material panel options. This initial implementation has a few limitations: - only supports gaussian SSS. - Does not support principled shader. - The radius parameters is baked down to a number of samples and then put into an UBO. This means the radius input socket cannot be used. You need to tweak the default vector directly. - The "texture blur" is considered as always set to 1
2017-11-14 00:49:54 +01:00
void EEVEE_subsurface_free(void);
Eevee: Effects: Split each effect in it's own file. This also: - make sure to only compile the shader needed by the active effects. - same thing for the shading groups. - disable TAA if motion blur is active (avoid infinite refresh).
2017-11-01 01:03:36 +01:00
/* eevee_motion_blur.c */
Eevee: Initial Final Render support. TAA / multiple samples is not working at the moment.
2018-01-29 18:16:11 +01:00
int EEVEE_motion_blur_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, Object *camera);
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
void EEVEE_motion_blur_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Effects: Split each effect in it's own file. This also: - make sure to only compile the shader needed by the active effects. - same thing for the shading groups. - disable TAA if motion blur is active (avoid infinite refresh).
2017-11-01 01:03:36 +01:00
void EEVEE_motion_blur_draw(EEVEE_Data *vedata);
void EEVEE_motion_blur_free(void);
Eevee: Add mist pass support. Eevee: Render: Fix crash when not enabling mist pass.
2018-02-01 18:09:06 +01:00
/* eevee_mist.c */
void EEVEE_mist_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Fix build for MSVC: Remove trailing double semicolon Not sure why but MSVC is complaining for some of those. In particular for the struct in BKE_subdiv_ccg.h. Those were the ones crashing here..
2018-09-20 14:47:10 +00:00
void EEVEE_mist_output_accumulate(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Add mist pass support. Eevee: Render: Fix crash when not enabling mist pass.
2018-02-01 18:09:06 +01:00
void EEVEE_mist_free(void);
Eevee: Effects: Split each effect in it's own file. This also: - make sure to only compile the shader needed by the active effects. - same thing for the shading groups. - disable TAA if motion blur is active (avoid infinite refresh).
2017-11-01 01:03:36 +01:00
/* eevee_temporal_sampling.c */
Eevee: Fix wrong SSR reprojection when switching orthographic view We just reset the temporal sampling and avoid using the previous frame for SSR at all.
2018-07-20 22:43:30 +02:00
void EEVEE_temporal_sampling_reset(EEVEE_Data *vedata);
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
int EEVEE_temporal_sampling_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Add support for TAA/SuperSampling for final render.
2018-01-29 19:39:53 +01:00
void EEVEE_temporal_sampling_matrices_calc(
Eevee: AA: Add Blackmann-Harris pixel filter distribution. This leads to a huge improvement of AntiAliasing quality. There is no other distribution now and there is not settings displayed to the user. That's for another commit.
2018-02-03 23:48:00 +01:00
EEVEE_EffectsInfo *effects, float viewmat[4][4], float persmat[4][4], const double ht_point[2]);
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
void EEVEE_temporal_sampling_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Effects: Split each effect in it's own file. This also: - make sure to only compile the shader needed by the active effects. - same thing for the shading groups. - disable TAA if motion blur is active (avoid infinite refresh).
2017-11-01 01:03:36 +01:00
void EEVEE_temporal_sampling_draw(EEVEE_Data *vedata);
void EEVEE_temporal_sampling_free(void);
/* eevee_volumes.c */
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
int EEVEE_volumes_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
void EEVEE_volumes_set_jitter(EEVEE_ViewLayerData *sldata, uint current_sample);
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
void EEVEE_volumes_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
void EEVEE_volumes_cache_object_add(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, struct Scene *scene, Object *ob);
void EEVEE_volumes_compute(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
void EEVEE_volumes_resolve(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Effects: Split each effect in it's own file. This also: - make sure to only compile the shader needed by the active effects. - same thing for the shading groups. - disable TAA if motion blur is active (avoid infinite refresh).
2017-11-01 01:03:36 +01:00
void EEVEE_volumes_free_smoke_textures(void);
void EEVEE_volumes_free(void);
Eevee: Simple Camera Motion Blur. Disabled by default. Set ENABLE_EFFECT_MOTION_BLUR to 1 to enable. No fancy motion blur. Use depth and camera matrix to get the motion vectors. Then blur in this direction. Only available in camera view. Only Camera animation is supported, does not take into account the parents motion
2017-05-04 17:36:40 +02:00
/* eevee_effects.c */
Eevee: Fix crash when baking Was caused by the normal pass being enbaled in the renderlayer settings. Fix T57344
2018-10-23 15:52:04 +02:00
void EEVEE_effects_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata, Object *camera, const bool minimal);
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
void EEVEE_effects_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Make MinmaxZ compatible with textureArray
2017-07-23 20:33:29 +02:00
void EEVEE_create_minmax_buffer(EEVEE_Data *vedata, struct GPUTexture *depth_src, int layer);
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
void EEVEE_downsample_buffer(EEVEE_Data *vedata, struct GPUTexture *texture_src, int level);
void EEVEE_downsample_cube_buffer(EEVEE_Data *vedata, struct GPUTexture *texture_src, int level);
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
void EEVEE_effects_do_gtao(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Put all constant uniforms in a global UBO. This is an optimization / cleanup commit. The use of a global ubo remove lots of uniform lookups and only transfert data when needed. Lots of renaming for more consistent codestyle.
2018-01-21 17:25:10 +01:00
void EEVEE_draw_effects(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata);
Eevee: Simple Camera Motion Blur. Disabled by default. Set ENABLE_EFFECT_MOTION_BLUR to 1 to enable. No fancy motion blur. Use depth and camera matrix to get the motion vectors. Then blur in this direction. Only available in camera view. Only Camera animation is supported, does not take into account the parents motion
2017-05-04 17:36:40 +02:00
void EEVEE_effects_free(void);
Eevee: Render: Make render passes appear in compositor.
2018-02-01 21:38:16 +01:00
/* eevee_render.c */
Eevee: Initial Final Render support. TAA / multiple samples is not working at the moment.
2018-01-29 18:16:11 +01:00
void EEVEE_render_init(EEVEE_Data *vedata, struct RenderEngine *engine, struct Depsgraph *depsgraph);
void EEVEE_render_cache(void *vedata, struct Object *ob, struct RenderEngine *engine, struct Depsgraph *depsgraph);
Fix border rendering for eevee + stop passing render result around Technically the original issue is that xof/yof in render result is calculated for drawing border render. So a simpler patch could be: ``` - rr->xof = re->disprect.xmin; + rr->xof = re->disprect.xmin + BLI_rcti_cent_x(&re->disprect) - (re->winx / 2); ``` However everywhere in the code we are getting border directly from re->disprect which we may as well do here too. Besides I'm taking this as a chance to get rid of RenderResult in the internal loop of eevee, to help prepare the code to the upcoming rendering pipeline changes.
2018-02-23 13:26:28 -03:00
void EEVEE_render_draw(EEVEE_Data *vedata, struct RenderEngine *engine, struct RenderLayer *render_layer, const struct rcti *rect);
Eevee: Render: Make render passes appear in compositor.
2018-02-01 21:38:16 +01:00
void EEVEE_render_update_passes(struct RenderEngine *engine, struct Scene *scene, struct ViewLayer *view_layer);
Eevee: Initial Final Render support. TAA / multiple samples is not working at the moment.
2018-01-29 18:16:11 +01:00
EEvEE: LookDev
2018-05-25 08:06:36 +02:00
/** eevee_lookdev.c */
EEVEE: LookDev fadeout to the world horizon color
2018-05-29 12:38:19 +02:00
void EEVEE_lookdev_cache_init(EEVEE_Data *vedata, DRWShadingGroup **grp, GPUShader *shader, DRWPass *pass, struct World *world, EEVEE_LightProbesInfo *pinfo);
EEvEE: LookDev
2018-05-25 08:06:36 +02:00
void EEVEE_lookdev_draw_background(EEVEE_Data *vedata);
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
/** eevee_engine.c */
void EEVEE_cache_populate(void *vedata, Object *ob);
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
/* Shadow Matrix */
static const float texcomat[4][4] = { /* From NDC to TexCo */
Eevee: Fix double promotion.
2017-07-13 12:18:39 +02:00
{0.5f, 0.0f, 0.0f, 0.0f},
{0.0f, 0.5f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.5f, 0.0f},
{0.5f, 0.5f, 0.5f, 1.0f}
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
};
/* Cubemap Matrices */
static const float cubefacemat[6][4][4] = {
/* Pos X */
Eevee: Fix double promotion.
2017-07-13 12:18:39 +02:00
{{0.0f, 0.0f, -1.0f, 0.0f},
{0.0f, -1.0f, 0.0f, 0.0f},
{-1.0f, 0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f}},
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
/* Neg X */
Eevee: Fix double promotion.
2017-07-13 12:18:39 +02:00
{{0.0f, 0.0f, 1.0f, 0.0f},
{0.0f, -1.0f, 0.0f, 0.0f},
{1.0f, 0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f}},
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
/* Pos Y */
Eevee: Fix double promotion.
2017-07-13 12:18:39 +02:00
{{1.0f, 0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, -1.0f, 0.0f},
{0.0f, 1.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f}},
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
/* Neg Y */
Eevee: Fix double promotion.
2017-07-13 12:18:39 +02:00
{{1.0f, 0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 1.0f, 0.0f},
{0.0f, -1.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f}},
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
/* Pos Z */
Eevee: Fix double promotion.
2017-07-13 12:18:39 +02:00
{{1.0f, 0.0f, 0.0f, 0.0f},
{0.0f, -1.0f, 0.0f, 0.0f},
{0.0f, 0.0f, -1.0f, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f}},
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
/* Neg Z */
Eevee: Fix double promotion.
2017-07-13 12:18:39 +02:00
{{-1.0f, 0.0f, 0.0f, 0.0f},
{0.0f, -1.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 1.0f, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f}},
Eevee: Introduction of world preconvolved envmap. For now only compute GGX convolution. The GGX LUT used for the split sum approximation (UE4) is merged with the LTX mag LUT that uses the same parameters (theta and roughness)
2017-04-18 12:50:09 +02:00
};
Cleanup: style & header guards
2017-05-08 11:44:58 +10:00
#endif /* __EEVEE_PRIVATE_H__ */
Copy Permalink