Differential D3057 Diff 10008 source/blender/draw/intern/draw_manager.c

Changeset View

Standalone View

source/blender/draw/intern/draw_manager.c

Show All 24 Lines

#include <stdio.h>		#include <stdio.h>

#include "BLI_listbase.h"		#include "BLI_listbase.h"
#include "BLI_mempool.h"		#include "BLI_mempool.h"
#include "BLI_rect.h"		#include "BLI_rect.h"
#include "BLI_string.h"		#include "BLI_string.h"
#include "BLI_string_utils.h"		#include "BLI_string_utils.h"
		#include "BLI_threads.h"

#include "BIF_glutil.h"		#include "BIF_glutil.h"

#include "BKE_curve.h"		#include "BKE_curve.h"
#include "BKE_global.h"		#include "BKE_global.h"
#include "BKE_mesh.h"		#include "BKE_mesh.h"
#include "BKE_object.h"		#include "BKE_object.h"
#include "BKE_pbvh.h"		#include "BKE_pbvh.h"
Show All 36 Lines
#include "RE_engine.h"		#include "RE_engine.h"
#include "RE_pipeline.h"		#include "RE_pipeline.h"

#include "UI_interface.h"		#include "UI_interface.h"
#include "UI_resources.h"		#include "UI_resources.h"

#include "WM_api.h"		#include "WM_api.h"
#include "WM_types.h"		#include "WM_types.h"
		#include "wm_window.h"

#include "draw_manager_text.h"		#include "draw_manager_text.h"
#include "draw_manager_profiling.h"		#include "draw_manager_profiling.h"

/* only for callbacks */		/* only for callbacks */
#include "draw_cache_impl.h"		#include "draw_cache_impl.h"

#include "draw_instance_data.h"		#include "draw_instance_data.h"
▲ Show 20 Lines • Show All 276 Lines • ▼ Show 20 Lines

static struct DRWMatrixOveride {		static struct DRWMatrixOveride {
float mat[6][4][4];		float mat[6][4][4];
bool override[6];		bool override[6];
} viewport_matrix_override = {{{{0}}}};		} viewport_matrix_override = {{{{0}}}};

ListBase DRW_engines = {NULL, NULL};		ListBase DRW_engines = {NULL, NULL};

		/* Unique ghost context used by the draw manager. */
		static void *g_ogl_context = NULL;

		/* Mutex to lock the drw manager and avoid concurent context usage. */
		static ThreadRWMutex cache_rwlock = BLI_RWLOCK_INITIALIZER;
		brechtUnsubmitted Not Done Inline Actions Only write locks are used for this read-write mutex, so unless you are planning to use read locks you could use a regular mutex instead. brecht: Only write locks are used for this read-write mutex, so unless you are planning to use read…

		brechtUnsubmitted Not Done Inline Actions Rename to `g_ogl_context_lock` or something like that? brecht: Rename to `g_ogl_context_lock` or something like that?
#ifdef USE_GPU_SELECT		#ifdef USE_GPU_SELECT
static unsigned int g_DRW_select_id = (unsigned int)-1;		static unsigned int g_DRW_select_id = (unsigned int)-1;

void DRW_select_load_id(unsigned int id)		void DRW_select_load_id(unsigned int id)
{		{
BLI_assert(G.f & G_PICKSEL);		BLI_assert(G.f & G_PICKSEL);
g_DRW_select_id = id;		g_DRW_select_id = id;
}		}
▲ Show 20 Lines • Show All 3,066 Lines • ▼ Show 20 Lines
* Need to reset DST before calling this function		* Need to reset DST before calling this function
*/		*/
void DRW_draw_render_loop_ex(		void DRW_draw_render_loop_ex(
struct Depsgraph *depsgraph,		struct Depsgraph *depsgraph,
RenderEngineType *engine_type,		RenderEngineType *engine_type,
ARegion ar, View3D v3d, const eObjectMode object_mode,		ARegion ar, View3D v3d, const eObjectMode object_mode,
const bContext *evil_C)		const bContext *evil_C)
{		{

Scene *scene = DEG_get_evaluated_scene(depsgraph);		Scene *scene = DEG_get_evaluated_scene(depsgraph);
ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);		ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
RegionView3D *rv3d = ar->regiondata;		RegionView3D *rv3d = ar->regiondata;

DST.draw_ctx.evil_C = evil_C;		DST.draw_ctx.evil_C = evil_C;

DST.viewport = rv3d->viewport;		DST.viewport = rv3d->viewport;
v3d->zbuf = true;		v3d->zbuf = true;
▲ Show 20 Lines • Show All 169 Lines • ▼ Show 20 Lines
{		{
Scene *scene = DEG_get_evaluated_scene(depsgraph);		Scene *scene = DEG_get_evaluated_scene(depsgraph);
ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);		ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
RenderEngineType *engine_type = re->type;		RenderEngineType *engine_type = re->type;
DrawEngineType *draw_engine_type = engine_type->draw_engine;		DrawEngineType *draw_engine_type = engine_type->draw_engine;
RenderData *r = &scene->r;		RenderData *r = &scene->r;
Render *render = re->re;		Render *render = re->re;
const EvaluationContext *eval_ctx = RE_GetEvalCtx(render);		const EvaluationContext *eval_ctx = RE_GetEvalCtx(render);
		/* Changing Context */
		BLI_rw_mutex_lock(&cache_rwlock, THREAD_LOCK_WRITE);
		/* IMPORTANT: We dont support immediate mode in render mode! */
		WM_context_activate(g_ogl_context);
		brechtUnsubmitted Not Done Inline Actions Maybe add a `DRW_ogl_select_ctx_enable()` and use it here? Just to keep that locking logic together a bit. brecht: Maybe add a `DRW_ogl_select_ctx_enable()` and use it here? Just to keep that locking logic…

/* Reset before using it. */		/* Reset before using it. */
memset(&DST, 0x0, sizeof(DST));		memset(&DST, 0x0, sizeof(DST));
DST.options.is_image_render = true;		DST.options.is_image_render = true;
DST.options.is_scene_render = true;		DST.options.is_scene_render = true;
DST.options.draw_background = scene->r.alphamode == R_ADDSKY;		DST.options.draw_background = scene->r.alphamode == R_ADDSKY;

DST.draw_ctx = (DRWContextState){		DST.draw_ctx = (DRWContextState){
Show All 38 Lines	void DRW_render_to_image(RenderEngine re, struct Depsgraph depsgraph)
* on at this point. */		* on at this point. */
glDisable(GL_DEPTH_TEST);		glDisable(GL_DEPTH_TEST);

/* Restore Drawing area. */		/* Restore Drawing area. */
gpuPopAttrib();		gpuPopAttrib();
glEnable(GL_SCISSOR_TEST);		glEnable(GL_SCISSOR_TEST);
GPU_framebuffer_restore();		GPU_framebuffer_restore();

		/* Changing Context */
		wm_window_reset_drawable();
		BLI_rw_mutex_unlock(&cache_rwlock);

#ifdef DEBUG		#ifdef DEBUG
/* Avoid accidental reuse. */		/* Avoid accidental reuse. */
memset(&DST, 0xFF, sizeof(DST));		memset(&DST, 0xFF, sizeof(DST));
#endif		#endif
}		}

void DRW_render_object_iter(		void DRW_render_object_iter(
void vedata, RenderEngine engine, struct Depsgraph *depsgraph,		void vedata, RenderEngine engine, struct Depsgraph *depsgraph,
void (callback)(void vedata, Object ob, RenderEngine engine, struct Depsgraph *depsgraph))		void (callback)(void vedata, Object ob, RenderEngine engine, struct Depsgraph *depsgraph))
{		{
DEG_OBJECT_ITER_FOR_RENDER_ENGINE(depsgraph, ob, DRW_iterator_mode_get())		DEG_OBJECT_ITER_FOR_RENDER_ENGINE(depsgraph, ob, DRW_iterator_mode_get())
{		{
callback(vedata, ob, engine, depsgraph);		callback(vedata, ob, engine, depsgraph);
}		}
DEG_OBJECT_ITER_FOR_RENDER_ENGINE_END		DEG_OBJECT_ITER_FOR_RENDER_ENGINE_END
}		}

		static struct DRWSelectBuffer {
		struct GPUFrameBuffer *framebuffer;
		struct GPUTexture *texture_depth;
		} g_select_buffer = {NULL};

		static void draw_select_framebuffer_setup(const rcti *rect)
		{
		if (g_select_buffer.framebuffer == NULL) {
		g_select_buffer.framebuffer = GPU_framebuffer_create();
		}

		/* If size mismatch recreate the texture. */
		if ((g_select_buffer.texture_depth != NULL) &&
		((GPU_texture_width(g_select_buffer.texture_depth) != BLI_rcti_size_x(rect)) \|\|
		(GPU_texture_height(g_select_buffer.texture_depth) != BLI_rcti_size_y(rect))))
		{
		GPU_texture_free(g_select_buffer.texture_depth);
		g_select_buffer.texture_depth = NULL;
		}

		if (g_select_buffer.texture_depth == NULL) {
		g_select_buffer.texture_depth = GPU_texture_create_depth(BLI_rcti_size_x(rect), BLI_rcti_size_y(rect), NULL);

		GPU_framebuffer_texture_attach(g_select_buffer.framebuffer, g_select_buffer.texture_depth, 0, 0);

		if (!GPU_framebuffer_check_valid(g_select_buffer.framebuffer, NULL)) {
		printf("Error invalid selection framebuffer\n");
		}
		}
		}

/**		/**
* object mode select-loop, see: ED_view3d_draw_select_loop (legacy drawing).		* object mode select-loop, see: ED_view3d_draw_select_loop (legacy drawing).
*/		*/
void DRW_draw_select_loop(		void DRW_draw_select_loop(
struct Depsgraph *depsgraph,		struct Depsgraph *depsgraph,
ARegion ar, View3D v3d, const eObjectMode object_mode,		ARegion ar, View3D v3d, const eObjectMode object_mode,
bool UNUSED(use_obedit_skip), bool UNUSED(use_nearest), const rcti *rect)		bool UNUSED(use_obedit_skip), bool UNUSED(use_nearest), const rcti *rect)
{		{
Show All 25 Lines	// if (!BDR_drawSketchNames(vc))
use_obedit = true;		use_obedit = true;
obedit_mode = CTX_MODE_EDIT_ARMATURE;		obedit_mode = CTX_MODE_EDIT_ARMATURE;
}		}
}		}

struct GPUViewport *viewport = GPU_viewport_create();		struct GPUViewport *viewport = GPU_viewport_create();
GPU_viewport_size_set(viewport, (const int[2]){BLI_rcti_size_x(rect), BLI_rcti_size_y(rect)});		GPU_viewport_size_set(viewport, (const int[2]){BLI_rcti_size_x(rect), BLI_rcti_size_y(rect)});

bool cache_is_dirty;
DST.viewport = viewport;		DST.viewport = viewport;
v3d->zbuf = true;		v3d->zbuf = true;

		/* Setup framebuffer */
		draw_select_framebuffer_setup(rect);
		GPU_framebuffer_bind(g_select_buffer.framebuffer);

DST.options.is_select = true;		DST.options.is_select = true;

/* Get list of enabled engines */		/* Get list of enabled engines */
if (use_obedit) {		if (use_obedit) {
drw_engines_enable_from_mode(obedit_mode);		drw_engines_enable_from_mode(obedit_mode);
}		}
else {		else {
drw_engines_enable_basic();		drw_engines_enable_basic();
drw_engines_enable_from_object_mode();		drw_engines_enable_from_object_mode();
}		}

/* Setup viewport */		/* Setup viewport */
cache_is_dirty = true;

/* Instead of 'DRW_context_state_init(C, &DST.draw_ctx)', assign from args */		/* Instead of 'DRW_context_state_init(C, &DST.draw_ctx)', assign from args */
DST.draw_ctx = (DRWContextState){		DST.draw_ctx = (DRWContextState){
ar, rv3d, v3d, scene, view_layer, OBACT(view_layer), engine_type, depsgraph, object_mode,		ar, rv3d, v3d, scene, view_layer, OBACT(view_layer), engine_type, depsgraph, object_mode,
(bContext *)NULL,		(bContext *)NULL,
};		};

drw_viewport_var_init();		drw_viewport_var_init();

/* Update ubos */		/* Update ubos */
DRW_globals_update();		DRW_globals_update();

/* Init engines */		/* Init engines */
drw_engines_init();		drw_engines_init();

/* TODO : tag to refresh by the dependency graph */		{
/* ideally only refresh when objects are added/removed */
/* or render properties / materials change */
if (cache_is_dirty) {
drw_engines_cache_init();		drw_engines_cache_init();

if (use_obedit) {		if (use_obedit) {
drw_engines_cache_populate(scene->obedit);		drw_engines_cache_populate(scene->obedit);
}		}
else {		else {
DEG_OBJECT_ITER(depsgraph, ob, DRW_iterator_mode_get(),		DEG_OBJECT_ITER(depsgraph, ob, DRW_iterator_mode_get(),
DEG_ITER_OBJECT_FLAG_LINKED_DIRECTLY \|		DEG_ITER_OBJECT_FLAG_LINKED_DIRECTLY \|
▲ Show 20 Lines • Show All 305 Lines • ▼ Show 20 Lines	/* setup callbacks */
BKE_particle_batch_cache_free_cb = DRW_particle_batch_cache_free;		BKE_particle_batch_cache_free_cb = DRW_particle_batch_cache_free;
}		}
}		}

extern struct GPUUniformBuffer globals_ubo; / draw_common.c */		extern struct GPUUniformBuffer globals_ubo; / draw_common.c */
extern struct GPUTexture globals_ramp; / draw_common.c */		extern struct GPUTexture globals_ramp; / draw_common.c */
void DRW_engines_free(void)		void DRW_engines_free(void)
{		{
		DRW_ogl_ctx_enable();

		DRW_TEXTURE_FREE_SAFE(g_select_buffer.texture_depth);
		DRW_FRAMEBUFFER_FREE_SAFE(g_select_buffer.framebuffer);

DRW_shape_cache_free();		DRW_shape_cache_free();
DRW_stats_free();		DRW_stats_free();

DrawEngineType *next;		DrawEngineType *next;
for (DrawEngineType *type = DRW_engines.first; type; type = next) {		for (DrawEngineType *type = DRW_engines.first; type; type = next) {
next = type->next;		next = type->next;
BLI_remlink(&R_engines, type);		BLI_remlink(&R_engines, type);

if (type->engine_free) {		if (type->engine_free) {
type->engine_free();		type->engine_free();
}		}
}		}

if (globals_ubo)		if (globals_ubo)
GPU_uniformbuffer_free(globals_ubo);		GPU_uniformbuffer_free(globals_ubo);

if (globals_ramp)		if (globals_ramp)
GPU_texture_free(globals_ramp);		GPU_texture_free(globals_ramp);

MEM_SAFE_FREE(RST.bound_texs);		MEM_SAFE_FREE(RST.bound_texs);
MEM_SAFE_FREE(RST.bound_tex_slots);		MEM_SAFE_FREE(RST.bound_tex_slots);

		DRW_ogl_ctx_disable();

#ifdef WITH_CLAY_ENGINE		#ifdef WITH_CLAY_ENGINE
BLI_remlink(&R_engines, &DRW_engine_viewport_clay_type);		BLI_remlink(&R_engines, &DRW_engine_viewport_clay_type);
#endif		#endif
}		}

/** \} */		/** \} */

		/** \name Init/Exit (DRW_opengl_ctx)
		* \{ */

		void DRW_ogl_ctx_create(void)
		brechtUnsubmitted Not Done Inline Actions I would prefer to have the full name `DRW_opengl_context_create()` here for clarity, it's not so long and abbreviations are not always obvious. brecht: I would prefer to have the full name `DRW_opengl_context_create()` here for clarity, it's not…
		{
		BLI_assert(g_ogl_context == NULL); /* Ensure it's called once */

		/* This changes the active context. */
		g_ogl_context = WM_context_create();
		/* So we activate the window's one afterwards. */
		wm_window_reset_drawable();
		}

		void DRW_ogl_ctx_destroy(void)
		{
		if (g_ogl_context != NULL) {
		WM_context_dispose(g_ogl_context);
		}
		}

		void DRW_ogl_ctx_enable(void)
		{
		if (g_ogl_context != NULL) {
		BLI_rw_mutex_lock(&cache_rwlock, THREAD_LOCK_WRITE);
		immDeactivate();
		WM_context_activate(g_ogl_context);
		immActivate();
		}
		}

		void DRW_ogl_ctx_disable(void)
		{
		if (g_ogl_context != NULL) {
		wm_window_reset_drawable();
		BLI_rw_mutex_unlock(&cache_rwlock);
		}
		}

		/** \} */