Differential D2914 Diff 9557 source/blender/draw/intern/draw_cache_impl_metaball.c

Changeset View

Standalone View

source/blender/draw/intern/draw_cache_impl_metaball.c

This file was added.

				/*
				* *** 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) 2017 by Blender Foundation.
				* All rights reserved.
				*
				* *** END GPL LICENSE BLOCK ***
				*/

				/** \file draw_cache_impl_metaball.c
				* \ingroup draw
				*
				* \brief MetaBall API for render engines
				*/

				#include "MEM_guardedalloc.h"

				#include "BLI_utildefines.h"

				#include "DNA_meta_types.h"
				#include "DNA_object_types.h"

				#include "BKE_curve.h"
				#include "BKE_mball.h"

				#include "GPU_batch.h"

				#include "draw_cache_impl.h" /* own include */


				static void metaball_batch_cache_clear(MetaBall *mb);

				/* ---------------------------------------------------------------------- */
				/* MetaBall Interface, indirect, partially cached access to complex data. */

				typedef struct MetaBallRenderData {
				int types;

				/* borrow from 'Object' */
				CurveCache *ob_curve_cache;
				} MetaBallRenderData;

				enum {
				/* Geometry */
				MBALL_DATATYPE_SURFACE = 1 << 0,
				// MBALL_DATATYPE_WIRE = 1 << 1,
				// MBALL_DATATYPE_SHADING = 1 << 2,
				};

				static MetaBallRenderData metaball_render_data_create(MetaBall mb, CurveCache *ob_curve_cache, const int types)
				{
				MetaBallRenderData rdata = MEM_callocN(sizeof(rdata), __func__);
				rdata->types = types;
				rdata->ob_curve_cache = ob_curve_cache;

				/*
				TODO
				if (types & MBALL_DATATYPE_WIRE) {}
				SeverinUnsubmitted Done Inline Actions Dead code :) Severin: Dead code :)
				if (types & MBALL_DATATYPE_SHADING) {}
				*/

				return rdata;
				}

				static void metaball_render_data_free(MetaBallRenderData *rdata)
				{
				MEM_freeN(rdata);
				}

				/* ---------------------------------------------------------------------- */
				/* MetaBall Gwn_Batch Cache */

				typedef struct MetaBallBatchCache {
				Gwn_Batch *batch;

				/* settings to determine if cache is invalid */
				bool is_dirty;
				} MetaBallBatchCache;

				/* Gwn_Batch cache management. */

				static bool metaball_batch_cache_valid(MetaBall *mb)
				{
				MetaBallBatchCache *cache = mb->batch_cache;

				if (cache == NULL) {
				return false;
				}

				return cache->is_dirty == false;
				}

				static void metaball_batch_cache_init(MetaBall *mb)
				{
				MetaBallBatchCache *cache = mb->batch_cache;

				if (!cache) {
				cache = mb->batch_cache = MEM_mallocN(sizeof(*cache), __func__);
				}
				cache->batch = NULL;
				cache->is_dirty = false;
				}
				SeverinUnsubmitted Done Inline Actions Just change the `calloc` above to be a `malloc` and move this out of the `else`. If cache is `NULL`, the `calloc` does the actual initialization right now (`memset` to 0), which is not obvious on first sight. Also makes sense if in future a `MetaBallBatchCache` member is added that should not be initialized to 0. Severin: Just change the `calloc` above to be a `malloc` and move this out of the `else`. If cache is…

				static MetaBallBatchCache metaball_batch_cache_get(MetaBall mb)
				{
				if (!metaball_batch_cache_valid(mb)) {
				metaball_batch_cache_clear(mb);
				metaball_batch_cache_init(mb);
				}
				return mb->batch_cache;
				}

				void DRW_mball_batch_cache_dirty(MetaBall *mb, int mode)
				{
				MetaBallBatchCache *cache = mb->batch_cache;
				if (cache == NULL) {
				return;
				}
				switch (mode) {
				case BKE_MBALL_BATCH_DIRTY_ALL:
				cache->is_dirty = true;
				break;
				default:
				BLI_assert(0);
				}
				}

				static void metaball_batch_cache_clear(MetaBall *mb)
				{
				MetaBallBatchCache *cache = mb->batch_cache;
				if (!cache) {
				return;
				}

				GWN_BATCH_DISCARD_SAFE(cache->batch);
				}

				void DRW_mball_batch_cache_free(MetaBall *mb)
				{
				metaball_batch_cache_clear(mb);
				MEM_SAFE_FREE(mb->batch_cache);
				}

				/* -------------------------------------------------------------------- */

				/** \name Private MetaBall Cache API
				* \{ */

				/* Gwn_Batch cache usage. */

				static Gwn_Batch metaball_batch_cache_get_pos_and_normals(MetaBallRenderData rdata, MetaBallBatchCache *cache)
				{
				BLI_assert(rdata->types & MBALL_DATATYPE_SURFACE);
				if (cache->batch == NULL) {
				cache->batch = BLI_displist_batch_calc_surface(&rdata->ob_curve_cache->disp);
				}
				return cache->batch;
				}

				/** \} */

				/* -------------------------------------------------------------------- */

				/** \name Public Object/MetaBall API
				* \{ */

				Gwn_Batch DRW_metaball_batch_cache_get_triangles_with_normals(Object ob)
				{
				if (!BKE_mball_is_basis(ob))
				return NULL;

				MetaBall *mb = ob->data;
				MetaBallBatchCache *cache = metaball_batch_cache_get(mb);

				if (cache->batch == NULL) {
				MetaBallRenderData *rdata = metaball_render_data_create(mb, ob->curve_cache, MBALL_DATATYPE_SURFACE);
				metaball_batch_cache_get_pos_and_normals(rdata, cache);
				metaball_render_data_free(rdata);
				}

				return cache->batch;
				}