blender
/
blender
136
404
Fork 586
Code Issues 6.2k Pull Requests 763 Projects 19 Wiki Activity

GPUCompositing: Remove entire module. 

This module has no use now with the new DrawManager and DrawEngines and it
is using deprecated paths.

Moving gpu_shader_fullscreen_vert.glsl
to draw/modes/shaders/common_fullscreen_vert.glsl
This commit is contained in:
Clément Foucault 2018-03-22 16:10:54 +01:00
parent 6939523a15
commit 47acd706fd
27 changed files with 38 additions and 1914 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
source/blender/blenkernel/BKE_screen.h
View File

@ -327,7 +327,6 @@ void BKE_screen_view3d_scene_sync(struct bScreen *sc, struct Scene *scene);
void BKE_screen_transform_orientation_remove(
const struct bScreen *screen, const struct WorkSpace *workspace,
const struct TransformOrientation *orientation) ATTR_NONNULL();
void BKE_screen_gpu_fx_validate(struct GPUFXSettings *fx_settings);
bool BKE_screen_is_fullscreen_area(const struct bScreen *screen) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL();
bool BKE_screen_is_used(const struct bScreen *screen) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL();

2
source/blender/blenkernel/BKE_sequencer.h
View File

@ -438,7 +438,7 @@ typedef struct ImBuf *(*SequencerDrawView)(
struct ViewLayer *view_layer, struct Object *camera, int width, int height,
unsigned int flag, unsigned int draw_flags, int drawtype, int alpha_mode,
int samples, const char *viewname,
struct GPUFX *fx, struct GPUOffScreen *ofs, char err_out[256]);
struct GPUOffScreen *ofs, char err_out[256]);
extern SequencerDrawView sequencer_view3d_cb;
/* copy/paste */

4
source/blender/blenkernel/intern/camera.c
View File

@ -61,8 +61,6 @@
#include "MEM_guardedalloc.h"
#include "GPU_compositing.h"
/****************************** Camera Datablock *****************************/
void BKE_camera_init(Camera *cam)
@ -79,8 +77,6 @@ void BKE_camera_init(Camera *cam)
cam->flag |= CAM_SHOWPASSEPARTOUT;
cam->passepartalpha = 0.5f;
GPU_fx_compositor_init_dof_settings(&cam->gpu_dof);
/* stereoscopy 3d */
cam->stereo.interocular_distance = 0.065f;
cam->stereo.convergence_distance = 30.f * 0.065f;

25
source/blender/blenkernel/intern/screen.c
View File

@ -39,8 +39,6 @@
#include "MEM_guardedalloc.h"
#include "GPU_compositing.h"
#include "DNA_scene_types.h"
#include "DNA_screen_types.h"
#include "DNA_space_types.h"
@ -684,29 +682,6 @@ float BKE_screen_view3d_zoom_from_fac(float zoomfac)
return ((sqrtf(4.0f * zoomfac) - (float)M_SQRT2) * 50.0f);
}
void BKE_screen_gpu_fx_validate(GPUFXSettings *fx_settings)
{
/* currently we use DOF from the camera _only_,
* so we never allocate this, only copy from the Camera */
#if 0
if ((fx_settings->dof == NULL) &&
(fx_settings->fx_flag & GPU_FX_FLAG_DOF))
{
GPUDOFSettings *fx_dof;
fx_dof = fx_settings->dof = MEM_callocN(sizeof(GPUDOFSettings), __func__);
}
#endif
if ((fx_settings->ssao == NULL) &&
(fx_settings->fx_flag & GPU_FX_FLAG_SSAO))
{
GPUSSAOSettings *fx_ssao;
fx_ssao = fx_settings->ssao = MEM_callocN(sizeof(GPUSSAOSettings), __func__);
GPU_fx_compositor_init_ssao_settings(fx_ssao);
}
}
bool BKE_screen_is_fullscreen_area(const bScreen *screen)
{
return ELEM(screen->state, SCREENMAXIMIZED, SCREENFULL);

2
source/blender/blenkernel/intern/sequencer.c
View File

@ -3337,7 +3337,7 @@ static ImBuf *seq_render_scene_strip(const SeqRenderData *context, Sequence *seq
context->eval_ctx, scene, view_layer, camera, width, height, IB_rect,
draw_flags, context->scene->r.seq_prev_type,
scene->r.alphamode, context->gpu_samples, viewname,
context->gpu_fx, context->gpu_offscreen, err_out);
context->gpu_offscreen, err_out);
if (ibuf == NULL) {
fprintf(stderr, "seq_render_scene_strip failed to get opengl buffer: %s\n", err_out);
}

1
source/blender/draw/CMakeLists.txt
View File

@ -208,6 +208,7 @@ data_to_c_simple(engines/eevee/shaders/volumetric_integration_frag.glsl SRC)
data_to_c_simple(modes/shaders/common_globals_lib.glsl SRC)
data_to_c_simple(modes/shaders/common_view_lib.glsl SRC)
data_to_c_simple(modes/shaders/common_fxaa_lib.glsl SRC)
data_to_c_simple(modes/shaders/common_fullscreen_vert.glsl SRC)
data_to_c_simple(modes/shaders/edit_mesh_overlay_frag.glsl SRC)
data_to_c_simple(modes/shaders/edit_mesh_overlay_vert.glsl SRC)
data_to_c_simple(modes/shaders/edit_mesh_overlay_geom_tri.glsl SRC)

4
source/blender/draw/engines/eevee/eevee_volumes.c
View File

@ -76,7 +76,7 @@ extern char datatoc_volumetric_resolve_frag_glsl[];
extern char datatoc_volumetric_scatter_frag_glsl[];
extern char datatoc_volumetric_integration_frag_glsl[];
extern char datatoc_volumetric_lib_glsl[];
extern char datatoc_gpu_shader_fullscreen_vert_glsl[];
extern char datatoc_common_fullscreen_vert_glsl[];
static void eevee_create_shader_volumes(void)
{
@ -126,7 +126,7 @@ static void eevee_create_shader_volumes(void)
datatoc_volumetric_integration_frag_glsl,
e_data.volumetric_common_lib, NULL);
e_data.volumetric_resolve_sh = DRW_shader_create_with_lib(
datatoc_gpu_shader_fullscreen_vert_glsl, NULL,
datatoc_common_fullscreen_vert_glsl, NULL,
datatoc_volumetric_resolve_frag_glsl,
e_data.volumetric_common_lib, NULL);
}

4
source/blender/draw/intern/draw_manager_shader.c
View File

@ -45,7 +45,7 @@
extern char datatoc_gpu_shader_2D_vert_glsl[];
extern char datatoc_gpu_shader_3D_vert_glsl[];
extern char datatoc_gpu_shader_fullscreen_vert_glsl[];
extern char datatoc_common_fullscreen_vert_glsl[];
/* -------------------------------------------------------------------- */
@ -297,7 +297,7 @@ GPUShader *DRW_shader_create_3D(const char *frag, const char *defines)
GPUShader *DRW_shader_create_fullscreen(const char *frag, const char *defines)
{
return GPU_shader_create(datatoc_gpu_shader_fullscreen_vert_glsl, frag, NULL, NULL, defines);
return GPU_shader_create(datatoc_common_fullscreen_vert_glsl, frag, NULL, NULL, defines);
}
GPUShader *DRW_shader_create_3D_depth_only(void)

4
source/blender/draw/modes/object_mode.c
View File

@ -83,7 +83,7 @@ extern char datatoc_object_particle_dot_frag_glsl[];
extern char datatoc_common_globals_lib_glsl[];
extern char datatoc_common_fxaa_lib_glsl[];
extern char datatoc_gpu_shader_flat_color_frag_glsl[];
extern char datatoc_gpu_shader_fullscreen_vert_glsl[];
extern char datatoc_common_fullscreen_vert_glsl[];
extern char datatoc_gpu_shader_uniform_color_frag_glsl[];
/* *********** LISTS *********** */
@ -307,7 +307,7 @@ static void OBJECT_engine_init(void *vedata)
if (!e_data.outline_resolve_aa_sh) {
e_data.outline_resolve_aa_sh = DRW_shader_create_with_lib(
datatoc_gpu_shader_fullscreen_vert_glsl, NULL,
datatoc_common_fullscreen_vert_glsl, NULL,
datatoc_object_outline_resolve_frag_glsl,
datatoc_common_fxaa_lib_glsl,
"#define FXAA_ALPHA\n"

0
source/blender/gpu/shaders/gpu_shader_fullscreen_vert.glsl → source/blender/draw/modes/shaders/common_fullscreen_vert.glsl
View File

6
source/blender/editors/include/ED_view3d.h
View File

@ -388,7 +388,7 @@ void ED_view3d_draw_offscreen(
const struct EvaluationContext *eval_ctx, struct Scene *scene,
struct ViewLayer *view_layer, struct View3D *v3d, struct ARegion *ar, int winx, int winy, float viewmat[4][4],
float winmat[4][4], bool do_bgpic, bool do_sky, bool is_persp, const char *viewname,
struct GPUFX *fx, struct GPUFXSettings *fx_settings,
struct GPUFXSettings *fx_settings,
struct GPUOffScreen *ofs, struct GPUViewport *viewport);
void ED_view3d_draw_setup_view(
struct wmWindow *win, const struct EvaluationContext *eval_ctx, struct Scene *scene, struct ARegion *ar, struct View3D *v3d,
@ -411,13 +411,13 @@ struct ImBuf *ED_view3d_draw_offscreen_imbuf(
struct ViewLayer *view_layer, struct View3D *v3d, struct ARegion *ar,
int sizex, int sizey, unsigned int flag, unsigned int draw_flags,
int alpha_mode, int samples, const char *viewname,
struct GPUFX *fx, struct GPUOffScreen *ofs, char err_out[256]);
struct GPUOffScreen *ofs, char err_out[256]);
struct ImBuf *ED_view3d_draw_offscreen_imbuf_simple(
const struct EvaluationContext *eval_ctx, struct Scene *scene,
struct ViewLayer *view_layer, struct Object *camera, int width, int height,
unsigned int flag, unsigned int draw_flags, int drawtype, int alpha_mode,
int samples, const char *viewname,
struct GPUFX *fx, struct GPUOffScreen *ofs, char err_out[256]);
struct GPUOffScreen *ofs, char err_out[256]);
struct Base *ED_view3d_give_base_under_cursor(struct bContext *C, const int mval[2]);
void ED_view3d_quadview_update(struct ScrArea *sa, struct ARegion *ar, bool do_clip);

23
source/blender/editors/render/render_opengl.c
View File

@ -74,7 +74,6 @@
#include "RNA_access.h"
#include "RNA_define.h"
#include "GPU_compositing.h"
#include "GPU_framebuffer.h"
#include "GPU_glew.h"
#include "GPU_matrix.h"
@ -122,7 +121,6 @@ typedef struct OGLRender {
GPUOffScreen *ofs;
int ofs_samples;
bool ofs_full_samples;
GPUFX *fx;
int sizex, sizey;
int write_still;
@ -365,7 +363,7 @@ static void screen_opengl_render_doit(const bContext *C, OGLRender *oglrender, R
ibuf_view = ED_view3d_draw_offscreen_imbuf(
&eval_ctx, scene, view_layer, v3d, ar, sizex, sizey,
IB_rectfloat, draw_flags, alpha_mode, oglrender->ofs_samples, viewname,
oglrender->fx, oglrender->ofs, err_out);
oglrender->ofs, err_out);
/* for stamp only */
if (rv3d->persp == RV3D_CAMOB && v3d->camera) {
@ -378,7 +376,7 @@ static void screen_opengl_render_doit(const bContext *C, OGLRender *oglrender, R
&eval_ctx, scene, view_layer, scene->camera, oglrender->sizex, oglrender->sizey,
IB_rectfloat, draw_flags, OB_SOLID,
alpha_mode, oglrender->ofs_samples, viewname,
oglrender->fx, oglrender->ofs, err_out);
oglrender->ofs, err_out);
camera = scene->camera;
}
@ -545,7 +543,6 @@ static void screen_opengl_render_apply(const bContext *C, OGLRender *oglrender)
for (view_id = 0; view_id < oglrender->views_len; view_id++) {
context.view_id = view_id;
context.gpu_offscreen = oglrender->ofs;
context.gpu_fx = oglrender->fx;
context.gpu_full_samples = oglrender->ofs_full_samples;
oglrender->seq_data.ibufs_arr[view_id] = BKE_sequencer_give_ibuf(&context, CFRA, chanshown);
@ -706,19 +703,6 @@ static bool screen_opengl_render_init(bContext *C, wmOperator *op)
/* apply immediately in case we're rendering from a script,
* running notifiers again will overwrite */
oglrender->scene->customdata_mask |= oglrender->scene->customdata_mask_modal;
if (oglrender->v3d->fx_settings.fx_flag & (GPU_FX_FLAG_DOF | GPU_FX_FLAG_SSAO)) {
oglrender->fx = GPU_fx_compositor_create();
}
}
else if (is_sequencer) {
/* NOTE: We allow animation of DoF setting for flexibility in edits, so
* we can't check in advance whether we need FX compositor or not.
* We just always allocated it and make sure it doesn't add extra
* overhead rather than memory allocation here if it's not really
* needed.
*/
oglrender->fx = GPU_fx_compositor_create();
}
/* create render */
@ -844,9 +828,6 @@ static void screen_opengl_render_end(bContext *C, OGLRender *oglrender)
WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, oglrender->scene);
if (oglrender->fx)
GPU_fx_compositor_destroy(oglrender->fx);
DRW_opengl_context_enable();
GPU_offscreen_free(oglrender->ofs);
DRW_opengl_context_disable();

2
source/blender/editors/sculpt_paint/paint_image_proj.c
View File

@ -5478,7 +5478,7 @@ static int texture_paint_image_from_view_exec(bContext *C, wmOperator *op)
ibuf = ED_view3d_draw_offscreen_imbuf(
&eval_ctx, scene, view_layer, CTX_wm_view3d(C), CTX_wm_region(C),
w, h, IB_rect, V3D_OFSDRAW_NONE, R_ALPHAPREMUL, 0, NULL,
NULL, NULL, err_out);
NULL, err_out);
if (!ibuf) {
/* Mostly happens when OpenGL offscreen buffer was failed to create, */
/* but could be other reasons. Should be handled in the future. nazgul */

7
source/blender/editors/space_sequencer/sequencer_draw.c
View File

@ -58,7 +58,6 @@
#include "BIF_glutil.h"
#include "GPU_compositing.h"
#include "GPU_immediate.h"
#include "GPU_immediate_util.h"
#include "GPU_matrix.h"
@ -924,12 +923,6 @@ ImBuf *sequencer_ibuf_get(struct Main *bmain, Scene *scene, SpaceSeq *sseq, int
rectx, recty, proxy_size,
&context);
context.view_id = BKE_scene_multiview_view_id_get(&scene->r, viewname);
if (scene->r.seq_flag & R_SEQ_CAMERA_DOF) {
if (sseq->compositor == NULL) {
sseq->compositor = GPU_fx_compositor_create();
}
context.gpu_fx = sseq->compositor;
}
/* sequencer could start rendering, in this case we need to be sure it wouldn't be canceled
* by Esc pressed somewhere in the past

7
source/blender/editors/space_sequencer/space_sequencer.c
View File

@ -60,8 +60,6 @@
#include "IMB_imbuf.h"
#include "GPU_compositing.h"
#include "sequencer_intern.h" // own include
/**************************** common state *****************************/
@ -220,11 +218,6 @@ static void sequencer_free(SpaceLink *sl)
if (scopes->histogram_ibuf)
IMB_freeImBuf(scopes->histogram_ibuf);
if (sseq->compositor != NULL) {
GPU_fx_compositor_destroy(sseq->compositor);
sseq->compositor = NULL;
}
}

9
source/blender/editors/space_view3d/space_view3d.c
View File

@ -59,7 +59,6 @@
#include "ED_screen.h"
#include "ED_transform.h"
#include "GPU_compositing.h"
#include "GPU_framebuffer.h"
#include "GPU_material.h"
#include "GPU_viewport.h"
@ -568,11 +567,6 @@ static void view3d_main_region_exit(wmWindowManager *wm, ARegion *ar)
rv3d->gpuoffscreen = NULL;
}
if (rv3d->compositor) {
GPU_fx_compositor_destroy(rv3d->compositor);
rv3d->compositor = NULL;
}
if (rv3d->viewport) {
DRW_opengl_context_enable();
GPU_viewport_free(rv3d->viewport);
@ -756,9 +750,6 @@ static void view3d_main_region_free(ARegion *ar)
if (rv3d->gpuoffscreen) {
GPU_offscreen_free(rv3d->gpuoffscreen);
}
if (rv3d->compositor) {
GPU_fx_compositor_destroy(rv3d->compositor);
}
if (rv3d->viewport) {
DRW_opengl_context_enable();
GPU_viewport_free(rv3d->viewport);

43
source/blender/editors/space_view3d/view3d_draw.c
View File

@ -78,7 +78,6 @@
#include "GPU_immediate_util.h"
#include "GPU_material.h"
#include "GPU_viewport.h"
#include "GPU_compositing.h"
#include "MEM_guardedalloc.h"
@ -1988,11 +1987,10 @@ void ED_view3d_draw_offscreen(
const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer,
View3D *v3d, ARegion *ar, int winx, int winy,
float viewmat[4][4], float winmat[4][4],
bool do_bgpic, bool do_sky, bool is_persp, const char *viewname,
GPUFX *fx, GPUFXSettings *fx_settings,
bool do_bgpic, bool do_sky, bool UNUSED(is_persp), const char *viewname,
GPUFXSettings *UNUSED(fx_settings),
GPUOffScreen *ofs, GPUViewport *viewport)
{
bool do_compositing = false;
RegionView3D *rv3d = ar->regiondata;
/* set temporary new size */
@ -2035,30 +2033,7 @@ void ED_view3d_draw_offscreen(
/* main drawing call */
RenderEngineType *engine_type = eval_ctx->engine_type;
if (engine_type->flag & RE_USE_LEGACY_PIPELINE) {
/* framebuffer fx needed, we need to draw offscreen first */
if (v3d->fx_settings.fx_flag && fx) {
GPUSSAOSettings *ssao = NULL;
if (v3d->drawtype < OB_SOLID) {
ssao = v3d->fx_settings.ssao;
v3d->fx_settings.ssao = NULL;
}
do_compositing = GPU_fx_compositor_initialize_passes(fx, &ar->winrct, NULL, fx_settings);
if (ssao)
v3d->fx_settings.ssao = ssao;
}
VP_deprecated_view3d_draw_objects(NULL, eval_ctx, scene, v3d, ar, NULL, do_bgpic, true, do_compositing ? fx : NULL);
/* post process */
if (do_compositing) {
if (!winmat)
is_persp = rv3d->is_persp;
GPU_fx_do_composite_pass(fx, winmat, is_persp, scene, ofs);
}
VP_deprecated_view3d_draw_objects(NULL, eval_ctx, scene, v3d, ar, NULL, do_bgpic, true);
if ((v3d->flag2 & V3D_RENDER_SHADOW) == 0) {
/* draw grease-pencil stuff */
@ -2104,7 +2079,7 @@ ImBuf *ED_view3d_draw_offscreen_imbuf(
unsigned int flag, unsigned int draw_flags,
int alpha_mode, int samples, const char *viewname,
/* output vars */
GPUFX *fx, GPUOffScreen *ofs, char err_out[256])
GPUOffScreen *ofs, char err_out[256])
{
const Depsgraph *depsgraph = eval_ctx->depsgraph;
RegionView3D *rv3d = ar->regiondata;
@ -2178,7 +2153,7 @@ ImBuf *ED_view3d_draw_offscreen_imbuf(
ED_view3d_draw_offscreen(
eval_ctx, scene, view_layer, v3d, ar, sizex, sizey, NULL, winmat,
draw_background, draw_sky, !is_ortho, viewname,
fx, &fx_settings, ofs, NULL);
&fx_settings, ofs, NULL);
if (ibuf->rect_float) {
GPU_offscreen_read_pixels(ofs, GL_FLOAT, ibuf->rect_float);
@ -2202,7 +2177,7 @@ ImBuf *ED_view3d_draw_offscreen_imbuf(
ED_view3d_draw_offscreen(
eval_ctx, scene, view_layer, v3d, ar, sizex, sizey, NULL, winmat,
draw_background, draw_sky, !is_ortho, viewname,
fx, &fx_settings, ofs, viewport);
&fx_settings, ofs, viewport);
GPU_offscreen_read_pixels(ofs, GL_FLOAT, accum_buffer);
/* skip the first sample */
@ -2216,7 +2191,7 @@ ImBuf *ED_view3d_draw_offscreen_imbuf(
ED_view3d_draw_offscreen(
eval_ctx, scene, view_layer, v3d, ar, sizex, sizey, NULL, winmat_jitter,
draw_background, draw_sky, !is_ortho, viewname,
fx, &fx_settings, ofs, viewport);
&fx_settings, ofs, viewport);
GPU_offscreen_read_pixels(ofs, GL_FLOAT, rect_temp);
unsigned int i = sizex * sizey * 4;
@ -2281,7 +2256,7 @@ ImBuf *ED_view3d_draw_offscreen_imbuf_simple(
Object *camera, int width, int height,
unsigned int flag, unsigned int draw_flags, int drawtype,
int alpha_mode, int samples, const char *viewname,
GPUFX *fx, GPUOffScreen *ofs, char err_out[256])
GPUOffScreen *ofs, char err_out[256])
{
View3D v3d = {NULL};
ARegion ar = {NULL};
@ -2340,7 +2315,7 @@ ImBuf *ED_view3d_draw_offscreen_imbuf_simple(
return ED_view3d_draw_offscreen_imbuf(
eval_ctx, scene, view_layer, &v3d, &ar, width, height, flag,
draw_flags, alpha_mode, samples, viewname, fx, ofs, err_out);
draw_flags, alpha_mode, samples, viewname, ofs, err_out);
}
/** \} */

48
source/blender/editors/space_view3d/view3d_draw_legacy.c
View File

@ -100,7 +100,6 @@
#include "GPU_framebuffer.h"
#include "GPU_lamp.h"
#include "GPU_material.h"
#include "GPU_compositing.h"
#include "GPU_extensions.h"
#include "GPU_immediate.h"
#include "GPU_immediate_util.h"
@ -1425,7 +1424,7 @@ static void gpu_update_lamps_shadows_world(const EvaluationContext *eval_ctx, Sc
ED_view3d_draw_offscreen(
eval_ctx, scene, eval_ctx->view_layer, v3d, &ar, winsize, winsize, viewmat, winmat,
false, false, true,
NULL, NULL, NULL, NULL, NULL);
NULL, NULL, NULL, NULL);
GPU_lamp_shadow_buffer_unbind(shadow->lamp);
v3d->drawtype = drawtype;
@ -1499,7 +1498,7 @@ static void view3d_draw_objects(
const EvaluationContext *eval_ctx,
Scene *scene, View3D *v3d, ARegion *ar,
const char **grid_unit,
const bool do_bgpic, const bool draw_offscreen, GPUFX *fx)
const bool do_bgpic, const bool draw_offscreen)
{
ViewLayer *view_layer = C ? CTX_data_view_layer(C) : BKE_view_layer_from_scene_get(scene);
Depsgraph *depsgraph = CTX_data_depsgraph(C);
@ -1510,8 +1509,7 @@ static void view3d_draw_objects(
const bool draw_grids = !draw_offscreen && (v3d->flag2 & V3D_RENDER_OVERRIDE) == 0;
const bool draw_floor = (rv3d->view == RV3D_VIEW_USER) || (rv3d->persp != RV3D_ORTHO);
/* only draw grids after in solid modes, else it hovers over mesh wires */
const bool draw_grids_after = draw_grids && draw_floor && (v3d->drawtype > OB_WIRE) && fx;
bool do_composite_xray = false;
const bool draw_grids_after = draw_grids && draw_floor && (v3d->drawtype > OB_WIRE);
bool xrayclear = true;
if (!draw_offscreen) {
@ -1636,19 +1634,9 @@ static void view3d_draw_objects(
/* transp and X-ray afterdraw stuff */
if (v3d->afterdraw_transp.first) view3d_draw_transp(eval_ctx, scene, view_layer, ar, v3d);
/* always do that here to cleanup depth buffers if none needed */
if (fx) {
do_composite_xray = v3d->zbuf && (v3d->afterdraw_xray.first || v3d->afterdraw_xraytransp.first);
GPU_fx_compositor_setup_XRay_pass(fx, do_composite_xray);
}
if (v3d->afterdraw_xray.first) view3d_draw_xray(eval_ctx, scene, view_layer, ar, v3d, &xrayclear);
if (v3d->afterdraw_xraytransp.first) view3d_draw_xraytransp(eval_ctx, scene, view_layer, ar, v3d, xrayclear);
if (fx && do_composite_xray) {
GPU_fx_compositor_XRay_resolve(fx);
}
if (!draw_offscreen) {
ED_region_draw_cb_draw(C, ar, REGION_DRAW_POST_VIEW);
}
@ -1957,9 +1945,6 @@ static void view3d_main_region_draw_objects(
CTX_data_eval_ctx(C, &eval_ctx);
/* post processing */
bool do_compositing = false;
/* shadow buffers, before we setup matrices */
if (draw_glsl_material(&eval_ctx, scene, view_layer, NULL, v3d, v3d->drawtype))
gpu_update_lamps_shadows_world(&eval_ctx, scene, v3d);
@ -1987,30 +1972,9 @@ static void view3d_main_region_draw_objects(
update_lods(scene, rv3d->viewinv[3]);
}
#endif
/* framebuffer fx needed, we need to draw offscreen first */
if (v3d->fx_settings.fx_flag && v3d->drawtype >= OB_SOLID) {
BKE_screen_gpu_fx_validate(&v3d->fx_settings);
GPUFXSettings fx_settings = v3d->fx_settings;
if (!rv3d->compositor)
rv3d->compositor = GPU_fx_compositor_create();
if (rv3d->persp == RV3D_CAMOB && v3d->camera)
BKE_camera_to_gpu_dof(v3d->camera, &fx_settings);
else {
fx_settings.dof = NULL;
}
do_compositing = GPU_fx_compositor_initialize_passes(rv3d->compositor, &ar->winrct, &ar->drawrct, &fx_settings);
}
/* main drawing call */
view3d_draw_objects(C, &eval_ctx, scene, v3d, ar, grid_unit, true, false, do_compositing ? rv3d->compositor : NULL);
/* post process */
if (do_compositing) {
GPU_fx_do_composite_pass(rv3d->compositor, rv3d->winmat, rv3d->is_persp, scene, NULL);
}
view3d_draw_objects(C, &eval_ctx, scene, v3d, ar, grid_unit, true, false);
if (v3d->lay_used != lay_used) { /* happens when loading old files or loading with UI load */
/* find header and force tag redraw */
@ -2170,9 +2134,9 @@ void VP_deprecated_view3d_draw_objects(
const EvaluationContext *eval_ctx,
Scene *scene, View3D *v3d, ARegion *ar,
const char **grid_unit,
const bool do_bgpic, const bool draw_offscreen, GPUFX *fx)
const bool do_bgpic, const bool draw_offscreen)
{
view3d_draw_objects(C, eval_ctx, scene, v3d, ar, grid_unit, do_bgpic, draw_offscreen, fx);
view3d_draw_objects(C, eval_ctx, scene, v3d, ar, grid_unit, do_bgpic, draw_offscreen);
}
void VP_deprecated_gpu_update_lamps_shadows_world(const EvaluationContext *eval_ctx, Scene *scene, View3D *v3d)

2
source/blender/editors/space_view3d/view3d_intern.h
View File

@ -402,6 +402,6 @@ void VP_deprecated_view3d_draw_objects(
const struct EvaluationContext *eval_ctx,
Scene *scene, View3D *v3d, ARegion *ar,
const char **grid_unit,
const bool do_bgpic, const bool draw_offscreen, struct GPUFX *fx);
const bool do_bgpic, const bool draw_offscreen);
#endif /* __VIEW3D_INTERN_H__ */

11
source/blender/gpu/CMakeLists.txt
View File

@ -55,7 +55,6 @@ set(SRC
intern/gpu_batch_presets.c
intern/gpu_buffers.c
intern/gpu_codegen.c
intern/gpu_compositing.c
intern/gpu_debug.c
intern/gpu_draw.c
intern/gpu_extensions.c
@ -99,7 +98,6 @@ set(SRC
GPU_basic_shader.h
GPU_batch.h
GPU_buffers.h
GPU_compositing.h
GPU_debug.h
GPU_draw.h
GPU_extensions.h
@ -222,15 +220,6 @@ data_to_c_simple(shaders/gpu_shader_vertex.glsl SRC)
data_to_c_simple(shaders/gpu_shader_vertex_world.glsl SRC)
data_to_c_simple(shaders/gpu_shader_vsm_store_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_vsm_store_vert.glsl SRC)
data_to_c_simple(shaders/gpu_shader_fullscreen_vert.glsl SRC)
data_to_c_simple(shaders/gpu_shader_fx_ssao_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_fx_dof_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_fx_dof_vert.glsl SRC)
data_to_c_simple(shaders/gpu_shader_fx_dof_hq_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_fx_dof_hq_vert.glsl SRC)
data_to_c_simple(shaders/gpu_shader_fx_dof_hq_geo.glsl SRC)
data_to_c_simple(shaders/gpu_shader_fx_depth_resolve.glsl SRC)
data_to_c_simple(shaders/gpu_shader_fx_lib.glsl SRC)
if(WITH_GAMEENGINE)
add_definitions(-DWITH_GAMEENGINE)

106
source/blender/gpu/GPU_compositing.h
View File

@ -1,106 +0,0 @@
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* 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.
*
* The Original Code is Copyright (C) 2005 Blender Foundation.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): Antony Riakiotakis.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file GPU_compositing.h
* \ingroup gpu
*/
#ifndef __GPU_COMPOSITING_H__
#define __GPU_COMPOSITING_H__
#ifdef __cplusplus
extern "C" {
#endif
/* opaque handle for framebuffer compositing effects (defined in gpu_compositing.c )*/
typedef struct GPUFX GPUFX;
struct GPUDOFSettings;
struct GPUSSAOSettings;
struct GPUOffScreen;
struct GPUFXSettings;
struct rcti;
struct Scene;
struct GPUShader;
enum eGPUFXFlags;
/**** Public API *****/
typedef enum GPUFXShaderEffect {
/* Screen space ambient occlusion shader */
GPU_SHADER_FX_SSAO = 1,
/* depth of field passes. Yep, quite a complex effect */
GPU_SHADER_FX_DEPTH_OF_FIELD_PASS_ONE = 2,
GPU_SHADER_FX_DEPTH_OF_FIELD_PASS_TWO = 3,
GPU_SHADER_FX_DEPTH_OF_FIELD_PASS_THREE = 4,
GPU_SHADER_FX_DEPTH_OF_FIELD_PASS_FOUR = 5,
GPU_SHADER_FX_DEPTH_OF_FIELD_PASS_FIVE = 6,
/* high quality */
GPU_SHADER_FX_DEPTH_OF_FIELD_HQ_PASS_ONE = 7,
GPU_SHADER_FX_DEPTH_OF_FIELD_HQ_PASS_TWO = 8,
GPU_SHADER_FX_DEPTH_OF_FIELD_HQ_PASS_THREE = 9,
GPU_SHADER_FX_DEPTH_RESOLVE = 10,
} GPUFXShaderEffect;
/* keep in synch with enum above! */
#define MAX_FX_SHADERS 11
/* generate a new FX compositor */
GPUFX *GPU_fx_compositor_create(void);
/* destroy a text compositor */
void GPU_fx_compositor_destroy(GPUFX *fx);
/* initialize a framebuffer with size taken from the viewport */
bool GPU_fx_compositor_initialize_passes(
GPUFX *fx, const struct rcti *rect, const struct rcti *scissor_rect,
const struct GPUFXSettings *fx_settings);
/* do compositing on the fx passes that have been initialized */
bool GPU_fx_do_composite_pass(
GPUFX *fx, float projmat[4][4], bool is_persp,
struct Scene *scene, struct GPUOffScreen *ofs);
/* bind new depth buffer for XRay pass */
void GPU_fx_compositor_setup_XRay_pass(GPUFX *fx, bool do_xray);
/* resolve a final depth buffer by compositing the XRay and normal depth buffers */
void GPU_fx_compositor_XRay_resolve(GPUFX *fx);
void GPU_fx_compositor_init_dof_settings(struct GPUDOFSettings *dof);
void GPU_fx_compositor_init_ssao_settings(struct GPUSSAOSettings *ssao);
/* initialize and cache the shader unform interface for effects */
void GPU_fx_shader_init_interface(struct GPUShader *shader, GPUFXShaderEffect effect);
#ifdef __cplusplus
}
#endif
#endif // __GPU_COMPOSITING_H__

4
source/blender/gpu/GPU_shader.h
View File

@ -72,9 +72,6 @@ int GPU_shader_get_program(GPUShader *shader);
void *GPU_shader_get_interface(GPUShader *shader);
void *GPU_fx_shader_get_interface(GPUShader *shader);
void GPU_fx_shader_set_interface(GPUShader *shader, void *interface);
int GPU_shader_get_uniform(GPUShader *shader, const char *name);
int GPU_shader_get_builtin_uniform(GPUShader *shader, int builtin);
int GPU_shader_get_uniform_block(GPUShader *shader, const char *name);
@ -191,7 +188,6 @@ typedef enum GPUInterlaceShader {
} GPUInterlaceShader;
GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader);
GPUShader *GPU_shader_get_builtin_fx_shader(int effects, bool persp);
void GPU_shader_free_builtin_shaders(void);

1494
source/blender/gpu/intern/gpu_compositing.c
View File

File diff suppressed because it is too large Load Diff

127
source/blender/gpu/intern/gpu_shader.c
View File

@ -37,7 +37,6 @@
#include "DNA_space_types.h"
#include "GPU_compositing.h"
#include "GPU_extensions.h"
#include "GPU_matrix.h"
#include "GPU_shader.h"
@ -145,22 +144,10 @@ extern char datatoc_gpu_shader_vsm_store_vert_glsl[];
extern char datatoc_gpu_shader_vsm_store_frag_glsl[];
extern char datatoc_gpu_shader_sep_gaussian_blur_vert_glsl[];
extern char datatoc_gpu_shader_sep_gaussian_blur_frag_glsl[];
extern char datatoc_gpu_shader_fullscreen_vert_glsl[];
extern char datatoc_gpu_shader_fx_ssao_frag_glsl[];
extern char datatoc_gpu_shader_fx_dof_frag_glsl[];
extern char datatoc_gpu_shader_fx_dof_vert_glsl[];
extern char datatoc_gpu_shader_fx_dof_hq_frag_glsl[];
extern char datatoc_gpu_shader_fx_dof_hq_vert_glsl[];
extern char datatoc_gpu_shader_fx_dof_hq_geo_glsl[];
extern char datatoc_gpu_shader_fx_depth_resolve_glsl[];
extern char datatoc_gpu_shader_fx_lib_glsl[];
/* cache of built-in shaders (each is created on first use) */
static GPUShader *builtin_shaders[GPU_NUM_BUILTIN_SHADERS] = { NULL };
/* cache for shader fx. Those can exist in combinations so store them here */
static GPUShader *fx_shaders[MAX_FX_SHADERS * 2] = { NULL };
typedef struct {
const char *vert;
const char *frag;
@ -574,11 +561,6 @@ int GPU_shader_get_uniform_block(GPUShader *shader, const char *name)
return ubo ? ubo->location : -1;
}
void *GPU_fx_shader_get_interface(GPUShader *shader)
{
return shader->uniform_interface;
}
void *GPU_shader_get_interface(GPUShader *shader)
{
return shader->interface;
@ -590,11 +572,6 @@ int GPU_shader_get_program(GPUShader *shader)
return (int)shader->program;
}
void GPU_fx_shader_set_interface(GPUShader *shader, void *interface)
{
shader->uniform_interface = interface;
}
void GPU_shader_uniform_vector(GPUShader *UNUSED(shader), int location, int length, int arraysize, const float *value)
{
if (location == -1 || value == NULL)
@ -641,32 +618,17 @@ void GPU_shader_uniform_buffer(GPUShader *shader, int location, GPUUniformBuffer
void GPU_shader_uniform_texture(GPUShader *UNUSED(shader), int location, GPUTexture *tex)
{
int number = GPU_texture_bound_number(tex);
int bindcode = GPU_texture_opengl_bindcode(tex);
int target = GPU_texture_target(tex);
if (number >= GPU_max_textures()) {
fprintf(stderr, "Not enough texture slots.\n");
if (number == -1) {
fprintf(stderr, "Texture is not bound.\n");
BLI_assert(0);
return;
}
if (number == -1)
return;
if (location == -1)
return;
if (number != 0)
glActiveTexture(GL_TEXTURE0 + number);
if (bindcode != 0)
glBindTexture(target, bindcode);
else
GPU_invalid_tex_bind(target);
glUniform1i(location, number);
if (number != 0)
glActiveTexture(GL_TEXTURE0);
}
int GPU_shader_get_attribute(GPUShader *shader, const char *name)
@ -885,82 +847,6 @@ GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader)
#define MAX_DEFINES 100
GPUShader *GPU_shader_get_builtin_fx_shader(int effect, bool persp)
{
int offset;
char defines[MAX_DEFINES] = "";
/* avoid shaders out of range */
if (effect >= MAX_FX_SHADERS)
return NULL;
offset = 2 * effect;
if (persp) {
offset += 1;
strcat(defines, "#define PERSP_MATRIX\n");
}
if (!fx_shaders[offset]) {
GPUShader *shader = NULL;
switch (effect) {
case GPU_SHADER_FX_SSAO:
shader = GPU_shader_create(datatoc_gpu_shader_fullscreen_vert_glsl, datatoc_gpu_shader_fx_ssao_frag_glsl, NULL, datatoc_gpu_shader_fx_lib_glsl, defines);
break;
case GPU_SHADER_FX_DEPTH_OF_FIELD_PASS_ONE:
strcat(defines, "#define FIRST_PASS\n");
shader = GPU_shader_create(datatoc_gpu_shader_fx_dof_vert_glsl, datatoc_gpu_shader_fx_dof_frag_glsl, NULL, datatoc_gpu_shader_fx_lib_glsl, defines);
break;
case GPU_SHADER_FX_DEPTH_OF_FIELD_PASS_TWO:
strcat(defines, "#define SECOND_PASS\n");
shader = GPU_shader_create(datatoc_gpu_shader_fx_dof_vert_glsl, datatoc_gpu_shader_fx_dof_frag_glsl, NULL, datatoc_gpu_shader_fx_lib_glsl, defines);
break;
case GPU_SHADER_FX_DEPTH_OF_FIELD_PASS_THREE:
strcat(defines, "#define THIRD_PASS\n");
shader = GPU_shader_create(datatoc_gpu_shader_fx_dof_vert_glsl, datatoc_gpu_shader_fx_dof_frag_glsl, NULL, datatoc_gpu_shader_fx_lib_glsl, defines);
break;
case GPU_SHADER_FX_DEPTH_OF_FIELD_PASS_FOUR:
strcat(defines, "#define FOURTH_PASS\n");
shader = GPU_shader_create(datatoc_gpu_shader_fx_dof_vert_glsl, datatoc_gpu_shader_fx_dof_frag_glsl, NULL, datatoc_gpu_shader_fx_lib_glsl, defines);
break;
case GPU_SHADER_FX_DEPTH_OF_FIELD_PASS_FIVE:
strcat(defines, "#define FIFTH_PASS\n");
shader = GPU_shader_create(datatoc_gpu_shader_fx_dof_vert_glsl, datatoc_gpu_shader_fx_dof_frag_glsl, NULL, datatoc_gpu_shader_fx_lib_glsl, defines);
break;
case GPU_SHADER_FX_DEPTH_OF_FIELD_HQ_PASS_ONE:
strcat(defines, "#define FIRST_PASS\n");
shader = GPU_shader_create(datatoc_gpu_shader_fx_dof_hq_vert_glsl, datatoc_gpu_shader_fx_dof_hq_frag_glsl, NULL, datatoc_gpu_shader_fx_lib_glsl, defines);
break;
case GPU_SHADER_FX_DEPTH_OF_FIELD_HQ_PASS_TWO:
strcat(defines, "#define SECOND_PASS\n");
shader = GPU_shader_create(datatoc_gpu_shader_fx_dof_hq_vert_glsl, datatoc_gpu_shader_fx_dof_hq_frag_glsl, datatoc_gpu_shader_fx_dof_hq_geo_glsl, datatoc_gpu_shader_fx_lib_glsl, defines);
break;
case GPU_SHADER_FX_DEPTH_OF_FIELD_HQ_PASS_THREE:
strcat(defines, "#define THIRD_PASS\n");
shader = GPU_shader_create(datatoc_gpu_shader_fx_dof_hq_vert_glsl, datatoc_gpu_shader_fx_dof_hq_frag_glsl, NULL, datatoc_gpu_shader_fx_lib_glsl, defines);
break;
case GPU_SHADER_FX_DEPTH_RESOLVE:
shader = GPU_shader_create(datatoc_gpu_shader_fullscreen_vert_glsl, datatoc_gpu_shader_fx_depth_resolve_glsl, NULL, NULL, defines);
break;
}
fx_shaders[offset] = shader;
GPU_fx_shader_init_interface(shader, effect);
}
return fx_shaders[offset];
}
void GPU_shader_free_builtin_shaders(void)
{
for (int i = 0; i < GPU_NUM_BUILTIN_SHADERS; ++i) {
@ -969,11 +855,4 @@ void GPU_shader_free_builtin_shaders(void)
builtin_shaders[i] = NULL;
}
}
for (int i = 0; i < 2 * MAX_FX_SHADERS; ++i) {
if (fx_shaders[i]) {
GPU_shader_free(fx_shaders[i]);
fx_shaders[i] = NULL;
}
}
}

11
source/blender/makesrna/intern/rna_scene.c
View File

@ -1925,13 +1925,6 @@ char *rna_GPUDOF_path(PointerRNA *ptr)
return BLI_strdup("");
}
static void rna_GPUFXSettings_fx_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
{
GPUFXSettings *fx_settings = ptr->data;
BKE_screen_gpu_fx_validate(fx_settings);
}
static void rna_GPUDOFSettings_blades_set(PointerRNA *ptr, const int value)
{
GPUDOFSettings *dofsettings = (GPUDOFSettings *)ptr->data;
@ -4839,7 +4832,7 @@ static void rna_def_gpu_fx(BlenderRNA *brna)
RNA_def_property_boolean_sdna(prop, NULL, "fx_flag", GPU_FX_FLAG_DOF);
RNA_def_property_ui_text(prop, "Depth Of Field",
"Use depth of field on viewport using the values from active camera");
RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_GPUFXSettings_fx_update");
RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
prop = RNA_def_property(srna, "ssao", PROP_POINTER, PROP_NONE);
@ -4850,7 +4843,7 @@ static void rna_def_gpu_fx(BlenderRNA *brna)
prop = RNA_def_property(srna, "use_ssao", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "fx_flag", GPU_FX_FLAG_SSAO);
RNA_def_property_ui_text(prop, "SSAO", "Use screen space ambient occlusion of field on viewport");
RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_GPUFXSettings_fx_update");
RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
}
static void rna_def_view_layers(BlenderRNA *brna, PropertyRNA *cprop)

1
source/blender/python/intern/gpu_offscreen.c
View File

@ -37,7 +37,6 @@
#include "ED_screen.h"
#include "GPU_compositing.h"
#include "GPU_framebuffer.h"
#include "GPU_texture.h"

4
source/blender/windowmanager/intern/wm_files.c
View File

@ -1046,14 +1046,14 @@ static ImBuf *blend_file_thumb(const bContext *C, Scene *scene, ViewLayer *view_
&eval_ctx, scene, view_layer, scene->camera,
BLEN_THUMB_SIZE * 2, BLEN_THUMB_SIZE * 2,
IB_rect, V3D_OFSDRAW_NONE, OB_SOLID, R_ALPHAPREMUL, 0, NULL,
NULL, NULL, err_out);
NULL, err_out);
}
else {
ibuf = ED_view3d_draw_offscreen_imbuf(
&eval_ctx, scene, view_layer, v3d, ar,
BLEN_THUMB_SIZE * 2, BLEN_THUMB_SIZE * 2,
IB_rect, V3D_OFSDRAW_NONE, R_ALPHAPREMUL, 0, NULL,
NULL, NULL, err_out);
NULL, err_out);
}
if (ibuf) {