2011-02-23 11:52:22 +01:00
|
|
|
/*
|
2008-01-07 20:13:47 +01:00
|
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
2005-03-27 22:34:18 +02:00
|
|
|
*
|
|
|
|
* 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
|
2008-01-07 20:13:47 +01:00
|
|
|
* of the License, or (at your option) any later version.
|
2005-03-27 22:34:18 +02:00
|
|
|
*
|
|
|
|
* 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,
|
2010-02-12 14:34:04 +01:00
|
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
2005-03-27 22:34:18 +02:00
|
|
|
*
|
2005-03-29 18:43:39 +02:00
|
|
|
* The Original Code is Copyright (C) 2005 Blender Foundation.
|
2005-03-27 22:34:18 +02:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* The Original Code is: all of this file.
|
|
|
|
*
|
|
|
|
* Contributor(s): none yet.
|
|
|
|
*
|
2008-01-07 20:13:47 +01:00
|
|
|
* ***** END GPL LICENSE BLOCK *****
|
2005-03-27 22:34:18 +02:00
|
|
|
*/
|
|
|
|
|
2011-02-27 21:40:57 +01:00
|
|
|
/** \file blender/blenkernel/intern/DerivedMesh.c
|
|
|
|
* \ingroup bke
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
2005-08-23 22:04:10 +02:00
|
|
|
#include <string.h>
|
2012-04-06 07:53:01 +02:00
|
|
|
#include <limits.h>
|
2005-07-23 21:15:08 +02:00
|
|
|
|
2005-03-27 22:34:18 +02:00
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
|
2010-03-30 13:49:07 +02:00
|
|
|
#include "DNA_cloth_types.h"
|
2006-08-28 03:12:36 +02:00
|
|
|
#include "DNA_key_types.h"
|
2014-07-21 12:02:05 +02:00
|
|
|
#include "DNA_material_types.h"
|
2012-02-19 23:17:30 +01:00
|
|
|
#include "DNA_mesh_types.h"
|
2005-03-27 22:34:18 +02:00
|
|
|
#include "DNA_meshdata_types.h"
|
|
|
|
#include "DNA_object_types.h"
|
2014-04-27 18:22:03 +02:00
|
|
|
#include "DNA_scene_types.h"
|
2005-03-27 22:34:18 +02:00
|
|
|
|
Fix T47038: Particles in Particle Edit Mode get added in completely wrong location.
It also fixes another issue (crash) related to symmetric editing.
Quite involved, we (try to!) fix complete broken logic of parts of particle code, which would use poly index
as tessface one (or vice-versa). Issue most probably goes back to BMesh integration time...
This patch mostly fixes particle editing mode:
- Adding/removing particles when using generative modifiers (like subsurf) should now work.
- Adding/removing particles with a non-tessellated mesh (i.e. one having ngons) should also mostly work.
- X-axis-mirror-editing particles over ngons does not really work, not sure why currently.
- All this in both 'modes' (with or without using modifier stack for particles).
Tech side:
- Store a deformed-only DM in particle modifier data.
- Rename existing DM to make it clear it's a final one.
- Use deformed-only DM's tessface2poly mapping to 'solve' poly/tessface mismatches.
- Make (part of) mirror-editing code able to use a DM instead of raw mesh, so that we can mirror based on final DM
when editing particles using modifier stack (mandatory, since there is no way currently to find orig tessface
from an final DM tessface index).
Note that this patch is not really nice and clean (current particles are beyond hope on this side anyway),
it's more like some urgency bandage. Whole crap needs complete rewrite anyway,
BMesh's polygons make it really hard to work with current system (and looptri would not help much here).
Also, did not test everything possibly affected by those changes, so it needs some users' testing & validation too.
Reviewers: psy-fi
Subscribers: dfelinto, eyecandy
Maniphest Tasks: T47038
Differential Revision: https://developer.blender.org/D1685
2016-01-04 12:19:45 +01:00
|
|
|
#include "BLI_array.h"
|
2005-03-27 23:27:12 +02:00
|
|
|
#include "BLI_blenlib.h"
|
2014-09-04 09:53:10 +02:00
|
|
|
#include "BLI_bitmap.h"
|
2010-03-22 12:59:36 +01:00
|
|
|
#include "BLI_math.h"
|
2011-01-07 19:36:47 +01:00
|
|
|
#include "BLI_utildefines.h"
|
2011-10-22 03:53:35 +02:00
|
|
|
#include "BLI_linklist.h"
|
2016-04-26 10:43:02 +02:00
|
|
|
#include "BLI_task.h"
|
2005-03-27 22:34:18 +02:00
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
#include "BKE_cdderivedmesh.h"
|
2017-12-07 05:36:26 +01:00
|
|
|
#include "BKE_colorband.h"
|
2013-04-18 19:09:56 +02:00
|
|
|
#include "BKE_editmesh.h"
|
2007-10-31 14:56:07 +01:00
|
|
|
#include "BKE_key.h"
|
2017-04-18 14:55:31 +02:00
|
|
|
#include "BKE_layer.h"
|
2015-11-09 19:47:10 +01:00
|
|
|
#include "BKE_library.h"
|
2014-04-09 03:03:25 +02:00
|
|
|
#include "BKE_material.h"
|
2007-10-31 14:56:07 +01:00
|
|
|
#include "BKE_modifier.h"
|
2005-03-27 22:34:18 +02:00
|
|
|
#include "BKE_mesh.h"
|
2014-01-21 16:32:36 +01:00
|
|
|
#include "BKE_mesh_mapping.h"
|
2017-05-24 14:33:21 +02:00
|
|
|
#include "BKE_mesh_tangent.h"
|
2005-03-27 22:34:18 +02:00
|
|
|
#include "BKE_object.h"
|
2012-09-05 05:45:32 +02:00
|
|
|
#include "BKE_object_deform.h"
|
2009-08-15 21:48:50 +02:00
|
|
|
#include "BKE_paint.h"
|
2011-01-31 21:02:51 +01:00
|
|
|
#include "BKE_multires.h"
|
2009-05-23 05:24:15 +02:00
|
|
|
#include "BKE_bvhutils.h"
|
2011-12-07 08:13:33 +01:00
|
|
|
#include "BKE_deform.h"
|
Fix [#30234] Various problems with CD layers and tesselation, related to modifiers stack.
Should also fix [#30266], [#29451], and partly [#30316].
Here are the changes made by this commit:
* It adds a "dirty" flag to DerivedMesh struct (for now, only DM_DIRTY_TESS_CDLAYERS, but more might be added as needed).
* It adds a new func, DM_update_tessface_data, which assumes tessfaces themselves are valid, but updates tessellated customdata from their poly/loop counter parts.
* At end of modstack, when valid tessellated faces are present in finaldm , but the cdlayers dirty flag is set, call that function (instead of recomputing the whole tessellation).
* Edits to the codes concerned (UVProject, DynamicPaint, and Subsurf modifiers).
* Also add to subsurf dm generation code the creation of a CD_POLYINDEX layer (mandatory for DM_update_tessface_data to work well, and imho all tessellated dm should have one).
Note: some pieces of old code are just #if 0’ed, will clean them later.
2012-03-18 23:06:57 +01:00
|
|
|
#include "BKE_global.h" /* For debug flag, DM_update_tessface_data() func. */
|
2005-03-27 22:34:18 +02:00
|
|
|
|
2013-05-28 21:35:26 +02:00
|
|
|
#include "BLI_sys_types.h" /* for intptr_t support */
|
2008-08-17 19:08:00 +02:00
|
|
|
|
2018-04-16 20:45:43 +02:00
|
|
|
#include "DEG_depsgraph.h"
|
|
|
|
#include "DEG_depsgraph_query.h"
|
|
|
|
|
2015-08-03 20:35:43 +02:00
|
|
|
#ifdef WITH_OPENSUBDIV
|
|
|
|
# include "DNA_userdef_types.h"
|
|
|
|
#endif
|
|
|
|
|
2013-09-04 03:29:34 +02:00
|
|
|
/* very slow! enable for testing only! */
|
2014-12-02 13:49:40 +01:00
|
|
|
//#define USE_MODIFIER_VALIDATE
|
2013-09-04 03:29:34 +02:00
|
|
|
|
|
|
|
#ifdef USE_MODIFIER_VALIDATE
|
|
|
|
# define ASSERT_IS_VALID_DM(dm) (BLI_assert((dm == NULL) || (DM_is_valid(dm) == true)))
|
2018-05-11 09:53:52 +02:00
|
|
|
# define ASSERT_IS_VALID_MESH(mesh) (BLI_assert((mesh == NULL) || (BKE_mesh_is_valid(mesh) == true)))
|
2013-09-04 03:29:34 +02:00
|
|
|
#else
|
|
|
|
# define ASSERT_IS_VALID_DM(dm)
|
2018-05-11 09:53:52 +02:00
|
|
|
# define ASSERT_IS_VALID_MESH(mesh)
|
2013-09-04 03:29:34 +02:00
|
|
|
#endif
|
|
|
|
|
2017-08-11 16:51:19 +02:00
|
|
|
|
2017-09-19 13:09:35 +02:00
|
|
|
static ThreadRWMutex loops_cache_lock = PTHREAD_RWLOCK_INITIALIZER;
|
2017-08-11 16:51:19 +02:00
|
|
|
|
|
|
|
|
2011-04-15 07:20:18 +02:00
|
|
|
static void add_shapekey_layers(DerivedMesh *dm, Mesh *me, Object *ob);
|
|
|
|
static void shapekey_layers_to_keyblocks(DerivedMesh *dm, Mesh *me, int actshape_uid);
|
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
static void mesh_init_origspace(Mesh *mesh);
|
|
|
|
|
2013-09-04 03:29:34 +02:00
|
|
|
|
|
|
|
/* -------------------------------------------------------------------- */
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
|
2008-09-29 19:08:11 +02:00
|
|
|
static MVert *dm_getVertArray(DerivedMesh *dm)
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
{
|
|
|
|
MVert *mvert = CustomData_get_layer(&dm->vertData, CD_MVERT);
|
|
|
|
|
|
|
|
if (!mvert) {
|
2006-12-12 22:29:09 +01:00
|
|
|
mvert = CustomData_add_layer(&dm->vertData, CD_MVERT, CD_CALLOC, NULL,
|
2012-05-12 21:18:02 +02:00
|
|
|
dm->getNumVerts(dm));
|
2006-12-12 22:29:09 +01:00
|
|
|
CustomData_set_layer_flag(&dm->vertData, CD_MVERT, CD_FLAG_TEMPORARY);
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
dm->copyVertArray(dm, mvert);
|
|
|
|
}
|
|
|
|
|
|
|
|
return mvert;
|
|
|
|
}
|
|
|
|
|
2008-09-29 19:08:11 +02:00
|
|
|
static MEdge *dm_getEdgeArray(DerivedMesh *dm)
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
{
|
|
|
|
MEdge *medge = CustomData_get_layer(&dm->edgeData, CD_MEDGE);
|
|
|
|
|
|
|
|
if (!medge) {
|
2006-12-12 22:29:09 +01:00
|
|
|
medge = CustomData_add_layer(&dm->edgeData, CD_MEDGE, CD_CALLOC, NULL,
|
2012-05-12 21:18:02 +02:00
|
|
|
dm->getNumEdges(dm));
|
2006-12-12 22:29:09 +01:00
|
|
|
CustomData_set_layer_flag(&dm->edgeData, CD_MEDGE, CD_FLAG_TEMPORARY);
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
dm->copyEdgeArray(dm, medge);
|
|
|
|
}
|
|
|
|
|
|
|
|
return medge;
|
|
|
|
}
|
|
|
|
|
2011-11-30 19:03:56 +01:00
|
|
|
static MFace *dm_getTessFaceArray(DerivedMesh *dm)
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
{
|
|
|
|
MFace *mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
|
|
|
|
|
|
|
|
if (!mface) {
|
2012-03-14 15:09:56 +01:00
|
|
|
int numTessFaces = dm->getNumTessFaces(dm);
|
|
|
|
|
|
|
|
if (!numTessFaces) {
|
|
|
|
/* Do not add layer if there's no elements in it, this leads to issues later when
|
|
|
|
* this layer is needed with non-zero size, but currently CD stuff does not check
|
|
|
|
* for requested layer size on creation and just returns layer which was previously
|
|
|
|
* added (sergey) */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
mface = CustomData_add_layer(&dm->faceData, CD_MFACE, CD_CALLOC, NULL, numTessFaces);
|
2006-12-12 22:29:09 +01:00
|
|
|
CustomData_set_layer_flag(&dm->faceData, CD_MFACE, CD_FLAG_TEMPORARY);
|
(NOTE: DO NOT TEST)
Start of planned DerivedMesh refactoring. The mface
interfaces in DerivedMesh have been renamed to reflect
their new status as tesselated face interfaces (rather
then the primary ones, which are now stored in mpolys).
short review: mpolys store "primary" face data, while
mfaces store the tesselated form of the mesh (generally
as triangles). mpolys are defined by mloops, and each
mpoly defines a range of loops it "owns" in the main
mloop array.
I've also added basic read-only face iterators, which
are implemented for CDDM, ccgsubsurf, and the bmeditmesh
derivedmesh. Since faces are now variable-length things,
trying to implement the same interface as mfaces would not
have worked well (especially since faces are stored as
an mpoly + a range of mloops).
I figure first we can evaluate these simple read-only
face iterators, then decide if a) we like using iterators
in DerivedMesh, b) how much of it should use them, and c)
if we want write-capable iterators.
I plan to write official docs on this design after I get
it more stable; I'm committing now because there's a rather
lot of changes, and I might do a merge soon.
2009-06-10 12:06:25 +02:00
|
|
|
dm->copyTessFaceArray(dm, mface);
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return mface;
|
|
|
|
}
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2011-06-14 05:16:08 +02:00
|
|
|
static MLoop *dm_getLoopArray(DerivedMesh *dm)
|
|
|
|
{
|
|
|
|
MLoop *mloop = CustomData_get_layer(&dm->loopData, CD_MLOOP);
|
|
|
|
|
|
|
|
if (!mloop) {
|
|
|
|
mloop = CustomData_add_layer(&dm->loopData, CD_MLOOP, CD_CALLOC, NULL,
|
2012-05-12 21:18:02 +02:00
|
|
|
dm->getNumLoops(dm));
|
2011-06-14 05:16:08 +02:00
|
|
|
CustomData_set_layer_flag(&dm->loopData, CD_MLOOP, CD_FLAG_TEMPORARY);
|
|
|
|
dm->copyLoopArray(dm, mloop);
|
|
|
|
}
|
|
|
|
|
|
|
|
return mloop;
|
|
|
|
}
|
|
|
|
|
|
|
|
static MPoly *dm_getPolyArray(DerivedMesh *dm)
|
|
|
|
{
|
|
|
|
MPoly *mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
|
|
|
|
|
|
|
|
if (!mpoly) {
|
|
|
|
mpoly = CustomData_add_layer(&dm->polyData, CD_MPOLY, CD_CALLOC, NULL,
|
2012-05-12 21:18:02 +02:00
|
|
|
dm->getNumPolys(dm));
|
2011-06-14 05:16:08 +02:00
|
|
|
CustomData_set_layer_flag(&dm->polyData, CD_MPOLY, CD_FLAG_TEMPORARY);
|
|
|
|
dm->copyPolyArray(dm, mpoly);
|
|
|
|
}
|
|
|
|
|
|
|
|
return mpoly;
|
|
|
|
}
|
|
|
|
|
2008-09-29 19:08:11 +02:00
|
|
|
static MVert *dm_dupVertArray(DerivedMesh *dm)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
2018-01-14 22:14:20 +01:00
|
|
|
MVert *tmp = MEM_malloc_arrayN(dm->getNumVerts(dm), sizeof(*tmp),
|
2012-05-12 21:18:02 +02:00
|
|
|
"dm_dupVertArray tmp");
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (tmp) dm->copyVertArray(dm, tmp);
|
2006-08-28 03:12:36 +02:00
|
|
|
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
2008-09-29 19:08:11 +02:00
|
|
|
static MEdge *dm_dupEdgeArray(DerivedMesh *dm)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
2018-01-14 22:14:20 +01:00
|
|
|
MEdge *tmp = MEM_malloc_arrayN(dm->getNumEdges(dm), sizeof(*tmp),
|
2012-05-12 21:18:02 +02:00
|
|
|
"dm_dupEdgeArray tmp");
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (tmp) dm->copyEdgeArray(dm, tmp);
|
2006-08-28 03:12:36 +02:00
|
|
|
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
2008-09-29 19:08:11 +02:00
|
|
|
static MFace *dm_dupFaceArray(DerivedMesh *dm)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
2018-01-14 22:14:20 +01:00
|
|
|
MFace *tmp = MEM_malloc_arrayN(dm->getNumTessFaces(dm), sizeof(*tmp),
|
2012-05-12 21:18:02 +02:00
|
|
|
"dm_dupFaceArray tmp");
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (tmp) dm->copyTessFaceArray(dm, tmp);
|
2006-08-28 03:12:36 +02:00
|
|
|
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
2011-06-14 05:16:08 +02:00
|
|
|
static MLoop *dm_dupLoopArray(DerivedMesh *dm)
|
|
|
|
{
|
2018-01-14 22:14:20 +01:00
|
|
|
MLoop *tmp = MEM_malloc_arrayN(dm->getNumLoops(dm), sizeof(*tmp),
|
2012-05-12 21:18:02 +02:00
|
|
|
"dm_dupLoopArray tmp");
|
2011-06-14 05:16:08 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (tmp) dm->copyLoopArray(dm, tmp);
|
2011-06-14 05:16:08 +02:00
|
|
|
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
static MPoly *dm_dupPolyArray(DerivedMesh *dm)
|
|
|
|
{
|
2018-01-14 22:14:20 +01:00
|
|
|
MPoly *tmp = MEM_malloc_arrayN(dm->getNumPolys(dm), sizeof(*tmp),
|
2012-05-12 21:18:02 +02:00
|
|
|
"dm_dupPolyArray tmp");
|
2011-06-14 05:16:08 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (tmp) dm->copyPolyArray(dm, tmp);
|
2011-06-14 05:16:08 +02:00
|
|
|
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
|
2015-07-16 19:36:03 +02:00
|
|
|
static int dm_getNumLoopTri(DerivedMesh *dm)
|
|
|
|
{
|
2016-11-23 20:19:03 +01:00
|
|
|
const int numlooptris = poly_to_tri_count(dm->getNumPolys(dm), dm->getNumLoops(dm));
|
|
|
|
BLI_assert(ELEM(dm->looptris.num, 0, numlooptris));
|
|
|
|
return numlooptris;
|
2015-07-16 19:36:03 +02:00
|
|
|
}
|
|
|
|
|
2017-08-11 15:41:53 +02:00
|
|
|
static const MLoopTri *dm_getLoopTriArray(DerivedMesh *dm)
|
|
|
|
{
|
2017-09-19 13:09:35 +02:00
|
|
|
MLoopTri *looptri;
|
|
|
|
|
|
|
|
BLI_rw_mutex_lock(&loops_cache_lock, THREAD_LOCK_READ);
|
|
|
|
looptri = dm->looptris.array;
|
|
|
|
BLI_rw_mutex_unlock(&loops_cache_lock);
|
|
|
|
|
|
|
|
if (looptri != NULL) {
|
2017-08-11 16:18:01 +02:00
|
|
|
BLI_assert(dm->getNumLoopTri(dm) == dm->looptris.num);
|
2017-08-11 15:41:53 +02:00
|
|
|
}
|
|
|
|
else {
|
2017-09-19 13:09:35 +02:00
|
|
|
BLI_rw_mutex_lock(&loops_cache_lock, THREAD_LOCK_WRITE);
|
2017-08-11 16:51:19 +02:00
|
|
|
/* We need to ensure array is still NULL inside mutex-protected code, some other thread might have already
|
|
|
|
* recomputed those looptris. */
|
|
|
|
if (dm->looptris.array == NULL) {
|
|
|
|
dm->recalcLoopTri(dm);
|
|
|
|
}
|
2017-09-19 13:09:35 +02:00
|
|
|
looptri = dm->looptris.array;
|
|
|
|
BLI_rw_mutex_unlock(&loops_cache_lock);
|
2017-08-11 15:41:53 +02:00
|
|
|
}
|
2017-09-19 13:09:35 +02:00
|
|
|
return looptri;
|
2017-08-11 15:41:53 +02:00
|
|
|
}
|
|
|
|
|
2011-05-11 04:14:43 +02:00
|
|
|
static CustomData *dm_getVertCData(DerivedMesh *dm)
|
2009-06-23 07:35:49 +02:00
|
|
|
{
|
|
|
|
return &dm->vertData;
|
|
|
|
}
|
|
|
|
|
2011-05-11 04:14:43 +02:00
|
|
|
static CustomData *dm_getEdgeCData(DerivedMesh *dm)
|
2009-06-23 07:35:49 +02:00
|
|
|
{
|
|
|
|
return &dm->edgeData;
|
|
|
|
}
|
|
|
|
|
2011-11-30 19:03:56 +01:00
|
|
|
static CustomData *dm_getTessFaceCData(DerivedMesh *dm)
|
2009-06-23 07:35:49 +02:00
|
|
|
{
|
|
|
|
return &dm->faceData;
|
|
|
|
}
|
|
|
|
|
2011-05-11 04:14:43 +02:00
|
|
|
static CustomData *dm_getLoopCData(DerivedMesh *dm)
|
2009-06-23 07:35:49 +02:00
|
|
|
{
|
|
|
|
return &dm->loopData;
|
|
|
|
}
|
|
|
|
|
2011-05-11 04:14:43 +02:00
|
|
|
static CustomData *dm_getPolyCData(DerivedMesh *dm)
|
2009-06-23 07:35:49 +02:00
|
|
|
{
|
|
|
|
return &dm->polyData;
|
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
/**
|
|
|
|
* Utility function to initialize a DerivedMesh's function pointers to
|
|
|
|
* the default implementation (for those functions which have a default)
|
|
|
|
*/
|
2006-08-28 03:12:36 +02:00
|
|
|
void DM_init_funcs(DerivedMesh *dm)
|
|
|
|
{
|
|
|
|
/* default function implementations */
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
dm->getVertArray = dm_getVertArray;
|
|
|
|
dm->getEdgeArray = dm_getEdgeArray;
|
2011-11-30 19:03:56 +01:00
|
|
|
dm->getTessFaceArray = dm_getTessFaceArray;
|
2011-06-14 05:16:08 +02:00
|
|
|
dm->getLoopArray = dm_getLoopArray;
|
|
|
|
dm->getPolyArray = dm_getPolyArray;
|
2006-08-28 03:12:36 +02:00
|
|
|
dm->dupVertArray = dm_dupVertArray;
|
|
|
|
dm->dupEdgeArray = dm_dupEdgeArray;
|
(NOTE: DO NOT TEST)
Start of planned DerivedMesh refactoring. The mface
interfaces in DerivedMesh have been renamed to reflect
their new status as tesselated face interfaces (rather
then the primary ones, which are now stored in mpolys).
short review: mpolys store "primary" face data, while
mfaces store the tesselated form of the mesh (generally
as triangles). mpolys are defined by mloops, and each
mpoly defines a range of loops it "owns" in the main
mloop array.
I've also added basic read-only face iterators, which
are implemented for CDDM, ccgsubsurf, and the bmeditmesh
derivedmesh. Since faces are now variable-length things,
trying to implement the same interface as mfaces would not
have worked well (especially since faces are stored as
an mpoly + a range of mloops).
I figure first we can evaluate these simple read-only
face iterators, then decide if a) we like using iterators
in DerivedMesh, b) how much of it should use them, and c)
if we want write-capable iterators.
I plan to write official docs on this design after I get
it more stable; I'm committing now because there's a rather
lot of changes, and I might do a merge soon.
2009-06-10 12:06:25 +02:00
|
|
|
dm->dupTessFaceArray = dm_dupFaceArray;
|
2011-06-14 05:16:08 +02:00
|
|
|
dm->dupLoopArray = dm_dupLoopArray;
|
|
|
|
dm->dupPolyArray = dm_dupPolyArray;
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2017-08-11 15:41:53 +02:00
|
|
|
dm->getLoopTriArray = dm_getLoopTriArray;
|
|
|
|
|
2015-07-16 19:36:03 +02:00
|
|
|
/* subtypes handle getting actual data */
|
|
|
|
dm->getNumLoopTri = dm_getNumLoopTri;
|
|
|
|
|
2009-06-23 07:35:49 +02:00
|
|
|
dm->getVertDataLayout = dm_getVertCData;
|
|
|
|
dm->getEdgeDataLayout = dm_getEdgeCData;
|
2011-11-30 19:03:56 +01:00
|
|
|
dm->getTessFaceDataLayout = dm_getTessFaceCData;
|
2009-06-23 07:35:49 +02:00
|
|
|
dm->getLoopDataLayout = dm_getLoopCData;
|
2011-11-29 14:01:51 +01:00
|
|
|
dm->getPolyDataLayout = dm_getPolyCData;
|
2009-06-23 07:35:49 +02:00
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
dm->getVertData = DM_get_vert_data;
|
|
|
|
dm->getEdgeData = DM_get_edge_data;
|
2011-11-29 06:09:54 +01:00
|
|
|
dm->getTessFaceData = DM_get_tessface_data;
|
2012-10-30 20:20:17 +01:00
|
|
|
dm->getPolyData = DM_get_poly_data;
|
2006-08-28 03:12:36 +02:00
|
|
|
dm->getVertDataArray = DM_get_vert_data_layer;
|
|
|
|
dm->getEdgeDataArray = DM_get_edge_data_layer;
|
2009-08-15 19:31:28 +02:00
|
|
|
dm->getTessFaceDataArray = DM_get_tessface_data_layer;
|
2012-10-30 20:20:17 +01:00
|
|
|
dm->getPolyDataArray = DM_get_poly_data_layer;
|
2013-04-03 22:10:08 +02:00
|
|
|
dm->getLoopDataArray = DM_get_loop_data_layer;
|
2009-05-23 05:24:15 +02:00
|
|
|
|
2018-05-09 01:00:51 +02:00
|
|
|
dm->bvhCache = NULL;
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
/**
|
|
|
|
* Utility function to initialize a DerivedMesh for the desired number
|
|
|
|
* of vertices, edges and faces (doesn't allocate memory for them, just
|
|
|
|
* sets up the custom data layers)
|
|
|
|
*/
|
|
|
|
void DM_init(
|
|
|
|
DerivedMesh *dm, DerivedMeshType type, int numVerts, int numEdges,
|
|
|
|
int numTessFaces, int numLoops, int numPolys)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
2010-01-06 13:05:46 +01:00
|
|
|
dm->type = type;
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
dm->numVertData = numVerts;
|
|
|
|
dm->numEdgeData = numEdges;
|
2011-11-30 19:03:56 +01:00
|
|
|
dm->numTessFaceData = numTessFaces;
|
(NOTE: DO NOT TEST)
Start of planned DerivedMesh refactoring. The mface
interfaces in DerivedMesh have been renamed to reflect
their new status as tesselated face interfaces (rather
then the primary ones, which are now stored in mpolys).
short review: mpolys store "primary" face data, while
mfaces store the tesselated form of the mesh (generally
as triangles). mpolys are defined by mloops, and each
mpoly defines a range of loops it "owns" in the main
mloop array.
I've also added basic read-only face iterators, which
are implemented for CDDM, ccgsubsurf, and the bmeditmesh
derivedmesh. Since faces are now variable-length things,
trying to implement the same interface as mfaces would not
have worked well (especially since faces are stored as
an mpoly + a range of mloops).
I figure first we can evaluate these simple read-only
face iterators, then decide if a) we like using iterators
in DerivedMesh, b) how much of it should use them, and c)
if we want write-capable iterators.
I plan to write official docs on this design after I get
it more stable; I'm committing now because there's a rather
lot of changes, and I might do a merge soon.
2009-06-10 12:06:25 +02:00
|
|
|
dm->numLoopData = numLoops;
|
2011-11-30 19:03:56 +01:00
|
|
|
dm->numPolyData = numPolys;
|
2006-08-28 03:12:36 +02:00
|
|
|
|
|
|
|
DM_init_funcs(dm);
|
2018-04-05 18:20:27 +02:00
|
|
|
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
dm->needsFree = 1;
|
Fix [#30234] Various problems with CD layers and tesselation, related to modifiers stack.
Should also fix [#30266], [#29451], and partly [#30316].
Here are the changes made by this commit:
* It adds a "dirty" flag to DerivedMesh struct (for now, only DM_DIRTY_TESS_CDLAYERS, but more might be added as needed).
* It adds a new func, DM_update_tessface_data, which assumes tessfaces themselves are valid, but updates tessellated customdata from their poly/loop counter parts.
* At end of modstack, when valid tessellated faces are present in finaldm , but the cdlayers dirty flag is set, call that function (instead of recomputing the whole tessellation).
* Edits to the codes concerned (UVProject, DynamicPaint, and Subsurf modifiers).
* Also add to subsurf dm generation code the creation of a CD_POLYINDEX layer (mandatory for DM_update_tessface_data to work well, and imho all tessellated dm should have one).
Note: some pieces of old code are just #if 0’ed, will clean them later.
2012-03-18 23:06:57 +01:00
|
|
|
dm->dirty = 0;
|
2012-10-31 10:50:24 +01:00
|
|
|
|
|
|
|
/* don't use CustomData_reset(...); because we dont want to touch customdata */
|
2015-05-05 09:08:29 +02:00
|
|
|
copy_vn_i(dm->vertData.typemap, CD_NUMTYPES, -1);
|
|
|
|
copy_vn_i(dm->edgeData.typemap, CD_NUMTYPES, -1);
|
|
|
|
copy_vn_i(dm->faceData.typemap, CD_NUMTYPES, -1);
|
|
|
|
copy_vn_i(dm->loopData.typemap, CD_NUMTYPES, -1);
|
|
|
|
copy_vn_i(dm->polyData.typemap, CD_NUMTYPES, -1);
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
/**
|
|
|
|
* Utility function to initialize a DerivedMesh for the desired number
|
|
|
|
* of vertices, edges and faces, with a layer setup copied from source
|
|
|
|
*/
|
2015-09-23 14:57:00 +02:00
|
|
|
void DM_from_template_ex(
|
2015-07-02 08:20:22 +02:00
|
|
|
DerivedMesh *dm, DerivedMesh *source, DerivedMeshType type,
|
|
|
|
int numVerts, int numEdges, int numTessFaces,
|
2015-09-23 14:57:00 +02:00
|
|
|
int numLoops, int numPolys,
|
|
|
|
CustomDataMask mask)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
2015-09-23 14:57:00 +02:00
|
|
|
CustomData_copy(&source->vertData, &dm->vertData, mask, CD_CALLOC, numVerts);
|
|
|
|
CustomData_copy(&source->edgeData, &dm->edgeData, mask, CD_CALLOC, numEdges);
|
|
|
|
CustomData_copy(&source->faceData, &dm->faceData, mask, CD_CALLOC, numTessFaces);
|
|
|
|
CustomData_copy(&source->loopData, &dm->loopData, mask, CD_CALLOC, numLoops);
|
|
|
|
CustomData_copy(&source->polyData, &dm->polyData, mask, CD_CALLOC, numPolys);
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
|
2013-01-10 05:43:31 +01:00
|
|
|
dm->cd_flag = source->cd_flag;
|
|
|
|
|
2010-01-06 13:05:46 +01:00
|
|
|
dm->type = type;
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
dm->numVertData = numVerts;
|
|
|
|
dm->numEdgeData = numEdges;
|
2011-11-30 19:03:56 +01:00
|
|
|
dm->numTessFaceData = numTessFaces;
|
(NOTE: DO NOT TEST)
Start of planned DerivedMesh refactoring. The mface
interfaces in DerivedMesh have been renamed to reflect
their new status as tesselated face interfaces (rather
then the primary ones, which are now stored in mpolys).
short review: mpolys store "primary" face data, while
mfaces store the tesselated form of the mesh (generally
as triangles). mpolys are defined by mloops, and each
mpoly defines a range of loops it "owns" in the main
mloop array.
I've also added basic read-only face iterators, which
are implemented for CDDM, ccgsubsurf, and the bmeditmesh
derivedmesh. Since faces are now variable-length things,
trying to implement the same interface as mfaces would not
have worked well (especially since faces are stored as
an mpoly + a range of mloops).
I figure first we can evaluate these simple read-only
face iterators, then decide if a) we like using iterators
in DerivedMesh, b) how much of it should use them, and c)
if we want write-capable iterators.
I plan to write official docs on this design after I get
it more stable; I'm committing now because there's a rather
lot of changes, and I might do a merge soon.
2009-06-10 12:06:25 +02:00
|
|
|
dm->numLoopData = numLoops;
|
|
|
|
dm->numPolyData = numPolys;
|
2006-08-28 03:12:36 +02:00
|
|
|
|
|
|
|
DM_init_funcs(dm);
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
|
|
|
|
dm->needsFree = 1;
|
Fix [#30234] Various problems with CD layers and tesselation, related to modifiers stack.
Should also fix [#30266], [#29451], and partly [#30316].
Here are the changes made by this commit:
* It adds a "dirty" flag to DerivedMesh struct (for now, only DM_DIRTY_TESS_CDLAYERS, but more might be added as needed).
* It adds a new func, DM_update_tessface_data, which assumes tessfaces themselves are valid, but updates tessellated customdata from their poly/loop counter parts.
* At end of modstack, when valid tessellated faces are present in finaldm , but the cdlayers dirty flag is set, call that function (instead of recomputing the whole tessellation).
* Edits to the codes concerned (UVProject, DynamicPaint, and Subsurf modifiers).
* Also add to subsurf dm generation code the creation of a CD_POLYINDEX layer (mandatory for DM_update_tessface_data to work well, and imho all tessellated dm should have one).
Note: some pieces of old code are just #if 0’ed, will clean them later.
2012-03-18 23:06:57 +01:00
|
|
|
dm->dirty = 0;
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
2015-09-23 14:57:00 +02:00
|
|
|
void DM_from_template(
|
|
|
|
DerivedMesh *dm, DerivedMesh *source, DerivedMeshType type,
|
|
|
|
int numVerts, int numEdges, int numTessFaces,
|
|
|
|
int numLoops, int numPolys)
|
|
|
|
{
|
|
|
|
DM_from_template_ex(
|
|
|
|
dm, source, type,
|
|
|
|
numVerts, numEdges, numTessFaces,
|
|
|
|
numLoops, numPolys,
|
|
|
|
CD_MASK_DERIVEDMESH);
|
|
|
|
}
|
2006-08-28 03:12:36 +02:00
|
|
|
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
int DM_release(DerivedMesh *dm)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
if (dm->needsFree) {
|
2009-05-23 05:24:15 +02:00
|
|
|
bvhcache_free(&dm->bvhCache);
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
CustomData_free(&dm->vertData, dm->numVertData);
|
|
|
|
CustomData_free(&dm->edgeData, dm->numEdgeData);
|
2011-11-30 19:03:56 +01:00
|
|
|
CustomData_free(&dm->faceData, dm->numTessFaceData);
|
(NOTE: DO NOT TEST)
Start of planned DerivedMesh refactoring. The mface
interfaces in DerivedMesh have been renamed to reflect
their new status as tesselated face interfaces (rather
then the primary ones, which are now stored in mpolys).
short review: mpolys store "primary" face data, while
mfaces store the tesselated form of the mesh (generally
as triangles). mpolys are defined by mloops, and each
mpoly defines a range of loops it "owns" in the main
mloop array.
I've also added basic read-only face iterators, which
are implemented for CDDM, ccgsubsurf, and the bmeditmesh
derivedmesh. Since faces are now variable-length things,
trying to implement the same interface as mfaces would not
have worked well (especially since faces are stored as
an mpoly + a range of mloops).
I figure first we can evaluate these simple read-only
face iterators, then decide if a) we like using iterators
in DerivedMesh, b) how much of it should use them, and c)
if we want write-capable iterators.
I plan to write official docs on this design after I get
it more stable; I'm committing now because there's a rather
lot of changes, and I might do a merge soon.
2009-06-10 12:06:25 +02:00
|
|
|
CustomData_free(&dm->loopData, dm->numLoopData);
|
|
|
|
CustomData_free(&dm->polyData, dm->numPolyData);
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
|
2014-04-09 17:37:54 +02:00
|
|
|
if (dm->mat) {
|
|
|
|
MEM_freeN(dm->mat);
|
|
|
|
dm->mat = NULL;
|
|
|
|
dm->totmat = 0;
|
|
|
|
}
|
|
|
|
|
2015-07-16 19:36:03 +02:00
|
|
|
MEM_SAFE_FREE(dm->looptris.array);
|
|
|
|
dm->looptris.num = 0;
|
|
|
|
dm->looptris.num_alloc = 0;
|
|
|
|
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
CustomData_free_temporary(&dm->vertData, dm->numVertData);
|
|
|
|
CustomData_free_temporary(&dm->edgeData, dm->numEdgeData);
|
2011-11-30 19:03:56 +01:00
|
|
|
CustomData_free_temporary(&dm->faceData, dm->numTessFaceData);
|
2009-06-16 22:08:40 +02:00
|
|
|
CustomData_free_temporary(&dm->loopData, dm->numLoopData);
|
|
|
|
CustomData_free_temporary(&dm->polyData, dm->numPolyData);
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
|
|
|
|
2011-06-14 05:16:08 +02:00
|
|
|
void DM_DupPolys(DerivedMesh *source, DerivedMesh *target)
|
(NOTE: DO NOT TEST)
Start of planned DerivedMesh refactoring. The mface
interfaces in DerivedMesh have been renamed to reflect
their new status as tesselated face interfaces (rather
then the primary ones, which are now stored in mpolys).
short review: mpolys store "primary" face data, while
mfaces store the tesselated form of the mesh (generally
as triangles). mpolys are defined by mloops, and each
mpoly defines a range of loops it "owns" in the main
mloop array.
I've also added basic read-only face iterators, which
are implemented for CDDM, ccgsubsurf, and the bmeditmesh
derivedmesh. Since faces are now variable-length things,
trying to implement the same interface as mfaces would not
have worked well (especially since faces are stored as
an mpoly + a range of mloops).
I figure first we can evaluate these simple read-only
face iterators, then decide if a) we like using iterators
in DerivedMesh, b) how much of it should use them, and c)
if we want write-capable iterators.
I plan to write official docs on this design after I get
it more stable; I'm committing now because there's a rather
lot of changes, and I might do a merge soon.
2009-06-10 12:06:25 +02:00
|
|
|
{
|
2011-10-27 14:17:02 +02:00
|
|
|
CustomData_free(&target->loopData, source->numLoopData);
|
|
|
|
CustomData_free(&target->polyData, source->numPolyData);
|
|
|
|
|
|
|
|
CustomData_copy(&source->loopData, &target->loopData, CD_MASK_DERIVEDMESH, CD_DUPLICATE, source->numLoopData);
|
|
|
|
CustomData_copy(&source->polyData, &target->polyData, CD_MASK_DERIVEDMESH, CD_DUPLICATE, source->numPolyData);
|
2009-08-18 22:05:08 +02:00
|
|
|
|
2011-06-14 05:16:08 +02:00
|
|
|
target->numLoopData = source->numLoopData;
|
|
|
|
target->numPolyData = source->numPolyData;
|
2009-08-18 22:05:08 +02:00
|
|
|
|
2011-06-14 05:16:08 +02:00
|
|
|
if (!CustomData_has_layer(&target->polyData, CD_MPOLY)) {
|
|
|
|
MPoly *mpoly;
|
|
|
|
MLoop *mloop;
|
2009-08-18 22:05:08 +02:00
|
|
|
|
2011-06-14 05:16:08 +02:00
|
|
|
mloop = source->dupLoopArray(source);
|
|
|
|
mpoly = source->dupPolyArray(source);
|
|
|
|
CustomData_add_layer(&target->loopData, CD_MLOOP, CD_ASSIGN, mloop, source->numLoopData);
|
|
|
|
CustomData_add_layer(&target->polyData, CD_MPOLY, CD_ASSIGN, mpoly, source->numPolyData);
|
(NOTE: DO NOT TEST)
Start of planned DerivedMesh refactoring. The mface
interfaces in DerivedMesh have been renamed to reflect
their new status as tesselated face interfaces (rather
then the primary ones, which are now stored in mpolys).
short review: mpolys store "primary" face data, while
mfaces store the tesselated form of the mesh (generally
as triangles). mpolys are defined by mloops, and each
mpoly defines a range of loops it "owns" in the main
mloop array.
I've also added basic read-only face iterators, which
are implemented for CDDM, ccgsubsurf, and the bmeditmesh
derivedmesh. Since faces are now variable-length things,
trying to implement the same interface as mfaces would not
have worked well (especially since faces are stored as
an mpoly + a range of mloops).
I figure first we can evaluate these simple read-only
face iterators, then decide if a) we like using iterators
in DerivedMesh, b) how much of it should use them, and c)
if we want write-capable iterators.
I plan to write official docs on this design after I get
it more stable; I'm committing now because there's a rather
lot of changes, and I might do a merge soon.
2009-06-10 12:06:25 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-30 19:36:43 +02:00
|
|
|
void DM_ensure_normals(DerivedMesh *dm)
|
|
|
|
{
|
|
|
|
if (dm->dirty & DM_DIRTY_NORMALS) {
|
|
|
|
dm->calcNormals(dm);
|
|
|
|
}
|
|
|
|
BLI_assert((dm->dirty & DM_DIRTY_NORMALS) == 0);
|
|
|
|
}
|
|
|
|
|
2015-01-19 14:11:40 +01:00
|
|
|
static void DM_calc_loop_normals(DerivedMesh *dm, const bool use_split_normals, float split_angle)
|
2014-04-13 12:18:51 +02:00
|
|
|
{
|
2015-01-19 14:11:40 +01:00
|
|
|
dm->calcLoopNormals(dm, use_split_normals, split_angle);
|
2014-04-21 17:56:05 +02:00
|
|
|
dm->dirty |= DM_DIRTY_TESS_CDLAYERS;
|
2014-04-13 12:18:51 +02:00
|
|
|
}
|
|
|
|
|
2012-01-05 13:40:09 +01:00
|
|
|
/* note: until all modifiers can take MPoly's as input,
|
|
|
|
* use this at the start of modifiers */
|
|
|
|
void DM_ensure_tessface(DerivedMesh *dm)
|
|
|
|
{
|
|
|
|
const int numTessFaces = dm->getNumTessFaces(dm);
|
|
|
|
const int numPolys = dm->getNumPolys(dm);
|
|
|
|
|
2012-04-29 19:11:40 +02:00
|
|
|
if ((numTessFaces == 0) && (numPolys != 0)) {
|
2012-03-02 17:05:54 +01:00
|
|
|
dm->recalcTessellation(dm);
|
2012-01-05 13:40:09 +01:00
|
|
|
|
2012-01-20 00:34:53 +01:00
|
|
|
if (dm->getNumTessFaces(dm) != 0) {
|
|
|
|
/* printf("info %s: polys -> ngons calculated\n", __func__); */
|
2012-01-05 13:40:09 +01:00
|
|
|
}
|
|
|
|
else {
|
2015-06-19 12:29:06 +02:00
|
|
|
printf("warning %s: could not create tessfaces from %d polygons, dm->type=%u\n",
|
2012-01-20 00:34:53 +01:00
|
|
|
__func__, numPolys, dm->type);
|
2012-01-05 13:40:09 +01:00
|
|
|
}
|
|
|
|
}
|
2012-04-01 17:02:19 +02:00
|
|
|
|
2012-09-15 08:30:40 +02:00
|
|
|
else if (dm->dirty & DM_DIRTY_TESS_CDLAYERS) {
|
2012-12-06 09:10:24 +01:00
|
|
|
BLI_assert(CustomData_has_layer(&dm->faceData, CD_ORIGINDEX) || numTessFaces == 0);
|
2012-04-01 17:02:19 +02:00
|
|
|
DM_update_tessface_data(dm);
|
|
|
|
}
|
|
|
|
|
|
|
|
dm->dirty &= ~DM_DIRTY_TESS_CDLAYERS;
|
2012-01-05 13:40:09 +01:00
|
|
|
}
|
|
|
|
|
2015-07-16 19:36:03 +02:00
|
|
|
/**
|
|
|
|
* Ensure the array is large enough
|
2017-09-19 13:57:46 +02:00
|
|
|
*
|
|
|
|
* /note This function must always be thread-protected by caller. It should only be used by internal code.
|
2015-07-16 19:36:03 +02:00
|
|
|
*/
|
|
|
|
void DM_ensure_looptri_data(DerivedMesh *dm)
|
|
|
|
{
|
|
|
|
const unsigned int totpoly = dm->numPolyData;
|
|
|
|
const unsigned int totloop = dm->numLoopData;
|
|
|
|
const int looptris_num = poly_to_tri_count(totpoly, totloop);
|
|
|
|
|
2017-09-19 13:57:46 +02:00
|
|
|
BLI_assert(dm->looptris.array_wip == NULL);
|
|
|
|
|
|
|
|
SWAP(MLoopTri *, dm->looptris.array, dm->looptris.array_wip);
|
|
|
|
|
2015-07-16 19:36:03 +02:00
|
|
|
if ((looptris_num > dm->looptris.num_alloc) ||
|
|
|
|
(looptris_num < dm->looptris.num_alloc * 2) ||
|
|
|
|
(totpoly == 0))
|
|
|
|
{
|
2017-09-19 13:57:46 +02:00
|
|
|
MEM_SAFE_FREE(dm->looptris.array_wip);
|
2015-07-16 19:36:03 +02:00
|
|
|
dm->looptris.num_alloc = 0;
|
|
|
|
dm->looptris.num = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (totpoly) {
|
2017-09-19 13:57:46 +02:00
|
|
|
if (dm->looptris.array_wip == NULL) {
|
2018-01-14 22:14:20 +01:00
|
|
|
dm->looptris.array_wip = MEM_malloc_arrayN(looptris_num, sizeof(*dm->looptris.array_wip), __func__);
|
2015-07-16 19:36:03 +02:00
|
|
|
dm->looptris.num_alloc = looptris_num;
|
|
|
|
}
|
|
|
|
|
|
|
|
dm->looptris.num = looptris_num;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-31 06:00:07 +02:00
|
|
|
void DM_verttri_from_looptri(MVertTri *verttri, const MLoop *mloop, const MLoopTri *looptri, int looptri_num)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < looptri_num; i++) {
|
|
|
|
verttri[i].tri[0] = mloop[looptri[i].tri[0]].v;
|
|
|
|
verttri[i].tri[1] = mloop[looptri[i].tri[1]].v;
|
|
|
|
verttri[i].tri[2] = mloop[looptri[i].tri[2]].v;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-20 23:56:26 +01:00
|
|
|
/* Update tessface CD data from loop/poly ones. Needed when not retessellating after modstack evaluation. */
|
|
|
|
/* NOTE: Assumes dm has valid tessellated data! */
|
Fix [#30234] Various problems with CD layers and tesselation, related to modifiers stack.
Should also fix [#30266], [#29451], and partly [#30316].
Here are the changes made by this commit:
* It adds a "dirty" flag to DerivedMesh struct (for now, only DM_DIRTY_TESS_CDLAYERS, but more might be added as needed).
* It adds a new func, DM_update_tessface_data, which assumes tessfaces themselves are valid, but updates tessellated customdata from their poly/loop counter parts.
* At end of modstack, when valid tessellated faces are present in finaldm , but the cdlayers dirty flag is set, call that function (instead of recomputing the whole tessellation).
* Edits to the codes concerned (UVProject, DynamicPaint, and Subsurf modifiers).
* Also add to subsurf dm generation code the creation of a CD_POLYINDEX layer (mandatory for DM_update_tessface_data to work well, and imho all tessellated dm should have one).
Note: some pieces of old code are just #if 0’ed, will clean them later.
2012-03-18 23:06:57 +01:00
|
|
|
void DM_update_tessface_data(DerivedMesh *dm)
|
|
|
|
{
|
2014-01-22 19:49:14 +01:00
|
|
|
MFace *mf, *mface = dm->getTessFaceArray(dm);
|
Fix [#30234] Various problems with CD layers and tesselation, related to modifiers stack.
Should also fix [#30266], [#29451], and partly [#30316].
Here are the changes made by this commit:
* It adds a "dirty" flag to DerivedMesh struct (for now, only DM_DIRTY_TESS_CDLAYERS, but more might be added as needed).
* It adds a new func, DM_update_tessface_data, which assumes tessfaces themselves are valid, but updates tessellated customdata from their poly/loop counter parts.
* At end of modstack, when valid tessellated faces are present in finaldm , but the cdlayers dirty flag is set, call that function (instead of recomputing the whole tessellation).
* Edits to the codes concerned (UVProject, DynamicPaint, and Subsurf modifiers).
* Also add to subsurf dm generation code the creation of a CD_POLYINDEX layer (mandatory for DM_update_tessface_data to work well, and imho all tessellated dm should have one).
Note: some pieces of old code are just #if 0’ed, will clean them later.
2012-03-18 23:06:57 +01:00
|
|
|
MPoly *mp = dm->getPolyArray(dm);
|
|
|
|
MLoop *ml = dm->getLoopArray(dm);
|
|
|
|
|
|
|
|
CustomData *fdata = dm->getTessFaceDataLayout(dm);
|
|
|
|
CustomData *ldata = dm->getLoopDataLayout(dm);
|
|
|
|
|
2013-09-09 05:12:23 +02:00
|
|
|
const int totface = dm->getNumTessFaces(dm);
|
|
|
|
int mf_idx;
|
2014-01-21 16:32:36 +01:00
|
|
|
|
|
|
|
int *polyindex = CustomData_get_layer(fdata, CD_ORIGINDEX);
|
|
|
|
unsigned int (*loopindex)[4];
|
Fix [#30234] Various problems with CD layers and tesselation, related to modifiers stack.
Should also fix [#30266], [#29451], and partly [#30316].
Here are the changes made by this commit:
* It adds a "dirty" flag to DerivedMesh struct (for now, only DM_DIRTY_TESS_CDLAYERS, but more might be added as needed).
* It adds a new func, DM_update_tessface_data, which assumes tessfaces themselves are valid, but updates tessellated customdata from their poly/loop counter parts.
* At end of modstack, when valid tessellated faces are present in finaldm , but the cdlayers dirty flag is set, call that function (instead of recomputing the whole tessellation).
* Edits to the codes concerned (UVProject, DynamicPaint, and Subsurf modifiers).
* Also add to subsurf dm generation code the creation of a CD_POLYINDEX layer (mandatory for DM_update_tessface_data to work well, and imho all tessellated dm should have one).
Note: some pieces of old code are just #if 0’ed, will clean them later.
2012-03-18 23:06:57 +01:00
|
|
|
|
|
|
|
/* Should never occure, but better abort than segfault! */
|
|
|
|
if (!polyindex)
|
|
|
|
return;
|
|
|
|
|
2017-05-25 07:11:00 +02:00
|
|
|
CustomData_from_bmeshpoly(fdata, ldata, totface);
|
Fix [#30234] Various problems with CD layers and tesselation, related to modifiers stack.
Should also fix [#30266], [#29451], and partly [#30316].
Here are the changes made by this commit:
* It adds a "dirty" flag to DerivedMesh struct (for now, only DM_DIRTY_TESS_CDLAYERS, but more might be added as needed).
* It adds a new func, DM_update_tessface_data, which assumes tessfaces themselves are valid, but updates tessellated customdata from their poly/loop counter parts.
* At end of modstack, when valid tessellated faces are present in finaldm , but the cdlayers dirty flag is set, call that function (instead of recomputing the whole tessellation).
* Edits to the codes concerned (UVProject, DynamicPaint, and Subsurf modifiers).
* Also add to subsurf dm generation code the creation of a CD_POLYINDEX layer (mandatory for DM_update_tessface_data to work well, and imho all tessellated dm should have one).
Note: some pieces of old code are just #if 0’ed, will clean them later.
2012-03-18 23:06:57 +01:00
|
|
|
|
2014-01-21 16:32:36 +01:00
|
|
|
if (CustomData_has_layer(fdata, CD_MTFACE) ||
|
|
|
|
CustomData_has_layer(fdata, CD_MCOL) ||
|
|
|
|
CustomData_has_layer(fdata, CD_PREVIEW_MCOL) ||
|
2014-04-13 12:18:51 +02:00
|
|
|
CustomData_has_layer(fdata, CD_ORIGSPACE) ||
|
2015-07-30 14:43:58 +02:00
|
|
|
CustomData_has_layer(fdata, CD_TESSLOOPNORMAL) ||
|
|
|
|
CustomData_has_layer(fdata, CD_TANGENT))
|
2014-01-21 16:32:36 +01:00
|
|
|
{
|
2018-01-14 22:14:20 +01:00
|
|
|
loopindex = MEM_malloc_arrayN(totface, sizeof(*loopindex), __func__);
|
2014-01-21 16:32:36 +01:00
|
|
|
|
2014-01-22 19:49:14 +01:00
|
|
|
for (mf_idx = 0, mf = mface; mf_idx < totface; mf_idx++, mf++) {
|
2014-01-21 16:32:36 +01:00
|
|
|
const int mf_len = mf->v4 ? 4 : 3;
|
|
|
|
unsigned int *ml_idx = loopindex[mf_idx];
|
|
|
|
int i, not_done;
|
|
|
|
|
|
|
|
/* Find out loop indices. */
|
|
|
|
/* NOTE: This assumes tessface are valid and in sync with loop/poly... Else, most likely, segfault! */
|
|
|
|
for (i = mp[polyindex[mf_idx]].loopstart, not_done = mf_len; not_done; i++) {
|
|
|
|
const int tf_v = BKE_MESH_TESSFACE_VINDEX_ORDER(mf, ml[i].v);
|
|
|
|
if (tf_v != -1) {
|
|
|
|
ml_idx[tf_v] = i;
|
|
|
|
not_done--;
|
|
|
|
}
|
Fix [#30234] Various problems with CD layers and tesselation, related to modifiers stack.
Should also fix [#30266], [#29451], and partly [#30316].
Here are the changes made by this commit:
* It adds a "dirty" flag to DerivedMesh struct (for now, only DM_DIRTY_TESS_CDLAYERS, but more might be added as needed).
* It adds a new func, DM_update_tessface_data, which assumes tessfaces themselves are valid, but updates tessellated customdata from their poly/loop counter parts.
* At end of modstack, when valid tessellated faces are present in finaldm , but the cdlayers dirty flag is set, call that function (instead of recomputing the whole tessellation).
* Edits to the codes concerned (UVProject, DynamicPaint, and Subsurf modifiers).
* Also add to subsurf dm generation code the creation of a CD_POLYINDEX layer (mandatory for DM_update_tessface_data to work well, and imho all tessellated dm should have one).
Note: some pieces of old code are just #if 0’ed, will clean them later.
2012-03-18 23:06:57 +01:00
|
|
|
}
|
|
|
|
}
|
2014-01-21 16:32:36 +01:00
|
|
|
|
2016-01-28 06:30:50 +01:00
|
|
|
/* NOTE: quad detection issue - fourth vertidx vs fourth loopidx:
|
|
|
|
* Here, our tfaces' fourth vertex index is never 0 for a quad. However, we know our fourth loop index may be
|
2014-01-22 19:49:14 +01:00
|
|
|
* 0 for quads (because our quads may have been rotated compared to their org poly, see tessellation code).
|
|
|
|
* So we pass the MFace's, and BKE_mesh_loops_to_tessdata will use MFace->v4 index as quad test.
|
|
|
|
*/
|
2017-05-25 07:11:00 +02:00
|
|
|
BKE_mesh_loops_to_tessdata(fdata, ldata, mface, polyindex, loopindex, totface);
|
2014-01-21 16:32:36 +01:00
|
|
|
|
|
|
|
MEM_freeN(loopindex);
|
Fix [#30234] Various problems with CD layers and tesselation, related to modifiers stack.
Should also fix [#30266], [#29451], and partly [#30316].
Here are the changes made by this commit:
* It adds a "dirty" flag to DerivedMesh struct (for now, only DM_DIRTY_TESS_CDLAYERS, but more might be added as needed).
* It adds a new func, DM_update_tessface_data, which assumes tessfaces themselves are valid, but updates tessellated customdata from their poly/loop counter parts.
* At end of modstack, when valid tessellated faces are present in finaldm , but the cdlayers dirty flag is set, call that function (instead of recomputing the whole tessellation).
* Edits to the codes concerned (UVProject, DynamicPaint, and Subsurf modifiers).
* Also add to subsurf dm generation code the creation of a CD_POLYINDEX layer (mandatory for DM_update_tessface_data to work well, and imho all tessellated dm should have one).
Note: some pieces of old code are just #if 0’ed, will clean them later.
2012-03-18 23:06:57 +01:00
|
|
|
}
|
|
|
|
|
2012-03-31 02:59:17 +02:00
|
|
|
if (G.debug & G_DEBUG)
|
2012-04-12 16:36:57 +02:00
|
|
|
printf("%s: Updated tessellated customdata of dm %p\n", __func__, dm);
|
Fix [#30234] Various problems with CD layers and tesselation, related to modifiers stack.
Should also fix [#30266], [#29451], and partly [#30316].
Here are the changes made by this commit:
* It adds a "dirty" flag to DerivedMesh struct (for now, only DM_DIRTY_TESS_CDLAYERS, but more might be added as needed).
* It adds a new func, DM_update_tessface_data, which assumes tessfaces themselves are valid, but updates tessellated customdata from their poly/loop counter parts.
* At end of modstack, when valid tessellated faces are present in finaldm , but the cdlayers dirty flag is set, call that function (instead of recomputing the whole tessellation).
* Edits to the codes concerned (UVProject, DynamicPaint, and Subsurf modifiers).
* Also add to subsurf dm generation code the creation of a CD_POLYINDEX layer (mandatory for DM_update_tessface_data to work well, and imho all tessellated dm should have one).
Note: some pieces of old code are just #if 0’ed, will clean them later.
2012-03-18 23:06:57 +01:00
|
|
|
|
|
|
|
dm->dirty &= ~DM_DIRTY_TESS_CDLAYERS;
|
|
|
|
}
|
|
|
|
|
2015-07-30 14:43:58 +02:00
|
|
|
void DM_generate_tangent_tessface_data(DerivedMesh *dm, bool generate)
|
|
|
|
{
|
|
|
|
MFace *mf, *mface = dm->getTessFaceArray(dm);
|
|
|
|
MPoly *mp = dm->getPolyArray(dm);
|
|
|
|
MLoop *ml = dm->getLoopArray(dm);
|
|
|
|
|
|
|
|
CustomData *fdata = dm->getTessFaceDataLayout(dm);
|
|
|
|
CustomData *ldata = dm->getLoopDataLayout(dm);
|
|
|
|
|
|
|
|
const int totface = dm->getNumTessFaces(dm);
|
|
|
|
int mf_idx;
|
|
|
|
|
|
|
|
int *polyindex = CustomData_get_layer(fdata, CD_ORIGINDEX);
|
2016-04-26 10:43:02 +02:00
|
|
|
unsigned int (*loopindex)[4] = NULL;
|
2015-07-30 14:43:58 +02:00
|
|
|
|
|
|
|
/* Should never occure, but better abort than segfault! */
|
|
|
|
if (!polyindex)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (generate) {
|
2016-04-26 10:43:02 +02:00
|
|
|
for (int j = 0; j < ldata->totlayer; j++) {
|
|
|
|
if (ldata->layers[j].type == CD_TANGENT) {
|
|
|
|
CustomData_add_layer_named(fdata, CD_TANGENT, CD_CALLOC, NULL, totface, ldata->layers[j].name);
|
2017-05-25 07:11:00 +02:00
|
|
|
CustomData_bmesh_update_active_layers(fdata, ldata);
|
2016-04-26 10:43:02 +02:00
|
|
|
|
|
|
|
if (!loopindex) {
|
2018-01-14 22:14:20 +01:00
|
|
|
loopindex = MEM_malloc_arrayN(totface, sizeof(*loopindex), __func__);
|
2016-04-26 10:43:02 +02:00
|
|
|
for (mf_idx = 0, mf = mface; mf_idx < totface; mf_idx++, mf++) {
|
|
|
|
const int mf_len = mf->v4 ? 4 : 3;
|
|
|
|
unsigned int *ml_idx = loopindex[mf_idx];
|
|
|
|
|
|
|
|
/* Find out loop indices. */
|
|
|
|
/* NOTE: This assumes tessface are valid and in sync with loop/poly... Else, most likely, segfault! */
|
|
|
|
for (int i = mp[polyindex[mf_idx]].loopstart, not_done = mf_len; not_done; i++) {
|
|
|
|
const int tf_v = BKE_MESH_TESSFACE_VINDEX_ORDER(mf, ml[i].v);
|
|
|
|
if (tf_v != -1) {
|
|
|
|
ml_idx[tf_v] = i;
|
|
|
|
not_done--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-07-30 14:43:58 +02:00
|
|
|
|
2016-04-26 10:43:02 +02:00
|
|
|
/* NOTE: quad detection issue - fourth vertidx vs fourth loopidx:
|
|
|
|
* Here, our tfaces' fourth vertex index is never 0 for a quad. However, we know our fourth loop index may be
|
|
|
|
* 0 for quads (because our quads may have been rotated compared to their org poly, see tessellation code).
|
|
|
|
* So we pass the MFace's, and BKE_mesh_loops_to_tessdata will use MFace->v4 index as quad test.
|
|
|
|
*/
|
|
|
|
BKE_mesh_tangent_loops_to_tessdata(fdata, ldata, mface, polyindex, loopindex, totface, ldata->layers[j].name);
|
2015-07-30 14:43:58 +02:00
|
|
|
}
|
|
|
|
}
|
2016-04-26 10:43:02 +02:00
|
|
|
if (loopindex)
|
|
|
|
MEM_freeN(loopindex);
|
2017-05-25 07:11:00 +02:00
|
|
|
BLI_assert(CustomData_from_bmeshpoly_test(fdata, ldata, true));
|
2015-07-30 14:43:58 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (G.debug & G_DEBUG)
|
|
|
|
printf("%s: Updated tessellated tangents of dm %p\n", __func__, dm);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-04-09 03:03:25 +02:00
|
|
|
void DM_update_materials(DerivedMesh *dm, Object *ob)
|
|
|
|
{
|
2014-04-09 17:37:54 +02:00
|
|
|
int i, totmat = ob->totcol + 1; /* materials start from 1, default material is 0 */
|
|
|
|
|
2016-05-06 17:58:28 +02:00
|
|
|
if (dm->totmat != totmat) {
|
|
|
|
dm->totmat = totmat;
|
|
|
|
/* invalidate old materials */
|
|
|
|
if (dm->mat)
|
|
|
|
MEM_freeN(dm->mat);
|
2014-04-09 17:37:54 +02:00
|
|
|
|
2018-01-14 22:14:20 +01:00
|
|
|
dm->mat = MEM_malloc_arrayN(totmat, sizeof(*dm->mat), "DerivedMesh.mat");
|
2016-05-06 17:58:28 +02:00
|
|
|
}
|
2014-04-09 17:37:54 +02:00
|
|
|
|
2014-07-21 12:02:05 +02:00
|
|
|
/* we leave last material as empty - rationale here is being able to index
|
|
|
|
* the materials by using the mf->mat_nr directly and leaving the last
|
|
|
|
* material as NULL in case no materials exist on mesh, so indexing will not fail */
|
|
|
|
for (i = 0; i < totmat - 1; i++) {
|
|
|
|
dm->mat[i] = give_current_material(ob, i + 1);
|
2014-04-09 17:37:54 +02:00
|
|
|
}
|
2016-05-06 17:58:28 +02:00
|
|
|
dm->mat[i] = NULL;
|
2014-04-09 03:03:25 +02:00
|
|
|
}
|
|
|
|
|
2015-07-16 20:26:17 +02:00
|
|
|
MLoopUV *DM_paint_uvlayer_active_get(DerivedMesh *dm, int mat_nr)
|
2015-07-16 19:36:03 +02:00
|
|
|
{
|
|
|
|
MLoopUV *uv_base;
|
|
|
|
|
|
|
|
BLI_assert(mat_nr < dm->totmat);
|
|
|
|
|
|
|
|
if (dm->mat[mat_nr] && dm->mat[mat_nr]->texpaintslot &&
|
|
|
|
dm->mat[mat_nr]->texpaintslot[dm->mat[mat_nr]->paint_active_slot].uvname)
|
|
|
|
{
|
|
|
|
uv_base = CustomData_get_layer_named(&dm->loopData, CD_MLOOPUV,
|
|
|
|
dm->mat[mat_nr]->texpaintslot[dm->mat[mat_nr]->paint_active_slot].uvname);
|
|
|
|
/* This can fail if we have changed the name in the UV layer list and have assigned the old name in the material
|
|
|
|
* texture slot.*/
|
|
|
|
if (!uv_base)
|
|
|
|
uv_base = CustomData_get_layer(&dm->loopData, CD_MLOOPUV);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
uv_base = CustomData_get_layer(&dm->loopData, CD_MLOOPUV);
|
|
|
|
}
|
|
|
|
|
|
|
|
return uv_base;
|
|
|
|
}
|
|
|
|
|
2015-02-18 20:00:23 +01:00
|
|
|
void DM_to_mesh(DerivedMesh *dm, Mesh *me, Object *ob, CustomDataMask mask, bool take_ownership)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
|
|
|
/* dm might depend on me, so we need to do everything with a local copy */
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
Mesh tmp = *me;
|
2011-11-16 18:09:41 +01:00
|
|
|
int totvert, totedge /*, totface */ /* UNUSED */, totloop, totpoly;
|
2012-05-12 21:18:02 +02:00
|
|
|
int did_shapekeys = 0;
|
2018-05-30 10:28:24 +02:00
|
|
|
eCDAllocType alloctype = CD_DUPLICATE;
|
2015-02-18 20:00:23 +01:00
|
|
|
|
|
|
|
if (take_ownership && dm->type == DM_TYPE_CDDM && dm->needsFree) {
|
|
|
|
bool has_any_referenced_layers =
|
|
|
|
CustomData_has_referenced(&dm->vertData) ||
|
|
|
|
CustomData_has_referenced(&dm->edgeData) ||
|
|
|
|
CustomData_has_referenced(&dm->loopData) ||
|
|
|
|
CustomData_has_referenced(&dm->faceData) ||
|
|
|
|
CustomData_has_referenced(&dm->polyData);
|
|
|
|
if (!has_any_referenced_layers) {
|
|
|
|
alloctype = CD_ASSIGN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-31 10:50:24 +01:00
|
|
|
CustomData_reset(&tmp.vdata);
|
|
|
|
CustomData_reset(&tmp.edata);
|
|
|
|
CustomData_reset(&tmp.fdata);
|
|
|
|
CustomData_reset(&tmp.ldata);
|
|
|
|
CustomData_reset(&tmp.pdata);
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2013-06-04 18:02:54 +02:00
|
|
|
DM_ensure_normals(dm);
|
|
|
|
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
totvert = tmp.totvert = dm->getNumVerts(dm);
|
|
|
|
totedge = tmp.totedge = dm->getNumEdges(dm);
|
2011-12-03 03:11:38 +01:00
|
|
|
totloop = tmp.totloop = dm->getNumLoops(dm);
|
2011-11-29 14:01:51 +01:00
|
|
|
totpoly = tmp.totpoly = dm->getNumPolys(dm);
|
2013-01-10 06:50:21 +01:00
|
|
|
tmp.totface = 0;
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2015-02-18 20:00:23 +01:00
|
|
|
CustomData_copy(&dm->vertData, &tmp.vdata, mask, alloctype, totvert);
|
|
|
|
CustomData_copy(&dm->edgeData, &tmp.edata, mask, alloctype, totedge);
|
|
|
|
CustomData_copy(&dm->loopData, &tmp.ldata, mask, alloctype, totloop);
|
|
|
|
CustomData_copy(&dm->polyData, &tmp.pdata, mask, alloctype, totpoly);
|
2013-02-26 15:32:53 +01:00
|
|
|
tmp.cd_flag = dm->cd_flag;
|
2018-05-15 13:26:24 +02:00
|
|
|
tmp.runtime.deformed_only = dm->deformedOnly;
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2011-04-15 07:20:18 +02:00
|
|
|
if (CustomData_has_layer(&dm->vertData, CD_SHAPEKEY)) {
|
|
|
|
KeyBlock *kb;
|
2012-01-30 04:54:24 +01:00
|
|
|
int uid;
|
2011-04-15 07:20:18 +02:00
|
|
|
|
|
|
|
if (ob) {
|
2012-05-12 21:18:02 +02:00
|
|
|
kb = BLI_findlink(&me->key->block, ob->shapenr - 1);
|
2012-01-30 04:54:24 +01:00
|
|
|
if (kb) {
|
|
|
|
uid = kb->uid;
|
2011-04-15 07:20:18 +02:00
|
|
|
}
|
2012-01-30 04:54:24 +01:00
|
|
|
else {
|
2011-11-25 00:09:55 +01:00
|
|
|
printf("%s: error - could not find active shapekey %d!\n",
|
2012-05-12 21:18:02 +02:00
|
|
|
__func__, ob->shapenr - 1);
|
2011-11-25 00:09:55 +01:00
|
|
|
|
2012-01-30 04:54:24 +01:00
|
|
|
uid = INT_MAX;
|
2011-04-15 07:20:18 +02:00
|
|
|
}
|
2012-01-30 04:54:24 +01:00
|
|
|
}
|
|
|
|
else {
|
2012-08-17 16:43:20 +02:00
|
|
|
/* if no object, set to INT_MAX so we don't mess up any shapekey layers */
|
2012-01-30 04:54:24 +01:00
|
|
|
uid = INT_MAX;
|
2011-04-15 07:20:18 +02:00
|
|
|
}
|
2012-01-30 04:54:24 +01:00
|
|
|
|
|
|
|
shapekey_layers_to_keyblocks(dm, me, uid);
|
2011-04-15 07:20:18 +02:00
|
|
|
did_shapekeys = 1;
|
|
|
|
}
|
2013-06-10 15:01:41 +02:00
|
|
|
|
|
|
|
/* copy texture space */
|
2013-08-04 01:58:17 +02:00
|
|
|
if (ob) {
|
|
|
|
BKE_mesh_texspace_copy_from_object(&tmp, ob);
|
|
|
|
}
|
2011-04-15 07:20:18 +02:00
|
|
|
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
/* not all DerivedMeshes store their verts/edges/faces in CustomData, so
|
2012-03-09 19:28:30 +01:00
|
|
|
* we set them here in case they are missing */
|
2015-02-18 20:00:23 +01:00
|
|
|
if (!CustomData_has_layer(&tmp.vdata, CD_MVERT)) {
|
|
|
|
CustomData_add_layer(&tmp.vdata, CD_MVERT, CD_ASSIGN,
|
|
|
|
(alloctype == CD_ASSIGN) ? dm->getVertArray(dm) : dm->dupVertArray(dm),
|
|
|
|
totvert);
|
|
|
|
}
|
|
|
|
if (!CustomData_has_layer(&tmp.edata, CD_MEDGE)) {
|
|
|
|
CustomData_add_layer(&tmp.edata, CD_MEDGE, CD_ASSIGN,
|
|
|
|
(alloctype == CD_ASSIGN) ? dm->getEdgeArray(dm) : dm->dupEdgeArray(dm),
|
|
|
|
totedge);
|
|
|
|
}
|
2012-03-24 07:18:31 +01:00
|
|
|
if (!CustomData_has_layer(&tmp.pdata, CD_MPOLY)) {
|
2015-02-18 20:00:23 +01:00
|
|
|
tmp.mloop = (alloctype == CD_ASSIGN) ? dm->getLoopArray(dm) : dm->dupLoopArray(dm);
|
|
|
|
tmp.mpoly = (alloctype == CD_ASSIGN) ? dm->getPolyArray(dm) : dm->dupPolyArray(dm);
|
2011-06-14 05:16:08 +02:00
|
|
|
|
|
|
|
CustomData_add_layer(&tmp.ldata, CD_MLOOP, CD_ASSIGN, tmp.mloop, tmp.totloop);
|
|
|
|
CustomData_add_layer(&tmp.pdata, CD_MPOLY, CD_ASSIGN, tmp.mpoly, tmp.totpoly);
|
|
|
|
}
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
|
2010-09-26 20:29:54 +02:00
|
|
|
/* object had got displacement layer, should copy this layer to save sculpted data */
|
|
|
|
/* NOTE: maybe some other layers should be copied? nazgul */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (CustomData_has_layer(&me->ldata, CD_MDISPS)) {
|
2011-04-15 07:20:18 +02:00
|
|
|
if (totloop == me->totloop) {
|
|
|
|
MDisps *mdisps = CustomData_get_layer(&me->ldata, CD_MDISPS);
|
2015-02-18 20:00:23 +01:00
|
|
|
CustomData_add_layer(&tmp.ldata, CD_MDISPS, alloctype, mdisps, totloop);
|
2010-09-26 20:29:54 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-20 23:56:26 +01:00
|
|
|
/* yes, must be before _and_ after tessellate */
|
2013-03-17 20:55:10 +01:00
|
|
|
BKE_mesh_update_customdata_pointers(&tmp, false);
|
2011-11-25 23:32:58 +01:00
|
|
|
|
2013-01-10 06:50:21 +01:00
|
|
|
/* since 2.65 caller must do! */
|
|
|
|
// BKE_mesh_tessface_calc(&tmp);
|
2011-11-25 23:32:58 +01:00
|
|
|
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
CustomData_free(&me->vdata, me->totvert);
|
|
|
|
CustomData_free(&me->edata, me->totedge);
|
|
|
|
CustomData_free(&me->fdata, me->totface);
|
2009-06-16 22:08:40 +02:00
|
|
|
CustomData_free(&me->ldata, me->totloop);
|
|
|
|
CustomData_free(&me->pdata, me->totpoly);
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
|
2012-03-09 19:28:30 +01:00
|
|
|
/* ok, this should now use new CD shapekey data,
|
2012-08-25 01:22:34 +02:00
|
|
|
* which should be fed through the modifier
|
2016-01-28 06:30:50 +01:00
|
|
|
* stack */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (tmp.totvert != me->totvert && !did_shapekeys && me->key) {
|
2012-04-12 16:36:57 +02:00
|
|
|
printf("%s: YEEK! this should be recoded! Shape key loss!: ID '%s'\n", __func__, tmp.id.name);
|
2018-05-18 15:10:48 +02:00
|
|
|
if (tmp.key && !(tmp.id.tag & LIB_TAG_NO_MAIN)) {
|
2015-11-09 19:47:10 +01:00
|
|
|
id_us_min(&tmp.key->id);
|
2018-05-18 15:10:48 +02:00
|
|
|
}
|
2010-06-23 12:18:51 +02:00
|
|
|
tmp.key = NULL;
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
|
|
|
|
2013-02-04 12:28:31 +01:00
|
|
|
/* Clear selection history */
|
2016-03-03 14:44:05 +01:00
|
|
|
MEM_SAFE_FREE(tmp.mselect);
|
2013-02-04 12:28:31 +01:00
|
|
|
tmp.totselect = 0;
|
2016-03-03 14:44:05 +01:00
|
|
|
BLI_assert(ELEM(tmp.bb, NULL, me->bb));
|
2016-02-22 13:20:18 +01:00
|
|
|
if (me->bb) {
|
|
|
|
MEM_freeN(me->bb);
|
2016-03-03 14:44:05 +01:00
|
|
|
tmp.bb = NULL;
|
2016-02-22 13:20:18 +01:00
|
|
|
}
|
2013-02-04 12:28:31 +01:00
|
|
|
|
2014-06-24 15:50:12 +02:00
|
|
|
/* skip the listbase */
|
|
|
|
MEMCPY_STRUCT_OFS(me, &tmp, id.prev);
|
2015-02-18 20:00:23 +01:00
|
|
|
|
|
|
|
if (take_ownership) {
|
|
|
|
if (alloctype == CD_ASSIGN) {
|
|
|
|
CustomData_free_typemask(&dm->vertData, dm->numVertData, ~mask);
|
|
|
|
CustomData_free_typemask(&dm->edgeData, dm->numEdgeData, ~mask);
|
|
|
|
CustomData_free_typemask(&dm->loopData, dm->numLoopData, ~mask);
|
|
|
|
CustomData_free_typemask(&dm->polyData, dm->numPolyData, ~mask);
|
|
|
|
}
|
|
|
|
dm->release(dm);
|
|
|
|
}
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
|
|
|
|
2009-11-22 14:44:09 +01:00
|
|
|
void DM_to_meshkey(DerivedMesh *dm, Mesh *me, KeyBlock *kb)
|
|
|
|
{
|
|
|
|
int a, totvert = dm->getNumVerts(dm);
|
|
|
|
float *fp;
|
|
|
|
MVert *mvert;
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
if (totvert == 0 || me->totvert == 0 || me->totvert != totvert) {
|
|
|
|
return;
|
|
|
|
}
|
2009-11-22 14:44:09 +01:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (kb->data) MEM_freeN(kb->data);
|
2018-01-14 22:14:20 +01:00
|
|
|
kb->data = MEM_malloc_arrayN(me->key->elemsize, me->totvert, "kb->data");
|
2012-05-12 21:18:02 +02:00
|
|
|
kb->totelem = totvert;
|
2009-11-22 14:44:09 +01:00
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
fp = kb->data;
|
|
|
|
mvert = dm->getVertDataArray(dm, CD_MVERT);
|
2009-11-22 14:44:09 +01:00
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
for (a = 0; a < kb->totelem; a++, fp += 3, mvert++) {
|
2011-11-06 16:39:20 +01:00
|
|
|
copy_v3_v3(fp, mvert->co);
|
2009-11-22 14:44:09 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
/**
|
|
|
|
* set the CD_FLAG_NOCOPY flag in custom data layers where the mask is
|
|
|
|
* zero for the layer type, so only layer types specified by the mask
|
|
|
|
* will be copied
|
|
|
|
*/
|
2006-12-05 18:42:03 +01:00
|
|
|
void DM_set_only_copy(DerivedMesh *dm, CustomDataMask mask)
|
|
|
|
{
|
|
|
|
CustomData_set_only_copy(&dm->vertData, mask);
|
|
|
|
CustomData_set_only_copy(&dm->edgeData, mask);
|
|
|
|
CustomData_set_only_copy(&dm->faceData, mask);
|
2012-10-01 16:23:57 +02:00
|
|
|
/* this wasn't in 2.63 and is disabled for 2.64 because it gives problems with
|
|
|
|
* weight paint mode when there are modifiers applied, needs further investigation,
|
|
|
|
* see replies to r50969, Campbell */
|
|
|
|
#if 0
|
2012-10-01 06:59:21 +02:00
|
|
|
CustomData_set_only_copy(&dm->loopData, mask);
|
|
|
|
CustomData_set_only_copy(&dm->polyData, mask);
|
2012-10-01 16:23:57 +02:00
|
|
|
#endif
|
2006-12-05 18:42:03 +01:00
|
|
|
}
|
|
|
|
|
2018-05-16 12:44:49 +02:00
|
|
|
static void mesh_set_only_copy(Mesh *mesh, CustomDataMask mask)
|
2018-05-11 09:53:52 +02:00
|
|
|
{
|
|
|
|
CustomData_set_only_copy(&mesh->vdata, mask);
|
|
|
|
CustomData_set_only_copy(&mesh->edata, mask);
|
|
|
|
CustomData_set_only_copy(&mesh->fdata, mask);
|
|
|
|
/* this wasn't in 2.63 and is disabled for 2.64 because it gives problems with
|
|
|
|
* weight paint mode when there are modifiers applied, needs further investigation,
|
|
|
|
* see replies to r50969, Campbell */
|
|
|
|
#if 0
|
|
|
|
CustomData_set_only_copy(&mesh->ldata, mask);
|
|
|
|
CustomData_set_only_copy(&mesh->pdata, mask);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2018-05-30 10:28:24 +02:00
|
|
|
void DM_add_vert_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
2006-12-12 22:29:09 +01:00
|
|
|
CustomData_add_layer(&dm->vertData, type, alloctype, layer, dm->numVertData);
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
|
|
|
|
2018-05-30 10:28:24 +02:00
|
|
|
void DM_add_edge_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
2006-12-12 22:29:09 +01:00
|
|
|
CustomData_add_layer(&dm->edgeData, type, alloctype, layer, dm->numEdgeData);
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
|
|
|
|
2018-05-30 10:28:24 +02:00
|
|
|
void DM_add_tessface_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
2011-11-30 19:03:56 +01:00
|
|
|
CustomData_add_layer(&dm->faceData, type, alloctype, layer, dm->numTessFaceData);
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
|
|
|
|
2018-05-30 10:28:24 +02:00
|
|
|
void DM_add_loop_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer)
|
2009-08-15 19:31:28 +02:00
|
|
|
{
|
|
|
|
CustomData_add_layer(&dm->loopData, type, alloctype, layer, dm->numLoopData);
|
|
|
|
}
|
|
|
|
|
2018-05-30 10:28:24 +02:00
|
|
|
void DM_add_poly_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer)
|
2009-08-15 19:31:28 +02:00
|
|
|
{
|
|
|
|
CustomData_add_layer(&dm->polyData, type, alloctype, layer, dm->numPolyData);
|
|
|
|
}
|
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
void *DM_get_vert_data(DerivedMesh *dm, int index, int type)
|
|
|
|
{
|
2013-07-10 07:38:36 +02:00
|
|
|
BLI_assert(index >= 0 && index < dm->getNumVerts(dm));
|
2006-08-28 03:12:36 +02:00
|
|
|
return CustomData_get(&dm->vertData, index, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *DM_get_edge_data(DerivedMesh *dm, int index, int type)
|
|
|
|
{
|
2013-07-10 07:38:36 +02:00
|
|
|
BLI_assert(index >= 0 && index < dm->getNumEdges(dm));
|
2006-08-28 03:12:36 +02:00
|
|
|
return CustomData_get(&dm->edgeData, index, type);
|
|
|
|
}
|
|
|
|
|
2011-11-29 06:09:54 +01:00
|
|
|
void *DM_get_tessface_data(DerivedMesh *dm, int index, int type)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
2013-07-10 07:38:36 +02:00
|
|
|
BLI_assert(index >= 0 && index < dm->getNumTessFaces(dm));
|
2006-08-28 03:12:36 +02:00
|
|
|
return CustomData_get(&dm->faceData, index, type);
|
|
|
|
}
|
|
|
|
|
2012-10-30 20:20:17 +01:00
|
|
|
void *DM_get_poly_data(DerivedMesh *dm, int index, int type)
|
|
|
|
{
|
2013-07-10 07:38:36 +02:00
|
|
|
BLI_assert(index >= 0 && index < dm->getNumPolys(dm));
|
2012-10-30 20:20:17 +01:00
|
|
|
return CustomData_get(&dm->polyData, index, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
void *DM_get_vert_data_layer(DerivedMesh *dm, int type)
|
|
|
|
{
|
2012-03-24 07:18:31 +01:00
|
|
|
if (type == CD_MVERT)
|
2010-01-06 13:05:46 +01:00
|
|
|
return dm->getVertArray(dm);
|
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
return CustomData_get_layer(&dm->vertData, type);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *DM_get_edge_data_layer(DerivedMesh *dm, int type)
|
|
|
|
{
|
2012-03-24 07:18:31 +01:00
|
|
|
if (type == CD_MEDGE)
|
2010-01-06 13:05:46 +01:00
|
|
|
return dm->getEdgeArray(dm);
|
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
return CustomData_get_layer(&dm->edgeData, type);
|
|
|
|
}
|
|
|
|
|
2009-08-15 19:31:28 +02:00
|
|
|
void *DM_get_tessface_data_layer(DerivedMesh *dm, int type)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
2011-11-13 16:13:59 +01:00
|
|
|
if (type == CD_MFACE)
|
2010-01-13 08:26:11 +01:00
|
|
|
return dm->getTessFaceArray(dm);
|
2010-01-06 13:05:46 +01:00
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
return CustomData_get_layer(&dm->faceData, type);
|
|
|
|
}
|
|
|
|
|
2011-11-29 06:09:54 +01:00
|
|
|
void *DM_get_poly_data_layer(DerivedMesh *dm, int type)
|
2009-08-15 19:31:28 +02:00
|
|
|
{
|
|
|
|
return CustomData_get_layer(&dm->polyData, type);
|
|
|
|
}
|
|
|
|
|
2012-02-05 12:30:26 +01:00
|
|
|
void *DM_get_loop_data_layer(DerivedMesh *dm, int type)
|
|
|
|
{
|
|
|
|
return CustomData_get_layer(&dm->loopData, type);
|
|
|
|
}
|
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
void DM_set_vert_data(DerivedMesh *dm, int index, int type, void *data)
|
|
|
|
{
|
|
|
|
CustomData_set(&dm->vertData, index, type, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
void DM_set_edge_data(DerivedMesh *dm, int index, int type, void *data)
|
|
|
|
{
|
|
|
|
CustomData_set(&dm->edgeData, index, type, data);
|
|
|
|
}
|
|
|
|
|
2011-11-29 06:09:54 +01:00
|
|
|
void DM_set_tessface_data(DerivedMesh *dm, int index, int type, void *data)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
|
|
|
CustomData_set(&dm->faceData, index, type, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
void DM_copy_vert_data(DerivedMesh *source, DerivedMesh *dest,
|
2012-05-12 21:18:02 +02:00
|
|
|
int source_index, int dest_index, int count)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
|
|
|
CustomData_copy_data(&source->vertData, &dest->vertData,
|
2012-05-12 21:18:02 +02:00
|
|
|
source_index, dest_index, count);
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void DM_copy_edge_data(DerivedMesh *source, DerivedMesh *dest,
|
2012-05-12 21:18:02 +02:00
|
|
|
int source_index, int dest_index, int count)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
|
|
|
CustomData_copy_data(&source->edgeData, &dest->edgeData,
|
2012-05-12 21:18:02 +02:00
|
|
|
source_index, dest_index, count);
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
|
|
|
|
(NOTE: DO NOT TEST)
Start of planned DerivedMesh refactoring. The mface
interfaces in DerivedMesh have been renamed to reflect
their new status as tesselated face interfaces (rather
then the primary ones, which are now stored in mpolys).
short review: mpolys store "primary" face data, while
mfaces store the tesselated form of the mesh (generally
as triangles). mpolys are defined by mloops, and each
mpoly defines a range of loops it "owns" in the main
mloop array.
I've also added basic read-only face iterators, which
are implemented for CDDM, ccgsubsurf, and the bmeditmesh
derivedmesh. Since faces are now variable-length things,
trying to implement the same interface as mfaces would not
have worked well (especially since faces are stored as
an mpoly + a range of mloops).
I figure first we can evaluate these simple read-only
face iterators, then decide if a) we like using iterators
in DerivedMesh, b) how much of it should use them, and c)
if we want write-capable iterators.
I plan to write official docs on this design after I get
it more stable; I'm committing now because there's a rather
lot of changes, and I might do a merge soon.
2009-06-10 12:06:25 +02:00
|
|
|
void DM_copy_tessface_data(DerivedMesh *source, DerivedMesh *dest,
|
2012-05-12 21:18:02 +02:00
|
|
|
int source_index, int dest_index, int count)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
|
|
|
CustomData_copy_data(&source->faceData, &dest->faceData,
|
2012-05-12 21:18:02 +02:00
|
|
|
source_index, dest_index, count);
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
|
|
|
|
(NOTE: DO NOT TEST)
Start of planned DerivedMesh refactoring. The mface
interfaces in DerivedMesh have been renamed to reflect
their new status as tesselated face interfaces (rather
then the primary ones, which are now stored in mpolys).
short review: mpolys store "primary" face data, while
mfaces store the tesselated form of the mesh (generally
as triangles). mpolys are defined by mloops, and each
mpoly defines a range of loops it "owns" in the main
mloop array.
I've also added basic read-only face iterators, which
are implemented for CDDM, ccgsubsurf, and the bmeditmesh
derivedmesh. Since faces are now variable-length things,
trying to implement the same interface as mfaces would not
have worked well (especially since faces are stored as
an mpoly + a range of mloops).
I figure first we can evaluate these simple read-only
face iterators, then decide if a) we like using iterators
in DerivedMesh, b) how much of it should use them, and c)
if we want write-capable iterators.
I plan to write official docs on this design after I get
it more stable; I'm committing now because there's a rather
lot of changes, and I might do a merge soon.
2009-06-10 12:06:25 +02:00
|
|
|
void DM_copy_loop_data(DerivedMesh *source, DerivedMesh *dest,
|
|
|
|
int source_index, int dest_index, int count)
|
|
|
|
{
|
|
|
|
CustomData_copy_data(&source->loopData, &dest->loopData,
|
|
|
|
source_index, dest_index, count);
|
|
|
|
}
|
|
|
|
|
2011-11-29 06:09:54 +01:00
|
|
|
void DM_copy_poly_data(DerivedMesh *source, DerivedMesh *dest,
|
(NOTE: DO NOT TEST)
Start of planned DerivedMesh refactoring. The mface
interfaces in DerivedMesh have been renamed to reflect
their new status as tesselated face interfaces (rather
then the primary ones, which are now stored in mpolys).
short review: mpolys store "primary" face data, while
mfaces store the tesselated form of the mesh (generally
as triangles). mpolys are defined by mloops, and each
mpoly defines a range of loops it "owns" in the main
mloop array.
I've also added basic read-only face iterators, which
are implemented for CDDM, ccgsubsurf, and the bmeditmesh
derivedmesh. Since faces are now variable-length things,
trying to implement the same interface as mfaces would not
have worked well (especially since faces are stored as
an mpoly + a range of mloops).
I figure first we can evaluate these simple read-only
face iterators, then decide if a) we like using iterators
in DerivedMesh, b) how much of it should use them, and c)
if we want write-capable iterators.
I plan to write official docs on this design after I get
it more stable; I'm committing now because there's a rather
lot of changes, and I might do a merge soon.
2009-06-10 12:06:25 +02:00
|
|
|
int source_index, int dest_index, int count)
|
|
|
|
{
|
|
|
|
CustomData_copy_data(&source->polyData, &dest->polyData,
|
|
|
|
source_index, dest_index, count);
|
|
|
|
}
|
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
void DM_free_vert_data(struct DerivedMesh *dm, int index, int count)
|
|
|
|
{
|
|
|
|
CustomData_free_elem(&dm->vertData, index, count);
|
|
|
|
}
|
|
|
|
|
|
|
|
void DM_free_edge_data(struct DerivedMesh *dm, int index, int count)
|
|
|
|
{
|
|
|
|
CustomData_free_elem(&dm->edgeData, index, count);
|
|
|
|
}
|
|
|
|
|
(NOTE: DO NOT TEST)
Start of planned DerivedMesh refactoring. The mface
interfaces in DerivedMesh have been renamed to reflect
their new status as tesselated face interfaces (rather
then the primary ones, which are now stored in mpolys).
short review: mpolys store "primary" face data, while
mfaces store the tesselated form of the mesh (generally
as triangles). mpolys are defined by mloops, and each
mpoly defines a range of loops it "owns" in the main
mloop array.
I've also added basic read-only face iterators, which
are implemented for CDDM, ccgsubsurf, and the bmeditmesh
derivedmesh. Since faces are now variable-length things,
trying to implement the same interface as mfaces would not
have worked well (especially since faces are stored as
an mpoly + a range of mloops).
I figure first we can evaluate these simple read-only
face iterators, then decide if a) we like using iterators
in DerivedMesh, b) how much of it should use them, and c)
if we want write-capable iterators.
I plan to write official docs on this design after I get
it more stable; I'm committing now because there's a rather
lot of changes, and I might do a merge soon.
2009-06-10 12:06:25 +02:00
|
|
|
void DM_free_tessface_data(struct DerivedMesh *dm, int index, int count)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
|
|
|
CustomData_free_elem(&dm->faceData, index, count);
|
|
|
|
}
|
|
|
|
|
(NOTE: DO NOT TEST)
Start of planned DerivedMesh refactoring. The mface
interfaces in DerivedMesh have been renamed to reflect
their new status as tesselated face interfaces (rather
then the primary ones, which are now stored in mpolys).
short review: mpolys store "primary" face data, while
mfaces store the tesselated form of the mesh (generally
as triangles). mpolys are defined by mloops, and each
mpoly defines a range of loops it "owns" in the main
mloop array.
I've also added basic read-only face iterators, which
are implemented for CDDM, ccgsubsurf, and the bmeditmesh
derivedmesh. Since faces are now variable-length things,
trying to implement the same interface as mfaces would not
have worked well (especially since faces are stored as
an mpoly + a range of mloops).
I figure first we can evaluate these simple read-only
face iterators, then decide if a) we like using iterators
in DerivedMesh, b) how much of it should use them, and c)
if we want write-capable iterators.
I plan to write official docs on this design after I get
it more stable; I'm committing now because there's a rather
lot of changes, and I might do a merge soon.
2009-06-10 12:06:25 +02:00
|
|
|
void DM_free_loop_data(struct DerivedMesh *dm, int index, int count)
|
|
|
|
{
|
|
|
|
CustomData_free_elem(&dm->loopData, index, count);
|
|
|
|
}
|
|
|
|
|
2011-11-29 06:09:54 +01:00
|
|
|
void DM_free_poly_data(struct DerivedMesh *dm, int index, int count)
|
(NOTE: DO NOT TEST)
Start of planned DerivedMesh refactoring. The mface
interfaces in DerivedMesh have been renamed to reflect
their new status as tesselated face interfaces (rather
then the primary ones, which are now stored in mpolys).
short review: mpolys store "primary" face data, while
mfaces store the tesselated form of the mesh (generally
as triangles). mpolys are defined by mloops, and each
mpoly defines a range of loops it "owns" in the main
mloop array.
I've also added basic read-only face iterators, which
are implemented for CDDM, ccgsubsurf, and the bmeditmesh
derivedmesh. Since faces are now variable-length things,
trying to implement the same interface as mfaces would not
have worked well (especially since faces are stored as
an mpoly + a range of mloops).
I figure first we can evaluate these simple read-only
face iterators, then decide if a) we like using iterators
in DerivedMesh, b) how much of it should use them, and c)
if we want write-capable iterators.
I plan to write official docs on this design after I get
it more stable; I'm committing now because there's a rather
lot of changes, and I might do a merge soon.
2009-06-10 12:06:25 +02:00
|
|
|
{
|
|
|
|
CustomData_free_elem(&dm->polyData, index, count);
|
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
/**
|
|
|
|
* interpolates vertex data from the vertices indexed by src_indices in the
|
|
|
|
* source mesh using the given weights and stores the result in the vertex
|
|
|
|
* indexed by dest_index in the dest mesh
|
|
|
|
*/
|
|
|
|
void DM_interp_vert_data(
|
|
|
|
DerivedMesh *source, DerivedMesh *dest,
|
|
|
|
int *src_indices, float *weights,
|
|
|
|
int count, int dest_index)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
|
|
|
CustomData_interp(&source->vertData, &dest->vertData, src_indices,
|
2012-05-12 21:18:02 +02:00
|
|
|
weights, NULL, count, dest_index);
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
/**
|
|
|
|
* interpolates edge data from the edges indexed by src_indices in the
|
|
|
|
* source mesh using the given weights and stores the result in the edge indexed
|
|
|
|
* by dest_index in the dest mesh.
|
|
|
|
* if weights is NULL, all weights default to 1.
|
|
|
|
* if vert_weights is non-NULL, any per-vertex edge data is interpolated using
|
|
|
|
* vert_weights[i] multiplied by weights[i].
|
|
|
|
*/
|
|
|
|
void DM_interp_edge_data(
|
|
|
|
DerivedMesh *source, DerivedMesh *dest,
|
|
|
|
int *src_indices,
|
|
|
|
float *weights, EdgeVertWeight *vert_weights,
|
|
|
|
int count, int dest_index)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
|
|
|
CustomData_interp(&source->edgeData, &dest->edgeData, src_indices,
|
2012-05-12 21:18:02 +02:00
|
|
|
weights, (float *)vert_weights, count, dest_index);
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
/**
|
|
|
|
* interpolates face data from the faces indexed by src_indices in the
|
|
|
|
* source mesh using the given weights and stores the result in the face indexed
|
|
|
|
* by dest_index in the dest mesh.
|
|
|
|
* if weights is NULL, all weights default to 1.
|
|
|
|
* if vert_weights is non-NULL, any per-vertex face data is interpolated using
|
|
|
|
* vert_weights[i] multiplied by weights[i].
|
|
|
|
*/
|
|
|
|
void DM_interp_tessface_data(
|
|
|
|
DerivedMesh *source, DerivedMesh *dest,
|
|
|
|
int *src_indices,
|
|
|
|
float *weights, FaceVertWeight *vert_weights,
|
|
|
|
int count, int dest_index)
|
2006-08-28 03:12:36 +02:00
|
|
|
{
|
|
|
|
CustomData_interp(&source->faceData, &dest->faceData, src_indices,
|
2012-05-12 21:18:02 +02:00
|
|
|
weights, (float *)vert_weights, count, dest_index);
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
2005-03-27 22:34:18 +02:00
|
|
|
|
2010-07-19 06:44:37 +02:00
|
|
|
void DM_swap_tessface_data(DerivedMesh *dm, int index, const int *corner_indices)
|
2005-07-17 19:41:03 +02:00
|
|
|
{
|
2016-02-28 15:16:42 +01:00
|
|
|
CustomData_swap_corners(&dm->faceData, index, corner_indices);
|
2005-07-17 19:41:03 +02:00
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
void DM_interp_loop_data(
|
|
|
|
DerivedMesh *source, DerivedMesh *dest,
|
|
|
|
int *src_indices,
|
|
|
|
float *weights, int count, int dest_index)
|
(NOTE: DO NOT TEST)
Start of planned DerivedMesh refactoring. The mface
interfaces in DerivedMesh have been renamed to reflect
their new status as tesselated face interfaces (rather
then the primary ones, which are now stored in mpolys).
short review: mpolys store "primary" face data, while
mfaces store the tesselated form of the mesh (generally
as triangles). mpolys are defined by mloops, and each
mpoly defines a range of loops it "owns" in the main
mloop array.
I've also added basic read-only face iterators, which
are implemented for CDDM, ccgsubsurf, and the bmeditmesh
derivedmesh. Since faces are now variable-length things,
trying to implement the same interface as mfaces would not
have worked well (especially since faces are stored as
an mpoly + a range of mloops).
I figure first we can evaluate these simple read-only
face iterators, then decide if a) we like using iterators
in DerivedMesh, b) how much of it should use them, and c)
if we want write-capable iterators.
I plan to write official docs on this design after I get
it more stable; I'm committing now because there's a rather
lot of changes, and I might do a merge soon.
2009-06-10 12:06:25 +02:00
|
|
|
{
|
|
|
|
CustomData_interp(&source->loopData, &dest->loopData, src_indices,
|
|
|
|
weights, NULL, count, dest_index);
|
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
void DM_interp_poly_data(
|
|
|
|
DerivedMesh *source, DerivedMesh *dest,
|
|
|
|
int *src_indices,
|
|
|
|
float *weights, int count, int dest_index)
|
(NOTE: DO NOT TEST)
Start of planned DerivedMesh refactoring. The mface
interfaces in DerivedMesh have been renamed to reflect
their new status as tesselated face interfaces (rather
then the primary ones, which are now stored in mpolys).
short review: mpolys store "primary" face data, while
mfaces store the tesselated form of the mesh (generally
as triangles). mpolys are defined by mloops, and each
mpoly defines a range of loops it "owns" in the main
mloop array.
I've also added basic read-only face iterators, which
are implemented for CDDM, ccgsubsurf, and the bmeditmesh
derivedmesh. Since faces are now variable-length things,
trying to implement the same interface as mfaces would not
have worked well (especially since faces are stored as
an mpoly + a range of mloops).
I figure first we can evaluate these simple read-only
face iterators, then decide if a) we like using iterators
in DerivedMesh, b) how much of it should use them, and c)
if we want write-capable iterators.
I plan to write official docs on this design after I get
it more stable; I'm committing now because there's a rather
lot of changes, and I might do a merge soon.
2009-06-10 12:06:25 +02:00
|
|
|
{
|
|
|
|
CustomData_interp(&source->polyData, &dest->polyData, src_indices,
|
|
|
|
weights, NULL, count, dest_index);
|
|
|
|
}
|
|
|
|
|
2013-12-25 22:26:41 +01:00
|
|
|
DerivedMesh *mesh_create_derived(Mesh *me, float (*vertCos)[3])
|
2005-03-27 22:34:18 +02:00
|
|
|
{
|
2013-12-25 22:26:41 +01:00
|
|
|
DerivedMesh *dm = CDDM_from_mesh(me);
|
2008-07-25 20:57:16 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (!dm)
|
2008-07-25 20:57:16 +02:00
|
|
|
return NULL;
|
|
|
|
|
2013-05-30 19:36:43 +02:00
|
|
|
if (vertCos) {
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
CDDM_apply_vert_coords(dm, vertCos);
|
2013-05-30 19:36:43 +02:00
|
|
|
}
|
2005-03-27 23:27:12 +02:00
|
|
|
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
return dm;
|
2005-03-27 22:34:18 +02:00
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
DerivedMesh *mesh_create_derived_for_modifier(
|
2018-04-06 12:07:27 +02:00
|
|
|
struct Depsgraph *depsgraph, Scene *scene, Object *ob,
|
2015-07-02 08:20:22 +02:00
|
|
|
ModifierData *md, int build_shapekey_layers)
|
2005-07-26 02:45:19 +02:00
|
|
|
{
|
|
|
|
Mesh *me = ob->data;
|
2015-03-30 12:17:07 +02:00
|
|
|
const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
|
2005-07-26 02:45:19 +02:00
|
|
|
DerivedMesh *dm;
|
2012-01-30 04:54:24 +01:00
|
|
|
KeyBlock *kb;
|
2018-05-01 17:33:04 +02:00
|
|
|
ModifierEvalContext mectx = {depsgraph, ob, 0};
|
2005-07-26 02:45:19 +02:00
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
md->scene = scene;
|
2009-01-04 15:14:06 +01:00
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
if (!(md->mode & eModifierMode_Realtime)) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mti->isDisabled && mti->isDisabled(md, 0)) {
|
|
|
|
return NULL;
|
|
|
|
}
|
2011-04-15 07:20:18 +02:00
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
if (build_shapekey_layers && me->key && (kb = BLI_findlink(&me->key->block, ob->shapenr - 1))) {
|
2014-11-16 19:15:23 +01:00
|
|
|
BKE_keyblock_convert_to_mesh(kb, me);
|
2011-04-15 07:20:18 +02:00
|
|
|
}
|
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
if (mti->type == eModifierTypeType_OnlyDeform) {
|
2005-07-26 02:45:19 +02:00
|
|
|
int numVerts;
|
2018-05-22 17:36:58 +02:00
|
|
|
float (*deformedVerts)[3] = BKE_mesh_vertexCos_get(me, &numVerts);
|
2005-07-26 02:45:19 +02:00
|
|
|
|
2018-05-01 17:33:04 +02:00
|
|
|
modwrap_deformVerts(md, &mectx, NULL, deformedVerts, numVerts);
|
2013-12-25 22:26:41 +01:00
|
|
|
dm = mesh_create_derived(me, deformedVerts);
|
2006-08-20 17:22:56 +02:00
|
|
|
|
2011-04-15 07:20:18 +02:00
|
|
|
if (build_shapekey_layers)
|
|
|
|
add_shapekey_layers(dm, me, ob);
|
|
|
|
|
2005-07-26 02:45:19 +02:00
|
|
|
MEM_freeN(deformedVerts);
|
2012-03-24 07:18:31 +01:00
|
|
|
}
|
|
|
|
else {
|
2013-12-25 22:26:41 +01:00
|
|
|
DerivedMesh *tdm = mesh_create_derived(me, NULL);
|
2011-04-15 07:20:18 +02:00
|
|
|
|
|
|
|
if (build_shapekey_layers)
|
|
|
|
add_shapekey_layers(tdm, me, ob);
|
|
|
|
|
2018-05-01 17:33:04 +02:00
|
|
|
dm = modwrap_applyModifier(md, &mectx, tdm);
|
2013-09-04 03:29:34 +02:00
|
|
|
ASSERT_IS_VALID_DM(dm);
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (tdm != dm) tdm->release(tdm);
|
2005-07-26 02:45:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return dm;
|
|
|
|
}
|
|
|
|
|
2012-12-21 08:28:14 +01:00
|
|
|
static float (*get_editbmesh_orco_verts(BMEditMesh *em))[3]
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 22:51:28 +02:00
|
|
|
{
|
2009-05-16 18:18:08 +02:00
|
|
|
BMIter iter;
|
|
|
|
BMVert *eve;
|
2012-12-21 08:28:14 +01:00
|
|
|
float (*orco)[3];
|
|
|
|
int i;
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 22:51:28 +02:00
|
|
|
|
|
|
|
/* these may not really be the orco's, but it's only for preview.
|
|
|
|
* could be solver better once, but isn't simple */
|
|
|
|
|
2018-01-14 22:14:20 +01:00
|
|
|
orco = MEM_malloc_arrayN(em->bm->totvert, sizeof(float) * 3, "BMEditMesh Orco");
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 22:51:28 +02:00
|
|
|
|
2012-12-21 08:28:14 +01:00
|
|
|
BM_ITER_MESH_INDEX (eve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
|
|
|
|
copy_v3_v3(orco[i], eve->co);
|
2011-11-06 16:39:20 +01:00
|
|
|
}
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 22:51:28 +02:00
|
|
|
|
|
|
|
return orco;
|
|
|
|
}
|
|
|
|
|
2009-05-23 05:24:15 +02:00
|
|
|
/* orco custom data layer */
|
2012-12-21 08:28:14 +01:00
|
|
|
static float (*get_orco_coords_dm(Object *ob, BMEditMesh *em, int layer, int *free))[3]
|
2010-03-30 13:49:07 +02:00
|
|
|
{
|
2012-05-12 21:18:02 +02:00
|
|
|
*free = 0;
|
2010-03-30 13:49:07 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (layer == CD_ORCO) {
|
2010-03-30 13:49:07 +02:00
|
|
|
/* get original coordinates */
|
2012-05-12 21:18:02 +02:00
|
|
|
*free = 1;
|
2010-03-30 13:49:07 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (em)
|
2012-12-21 08:28:14 +01:00
|
|
|
return get_editbmesh_orco_verts(em);
|
2010-03-30 13:49:07 +02:00
|
|
|
else
|
2012-12-21 08:28:14 +01:00
|
|
|
return BKE_mesh_orco_verts_get(ob);
|
2010-03-30 13:49:07 +02:00
|
|
|
}
|
2012-03-24 07:18:31 +01:00
|
|
|
else if (layer == CD_CLOTH_ORCO) {
|
2010-03-30 13:49:07 +02:00
|
|
|
/* apply shape key for cloth, this should really be solved
|
2012-03-09 19:28:30 +01:00
|
|
|
* by a more flexible customdata system, but not simple */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (!em) {
|
2010-03-30 13:49:07 +02:00
|
|
|
ClothModifierData *clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
|
2012-09-19 12:12:07 +02:00
|
|
|
KeyBlock *kb = BKE_keyblock_from_key(BKE_key_from_object(ob), clmd->sim_parms->shapekey_rest);
|
2011-12-05 00:13:28 +01:00
|
|
|
|
2015-04-13 07:54:37 +02:00
|
|
|
if (kb && kb->data) {
|
2011-12-05 00:13:28 +01:00
|
|
|
return kb->data;
|
2015-04-13 07:54:37 +02:00
|
|
|
}
|
2010-03-30 13:49:07 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-09-04 07:31:25 +02:00
|
|
|
static DerivedMesh *create_orco_dm(Object *ob, Mesh *me, BMEditMesh *em, int layer)
|
2007-12-05 13:40:54 +01:00
|
|
|
{
|
|
|
|
DerivedMesh *dm;
|
|
|
|
float (*orco)[3];
|
2010-03-30 13:49:07 +02:00
|
|
|
int free;
|
2007-12-05 13:40:54 +01:00
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
if (em) {
|
|
|
|
dm = CDDM_from_editbmesh(em, false, false);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
dm = CDDM_from_mesh(me);
|
|
|
|
}
|
2010-03-30 13:49:07 +02:00
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
orco = get_orco_coords_dm(ob, em, layer, &free);
|
2010-03-30 13:49:07 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (orco) {
|
2010-03-30 13:49:07 +02:00
|
|
|
CDDM_apply_vert_coords(dm, orco);
|
2012-03-24 07:18:31 +01:00
|
|
|
if (free) MEM_freeN(orco);
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 22:51:28 +02:00
|
|
|
}
|
|
|
|
|
2007-12-05 13:40:54 +01:00
|
|
|
return dm;
|
|
|
|
}
|
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
static Mesh *create_orco_mesh(Object *ob, Mesh *me, BMEditMesh *em, int layer)
|
|
|
|
{
|
|
|
|
Mesh *mesh;
|
|
|
|
float (*orco)[3];
|
|
|
|
int free;
|
|
|
|
|
|
|
|
if (em) {
|
|
|
|
mesh = BKE_bmesh_to_mesh_nomain(em->bm, &(struct BMeshToMeshParams){0});
|
|
|
|
}
|
|
|
|
else {
|
2018-05-20 08:52:10 +02:00
|
|
|
BKE_id_copy_ex(
|
|
|
|
NULL, &me->id, (ID **)&mesh,
|
2018-05-30 16:25:35 +02:00
|
|
|
(LIB_ID_CREATE_NO_MAIN |
|
|
|
|
LIB_ID_CREATE_NO_USER_REFCOUNT |
|
|
|
|
LIB_ID_CREATE_NO_DEG_TAG |
|
|
|
|
LIB_ID_COPY_CD_REFERENCE),
|
|
|
|
false);
|
2018-05-11 09:53:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
orco = get_orco_coords_dm(ob, em, layer, &free);
|
|
|
|
|
|
|
|
if (orco) {
|
|
|
|
BKE_mesh_apply_vert_coords(mesh, orco);
|
|
|
|
if (free) MEM_freeN(orco);
|
|
|
|
}
|
|
|
|
|
|
|
|
return mesh;
|
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
static void add_orco_dm(
|
|
|
|
Object *ob, BMEditMesh *em, DerivedMesh *dm,
|
|
|
|
DerivedMesh *orcodm, int layer)
|
2007-12-05 13:40:54 +01:00
|
|
|
{
|
|
|
|
float (*orco)[3], (*layerorco)[3];
|
2010-03-30 13:49:07 +02:00
|
|
|
int totvert, free;
|
2007-12-05 13:40:54 +01:00
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
totvert = dm->getNumVerts(dm);
|
2007-12-05 13:40:54 +01:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (orcodm) {
|
2018-01-14 22:14:20 +01:00
|
|
|
orco = MEM_calloc_arrayN(totvert, sizeof(float[3]), "dm orco");
|
2012-05-12 21:18:02 +02:00
|
|
|
free = 1;
|
2007-12-05 13:40:54 +01:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (orcodm->getNumVerts(orcodm) == totvert)
|
2007-12-05 13:40:54 +01:00
|
|
|
orcodm->getVertCos(orcodm, orco);
|
|
|
|
else
|
|
|
|
dm->getVertCos(dm, orco);
|
|
|
|
}
|
2018-04-25 09:53:32 +02:00
|
|
|
else {
|
|
|
|
/* TODO(sybren): totvert should potentially change here, as ob->data
|
|
|
|
* or em may have a different number of vertices than dm. */
|
2012-05-12 21:18:02 +02:00
|
|
|
orco = get_orco_coords_dm(ob, em, layer, &free);
|
2018-04-25 09:53:32 +02:00
|
|
|
}
|
2007-12-05 13:40:54 +01:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (orco) {
|
|
|
|
if (layer == CD_ORCO)
|
2012-05-05 23:28:12 +02:00
|
|
|
BKE_mesh_orco_verts_transform(ob->data, orco, totvert, 0);
|
2007-12-05 13:40:54 +01:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (!(layerorco = DM_get_vert_data_layer(dm, layer))) {
|
2010-03-30 13:49:07 +02:00
|
|
|
DM_add_vert_layer(dm, layer, CD_CALLOC, NULL);
|
|
|
|
layerorco = DM_get_vert_data_layer(dm, layer);
|
|
|
|
}
|
2007-12-05 13:40:54 +01:00
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
memcpy(layerorco, orco, sizeof(float) * 3 * totvert);
|
2012-03-24 07:18:31 +01:00
|
|
|
if (free) MEM_freeN(orco);
|
2007-12-05 13:40:54 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
static void add_orco_mesh(
|
|
|
|
Object *ob, BMEditMesh *em, Mesh *mesh,
|
|
|
|
Mesh *orco_mesh, int layer)
|
|
|
|
{
|
|
|
|
float (*orco)[3], (*layerorco)[3];
|
|
|
|
int totvert, free;
|
|
|
|
|
|
|
|
totvert = mesh->totvert;
|
|
|
|
|
|
|
|
if (orco_mesh) {
|
|
|
|
free = 1;
|
|
|
|
|
|
|
|
if (orco_mesh->totvert == totvert) {
|
|
|
|
orco = BKE_mesh_vertexCos_get(orco_mesh, NULL);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
orco = BKE_mesh_vertexCos_get(mesh, NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* TODO(sybren): totvert should potentially change here, as ob->data
|
|
|
|
* or em may have a different number of vertices than dm. */
|
|
|
|
orco = get_orco_coords_dm(ob, em, layer, &free);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (orco) {
|
|
|
|
if (layer == CD_ORCO) {
|
|
|
|
BKE_mesh_orco_verts_transform(ob->data, orco, totvert, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(layerorco = CustomData_get_layer(&mesh->vdata, layer))) {
|
|
|
|
CustomData_add_layer(&mesh->vdata, layer, CD_CALLOC, NULL, mesh->totvert);
|
|
|
|
BKE_mesh_update_customdata_pointers(mesh, false);
|
|
|
|
|
|
|
|
layerorco = CustomData_get_layer(&mesh->vdata, layer);
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(layerorco, orco, sizeof(float) * 3 * totvert);
|
|
|
|
if (free) MEM_freeN(orco);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-23 05:24:15 +02:00
|
|
|
/* weight paint colors */
|
|
|
|
|
|
|
|
/* Something of a hack, at the moment deal with weightpaint
|
|
|
|
* by tucking into colors during modifier eval, only in
|
|
|
|
* wpaint mode. Works ok but need to make sure recalc
|
|
|
|
* happens on enter/exit wpaint.
|
|
|
|
*/
|
|
|
|
|
2011-11-26 04:13:54 +01:00
|
|
|
void weight_to_rgb(float r_rgb[3], const float weight)
|
2009-05-23 05:24:15 +02:00
|
|
|
{
|
2012-05-12 21:18:02 +02:00
|
|
|
const float blend = ((weight / 2.0f) + 0.5f);
|
2011-11-26 04:13:54 +01:00
|
|
|
|
2012-07-07 01:56:59 +02:00
|
|
|
if (weight <= 0.25f) { /* blue->cyan */
|
2012-05-12 21:18:02 +02:00
|
|
|
r_rgb[0] = 0.0f;
|
|
|
|
r_rgb[1] = blend * weight * 4.0f;
|
|
|
|
r_rgb[2] = blend;
|
2009-05-23 05:24:15 +02:00
|
|
|
}
|
2012-07-07 01:56:59 +02:00
|
|
|
else if (weight <= 0.50f) { /* cyan->green */
|
2012-05-12 21:18:02 +02:00
|
|
|
r_rgb[0] = 0.0f;
|
|
|
|
r_rgb[1] = blend;
|
|
|
|
r_rgb[2] = blend * (1.0f - ((weight - 0.25f) * 4.0f));
|
2009-05-23 05:24:15 +02:00
|
|
|
}
|
2012-07-07 01:56:59 +02:00
|
|
|
else if (weight <= 0.75f) { /* green->yellow */
|
2012-05-12 21:18:02 +02:00
|
|
|
r_rgb[0] = blend * ((weight - 0.50f) * 4.0f);
|
|
|
|
r_rgb[1] = blend;
|
|
|
|
r_rgb[2] = 0.0f;
|
2009-05-23 05:24:15 +02:00
|
|
|
}
|
2012-07-07 01:56:59 +02:00
|
|
|
else if (weight <= 1.0f) { /* yellow->red */
|
2012-05-12 21:18:02 +02:00
|
|
|
r_rgb[0] = blend;
|
|
|
|
r_rgb[1] = blend * (1.0f - ((weight - 0.75f) * 4.0f));
|
|
|
|
r_rgb[2] = 0.0f;
|
2009-05-23 05:24:15 +02:00
|
|
|
}
|
2011-12-07 08:13:33 +01:00
|
|
|
else {
|
|
|
|
/* exceptional value, unclamped or nan,
|
|
|
|
* avoid uninitialized memory use */
|
2012-05-12 21:18:02 +02:00
|
|
|
r_rgb[0] = 1.0f;
|
|
|
|
r_rgb[1] = 0.0f;
|
|
|
|
r_rgb[2] = 1.0f;
|
2011-12-07 08:13:33 +01:00
|
|
|
}
|
2009-05-23 05:24:15 +02:00
|
|
|
}
|
|
|
|
|
2011-09-14 04:04:26 +02:00
|
|
|
/* draw_flag's for calc_weightpaint_vert_color */
|
|
|
|
enum {
|
2013-02-22 05:09:04 +01:00
|
|
|
/* only one of these should be set, keep first (for easy bit-shifting) */
|
|
|
|
CALC_WP_GROUP_USER_ACTIVE = (1 << 1),
|
|
|
|
CALC_WP_GROUP_USER_ALL = (1 << 2),
|
|
|
|
|
|
|
|
CALC_WP_MULTIPAINT = (1 << 3),
|
2016-01-20 22:03:15 +01:00
|
|
|
CALC_WP_AUTO_NORMALIZE = (1 << 4),
|
|
|
|
CALC_WP_MIRROR_X = (1 << 5),
|
2011-09-14 04:04:26 +02:00
|
|
|
};
|
|
|
|
|
2013-03-05 21:30:38 +01:00
|
|
|
typedef struct DMWeightColorInfo {
|
2013-03-06 03:57:31 +01:00
|
|
|
const ColorBand *coba;
|
|
|
|
const char *alert_color;
|
2013-03-05 21:30:38 +01:00
|
|
|
} DMWeightColorInfo;
|
|
|
|
|
|
|
|
|
2016-01-20 22:03:15 +01:00
|
|
|
static int dm_drawflag_calc(const ToolSettings *ts, const Mesh *me)
|
2013-04-13 22:20:21 +02:00
|
|
|
{
|
2016-01-18 20:00:56 +01:00
|
|
|
return ((ts->multipaint ? CALC_WP_MULTIPAINT : 0) |
|
2016-01-28 06:30:50 +01:00
|
|
|
/* CALC_WP_GROUP_USER_ACTIVE or CALC_WP_GROUP_USER_ALL */
|
2016-01-18 20:00:56 +01:00
|
|
|
(1 << ts->weightuser) |
|
2016-01-20 22:03:15 +01:00
|
|
|
(ts->auto_normalize ? CALC_WP_AUTO_NORMALIZE : 0) |
|
|
|
|
((me->editflag & ME_EDIT_MIRROR_X) ? CALC_WP_MIRROR_X : 0));
|
2013-04-13 22:20:21 +02:00
|
|
|
}
|
|
|
|
|
2013-03-05 21:30:38 +01:00
|
|
|
static void weightpaint_color(unsigned char r_col[4], DMWeightColorInfo *dm_wcinfo, const float input)
|
2011-12-18 13:54:50 +01:00
|
|
|
{
|
|
|
|
float colf[4];
|
|
|
|
|
2013-03-10 20:10:20 +01:00
|
|
|
if (dm_wcinfo && dm_wcinfo->coba) {
|
2017-12-07 05:52:59 +01:00
|
|
|
BKE_colorband_evaluate(dm_wcinfo->coba, input, colf);
|
2012-03-18 00:26:25 +01:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
weight_to_rgb(colf, input);
|
|
|
|
}
|
2011-12-18 13:54:50 +01:00
|
|
|
|
2012-03-18 00:37:14 +01:00
|
|
|
/* don't use rgb_float_to_uchar() here because
|
|
|
|
* the resulting float doesn't need 0-1 clamp check */
|
|
|
|
r_col[0] = (unsigned char)(colf[0] * 255.0f);
|
|
|
|
r_col[1] = (unsigned char)(colf[1] * 255.0f);
|
|
|
|
r_col[2] = (unsigned char)(colf[2] * 255.0f);
|
|
|
|
r_col[3] = 255;
|
2011-12-18 13:54:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-12-07 19:22:16 +01:00
|
|
|
static void calc_weightpaint_vert_color(
|
2011-12-18 13:54:50 +01:00
|
|
|
unsigned char r_col[4],
|
2014-07-12 01:07:51 +02:00
|
|
|
const MDeformVert *dv,
|
2013-03-06 03:57:31 +01:00
|
|
|
DMWeightColorInfo *dm_wcinfo,
|
2011-12-18 13:54:50 +01:00
|
|
|
const int defbase_tot, const int defbase_act,
|
2013-05-15 17:52:48 +02:00
|
|
|
const bool *defbase_sel, const int defbase_sel_tot,
|
2012-09-05 05:45:32 +02:00
|
|
|
const int draw_flag)
|
2009-05-23 05:24:15 +02:00
|
|
|
{
|
2011-12-07 08:13:33 +01:00
|
|
|
float input = 0.0f;
|
2011-09-18 19:10:28 +02:00
|
|
|
|
2013-03-06 03:57:31 +01:00
|
|
|
bool show_alert_color = false;
|
2009-04-02 16:38:40 +02:00
|
|
|
|
2012-09-05 05:45:32 +02:00
|
|
|
if ((defbase_sel_tot > 1) && (draw_flag & CALC_WP_MULTIPAINT)) {
|
2013-03-06 03:57:31 +01:00
|
|
|
/* Multi-Paint feature */
|
2016-01-19 16:57:52 +01:00
|
|
|
input = BKE_defvert_multipaint_collective_weight(
|
|
|
|
dv, defbase_tot, defbase_sel, defbase_sel_tot, (draw_flag & CALC_WP_AUTO_NORMALIZE) != 0);
|
2009-05-23 05:24:15 +02:00
|
|
|
|
2011-12-18 13:54:50 +01:00
|
|
|
/* make it black if the selected groups have no weight on a vertex */
|
2016-01-19 16:57:52 +01:00
|
|
|
if (input == 0.0f) {
|
2013-03-06 03:57:31 +01:00
|
|
|
show_alert_color = true;
|
2011-09-14 04:04:26 +02:00
|
|
|
}
|
2011-06-08 21:05:17 +02:00
|
|
|
}
|
2011-12-18 13:54:50 +01:00
|
|
|
else {
|
|
|
|
/* default, non tricky behavior */
|
2012-05-12 21:18:02 +02:00
|
|
|
input = defvert_find_weight(dv, defbase_act);
|
2013-02-22 05:09:04 +01:00
|
|
|
|
|
|
|
if (draw_flag & CALC_WP_GROUP_USER_ACTIVE) {
|
|
|
|
if (input == 0.0f) {
|
2013-03-06 03:57:31 +01:00
|
|
|
show_alert_color = true;
|
2013-02-22 05:09:04 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (draw_flag & CALC_WP_GROUP_USER_ALL) {
|
|
|
|
if (input == 0.0f) {
|
2013-03-06 03:57:31 +01:00
|
|
|
show_alert_color = defvert_is_weight_zero(dv, defbase_tot);
|
2013-02-22 05:09:04 +01:00
|
|
|
}
|
|
|
|
}
|
2011-12-18 13:54:50 +01:00
|
|
|
}
|
|
|
|
|
2013-03-06 03:57:31 +01:00
|
|
|
if (show_alert_color == false) {
|
2011-12-07 08:13:33 +01:00
|
|
|
CLAMP(input, 0.0f, 1.0f);
|
2013-03-05 21:30:38 +01:00
|
|
|
weightpaint_color(r_col, dm_wcinfo, input);
|
2011-12-07 08:13:33 +01:00
|
|
|
}
|
2013-03-06 03:57:31 +01:00
|
|
|
else {
|
|
|
|
copy_v3_v3_char((char *)r_col, dm_wcinfo->alert_color);
|
|
|
|
r_col[3] = 255;
|
|
|
|
}
|
2009-05-23 05:24:15 +02:00
|
|
|
}
|
|
|
|
|
2013-03-16 15:33:32 +01:00
|
|
|
static DMWeightColorInfo G_dm_wcinfo;
|
2013-03-06 03:57:31 +01:00
|
|
|
|
|
|
|
void vDM_ColorBand_store(const ColorBand *coba, const char alert_color[4])
|
2009-05-23 05:24:15 +02:00
|
|
|
{
|
2013-03-16 15:33:32 +01:00
|
|
|
G_dm_wcinfo.coba = coba;
|
|
|
|
G_dm_wcinfo.alert_color = alert_color;
|
2009-05-23 05:24:15 +02:00
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
/**
|
|
|
|
* return an array of vertex weight colors, caller must free.
|
2011-12-20 03:04:35 +01:00
|
|
|
*
|
2015-07-02 08:20:22 +02:00
|
|
|
* \note that we could save some memory and allocate RGB only but then we'd need to
|
2011-12-20 03:04:35 +01:00
|
|
|
* re-arrange the colors when copying to the face since MCol has odd ordering,
|
2015-07-02 08:20:22 +02:00
|
|
|
* so leave this as is - campbell
|
|
|
|
*/
|
|
|
|
static void calc_weightpaint_vert_array(
|
|
|
|
Object *ob, DerivedMesh *dm, int const draw_flag, DMWeightColorInfo *dm_wcinfo,
|
|
|
|
unsigned char (*r_wtcol_v)[4])
|
2009-05-23 05:24:15 +02:00
|
|
|
{
|
2016-06-22 13:20:09 +02:00
|
|
|
BMEditMesh *em = (dm->type == DM_TYPE_EDITBMESH) ? BKE_editmesh_from_object(ob) : NULL;
|
|
|
|
const int numVerts = dm->getNumVerts(dm);
|
2011-12-18 13:54:50 +01:00
|
|
|
|
2016-06-22 13:20:09 +02:00
|
|
|
if ((ob->actdef != 0) &&
|
|
|
|
(CustomData_has_layer(em ? &em->bm->vdata : &dm->vertData, CD_MDEFORMVERT)))
|
|
|
|
{
|
2013-04-13 22:20:21 +02:00
|
|
|
unsigned char (*wc)[4] = r_wtcol_v;
|
2011-12-19 23:55:04 +01:00
|
|
|
unsigned int i;
|
2011-12-18 13:54:50 +01:00
|
|
|
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
/* variables for multipaint */
|
2014-11-16 13:57:58 +01:00
|
|
|
const int defbase_tot = BLI_listbase_count(&ob->defbase);
|
2012-05-12 21:18:02 +02:00
|
|
|
const int defbase_act = ob->actdef - 1;
|
2012-09-05 05:45:32 +02:00
|
|
|
|
|
|
|
int defbase_sel_tot = 0;
|
2013-05-15 17:52:48 +02:00
|
|
|
bool *defbase_sel = NULL;
|
2012-09-05 05:45:32 +02:00
|
|
|
|
|
|
|
if (draw_flag & CALC_WP_MULTIPAINT) {
|
2014-11-18 23:52:17 +01:00
|
|
|
defbase_sel = BKE_object_defgroup_selected_get(ob, defbase_tot, &defbase_sel_tot);
|
2016-01-20 22:03:15 +01:00
|
|
|
|
|
|
|
if (defbase_sel_tot > 1 && (draw_flag & CALC_WP_MIRROR_X)) {
|
|
|
|
BKE_object_defgroup_mirror_selection(ob, defbase_tot, defbase_sel, defbase_sel, &defbase_sel_tot);
|
|
|
|
}
|
2012-09-05 05:45:32 +02:00
|
|
|
}
|
2011-12-18 13:54:50 +01:00
|
|
|
|
2016-06-22 13:20:09 +02:00
|
|
|
/* editmesh won't have deform verts unless modifiers require it,
|
|
|
|
* avoid having to create an array of deform-verts only for drawing
|
|
|
|
* by reading from the bmesh directly. */
|
|
|
|
if (em) {
|
|
|
|
BMIter iter;
|
|
|
|
BMVert *eve;
|
|
|
|
const int cd_dvert_offset = CustomData_get_offset(&em->bm->vdata, CD_MDEFORMVERT);
|
|
|
|
BLI_assert(cd_dvert_offset != -1);
|
|
|
|
|
|
|
|
BM_ITER_MESH_INDEX (eve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
|
|
|
|
const MDeformVert *dv = BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset);
|
|
|
|
calc_weightpaint_vert_color(
|
|
|
|
(unsigned char *)wc, dv, dm_wcinfo,
|
|
|
|
defbase_tot, defbase_act, defbase_sel, defbase_sel_tot, draw_flag);
|
|
|
|
wc++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
const MDeformVert *dv = DM_get_vert_data_layer(dm, CD_MDEFORMVERT);
|
|
|
|
for (i = numVerts; i != 0; i--, wc++, dv++) {
|
|
|
|
calc_weightpaint_vert_color(
|
|
|
|
(unsigned char *)wc, dv, dm_wcinfo,
|
|
|
|
defbase_tot, defbase_act, defbase_sel, defbase_sel_tot, draw_flag);
|
|
|
|
}
|
2011-12-18 13:54:50 +01:00
|
|
|
}
|
|
|
|
|
2012-09-05 05:45:32 +02:00
|
|
|
if (defbase_sel) {
|
|
|
|
MEM_freeN(defbase_sel);
|
|
|
|
}
|
2011-12-18 13:54:50 +01:00
|
|
|
}
|
|
|
|
else {
|
2014-06-19 14:34:52 +02:00
|
|
|
unsigned char col[4];
|
2015-11-03 20:19:03 +01:00
|
|
|
if ((ob->actdef == 0) && !BLI_listbase_is_empty(&ob->defbase)) {
|
2016-01-19 18:30:50 +01:00
|
|
|
/* color-code for missing data (full brightness isn't easy on the eye). */
|
|
|
|
ARRAY_SET_ITEMS(col, 0xa0, 0, 0xa0, 0xff);
|
2015-11-03 20:19:03 +01:00
|
|
|
}
|
|
|
|
else if (draw_flag & (CALC_WP_GROUP_USER_ACTIVE | CALC_WP_GROUP_USER_ALL)) {
|
2014-06-19 14:34:52 +02:00
|
|
|
copy_v3_v3_char((char *)col, dm_wcinfo->alert_color);
|
|
|
|
col[3] = 255;
|
2013-02-22 05:09:04 +01:00
|
|
|
}
|
|
|
|
else {
|
2014-06-19 14:34:52 +02:00
|
|
|
weightpaint_color(col, dm_wcinfo, 0.0f);
|
2013-02-22 05:09:04 +01:00
|
|
|
}
|
2015-05-05 09:08:29 +02:00
|
|
|
copy_vn_i((int *)r_wtcol_v, numVerts, *((int *)col));
|
2011-12-19 23:55:04 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
static void calc_weightpaint_vert_array_mesh(
|
|
|
|
Object *ob, Mesh *mesh, int const draw_flag, DMWeightColorInfo *dm_wcinfo,
|
|
|
|
unsigned char (*r_wtcol_v)[4])
|
|
|
|
{
|
|
|
|
BMEditMesh *em = BKE_editmesh_from_object(ob);
|
|
|
|
const int numVerts = mesh->totvert;
|
|
|
|
|
|
|
|
if ((ob->actdef != 0) &&
|
|
|
|
(CustomData_has_layer(em ? &em->bm->vdata : &mesh->vdata, CD_MDEFORMVERT)))
|
|
|
|
{
|
|
|
|
unsigned char (*wc)[4] = r_wtcol_v;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
/* variables for multipaint */
|
|
|
|
const int defbase_tot = BLI_listbase_count(&ob->defbase);
|
|
|
|
const int defbase_act = ob->actdef - 1;
|
|
|
|
|
|
|
|
int defbase_sel_tot = 0;
|
|
|
|
bool *defbase_sel = NULL;
|
|
|
|
|
|
|
|
if (draw_flag & CALC_WP_MULTIPAINT) {
|
|
|
|
defbase_sel = BKE_object_defgroup_selected_get(ob, defbase_tot, &defbase_sel_tot);
|
|
|
|
|
|
|
|
if (defbase_sel_tot > 1 && (draw_flag & CALC_WP_MIRROR_X)) {
|
|
|
|
BKE_object_defgroup_mirror_selection(ob, defbase_tot, defbase_sel, defbase_sel, &defbase_sel_tot);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* editmesh won't have deform verts unless modifiers require it,
|
|
|
|
* avoid having to create an array of deform-verts only for drawing
|
|
|
|
* by reading from the bmesh directly. */
|
|
|
|
if (em) {
|
|
|
|
BMIter iter;
|
|
|
|
BMVert *eve;
|
|
|
|
const int cd_dvert_offset = CustomData_get_offset(&em->bm->vdata, CD_MDEFORMVERT);
|
|
|
|
BLI_assert(cd_dvert_offset != -1);
|
|
|
|
|
|
|
|
BM_ITER_MESH_INDEX (eve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
|
|
|
|
const MDeformVert *dv = BM_ELEM_CD_GET_VOID_P(eve, cd_dvert_offset);
|
|
|
|
calc_weightpaint_vert_color(
|
|
|
|
(unsigned char *)wc, dv, dm_wcinfo,
|
|
|
|
defbase_tot, defbase_act, defbase_sel, defbase_sel_tot, draw_flag);
|
|
|
|
wc++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
const MDeformVert *dv = CustomData_get_layer(&mesh->vdata, CD_MDEFORMVERT);
|
|
|
|
for (i = numVerts; i != 0; i--, wc++, dv++) {
|
|
|
|
calc_weightpaint_vert_color(
|
|
|
|
(unsigned char *)wc, dv, dm_wcinfo,
|
|
|
|
defbase_tot, defbase_act, defbase_sel, defbase_sel_tot, draw_flag);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (defbase_sel) {
|
|
|
|
MEM_freeN(defbase_sel);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
unsigned char col[4];
|
|
|
|
if ((ob->actdef == 0) && !BLI_listbase_is_empty(&ob->defbase)) {
|
|
|
|
/* color-code for missing data (full brightness isn't easy on the eye). */
|
|
|
|
ARRAY_SET_ITEMS(col, 0xa0, 0, 0xa0, 0xff);
|
|
|
|
}
|
|
|
|
else if (draw_flag & (CALC_WP_GROUP_USER_ACTIVE | CALC_WP_GROUP_USER_ALL)) {
|
|
|
|
copy_v3_v3_char((char *)col, dm_wcinfo->alert_color);
|
|
|
|
col[3] = 255;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
weightpaint_color(col, dm_wcinfo, 0.0f);
|
|
|
|
}
|
|
|
|
copy_vn_i((int *)r_wtcol_v, numVerts, *((int *)col));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
/** return an array of vertex weight colors from given weights, caller must free.
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
*
|
2015-07-02 08:20:22 +02:00
|
|
|
* \note that we could save some memory and allocate RGB only but then we'd need to
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
* re-arrange the colors when copying to the face since MCol has odd ordering,
|
2015-07-02 08:20:22 +02:00
|
|
|
* so leave this as is - campbell
|
|
|
|
*/
|
|
|
|
static void calc_colors_from_weights_array(
|
|
|
|
const int num, const float *weights,
|
|
|
|
unsigned char (*r_wtcol_v)[4])
|
2011-12-19 23:55:04 +01:00
|
|
|
{
|
2013-04-13 22:20:21 +02:00
|
|
|
unsigned char (*wc)[4] = r_wtcol_v;
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
int i;
|
2011-12-19 23:55:04 +01:00
|
|
|
|
2013-04-13 22:20:21 +02:00
|
|
|
for (i = 0; i < num; i++, wc++, weights++) {
|
|
|
|
weightpaint_color((unsigned char *)wc, NULL, *weights);
|
|
|
|
}
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
void DM_update_weight_mcol(
|
|
|
|
Object *ob, DerivedMesh *dm, int const draw_flag,
|
|
|
|
float *weights, int num, const int *indices)
|
2011-12-19 23:55:04 +01:00
|
|
|
{
|
2013-04-16 07:59:48 +02:00
|
|
|
BMEditMesh *em = (dm->type == DM_TYPE_EDITBMESH) ? BKE_editmesh_from_object(ob) : NULL;
|
2013-04-13 22:20:21 +02:00
|
|
|
unsigned char (*wtcol_v)[4];
|
2012-01-22 21:05:26 +01:00
|
|
|
int numVerts = dm->getNumVerts(dm);
|
2013-04-15 10:43:17 +02:00
|
|
|
int i;
|
2011-12-19 23:55:04 +01:00
|
|
|
|
2013-04-13 22:20:21 +02:00
|
|
|
if (em) {
|
2013-04-18 19:09:56 +02:00
|
|
|
BKE_editmesh_color_ensure(em, BM_VERT);
|
|
|
|
wtcol_v = em->derivedVertColor;
|
2013-04-13 22:20:21 +02:00
|
|
|
}
|
|
|
|
else {
|
2018-01-14 22:14:20 +01:00
|
|
|
wtcol_v = MEM_malloc_arrayN(numVerts, sizeof(*wtcol_v), __func__);
|
2013-04-13 22:20:21 +02:00
|
|
|
}
|
|
|
|
|
2012-12-03 15:12:40 +01:00
|
|
|
/* Weights are given by caller. */
|
|
|
|
if (weights) {
|
|
|
|
float *w = weights;
|
|
|
|
/* If indices is not NULL, it means we do not have weights for all vertices,
|
|
|
|
* so we must create them (and set them to zero)... */
|
|
|
|
if (indices) {
|
2018-01-14 22:14:20 +01:00
|
|
|
w = MEM_calloc_arrayN(numVerts, sizeof(float), "Temp weight array DM_update_weight_mcol");
|
2012-12-03 15:12:40 +01:00
|
|
|
i = num;
|
|
|
|
while (i--)
|
|
|
|
w[indices[i]] = weights[i];
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
}
|
2011-12-20 02:33:14 +01:00
|
|
|
|
2012-12-03 15:12:40 +01:00
|
|
|
/* Convert float weights to colors. */
|
2013-04-13 22:20:21 +02:00
|
|
|
calc_colors_from_weights_array(numVerts, w, wtcol_v);
|
2011-12-20 02:33:14 +01:00
|
|
|
|
2012-12-03 15:12:40 +01:00
|
|
|
if (indices)
|
|
|
|
MEM_freeN(w);
|
|
|
|
}
|
2013-03-16 15:33:32 +01:00
|
|
|
else {
|
|
|
|
/* No weights given, take them from active vgroup(s). */
|
2013-04-13 22:20:21 +02:00
|
|
|
calc_weightpaint_vert_array(ob, dm, draw_flag, &G_dm_wcinfo, wtcol_v);
|
2013-03-16 15:33:32 +01:00
|
|
|
}
|
2012-12-03 15:12:40 +01:00
|
|
|
|
2013-04-13 22:20:21 +02:00
|
|
|
if (dm->type == DM_TYPE_EDITBMESH) {
|
2013-11-05 05:23:46 +01:00
|
|
|
/* editmesh draw function checks specifically for this */
|
2012-12-03 15:12:40 +01:00
|
|
|
}
|
|
|
|
else {
|
2013-05-02 03:49:10 +02:00
|
|
|
const int dm_totpoly = dm->getNumPolys(dm);
|
|
|
|
const int dm_totloop = dm->getNumLoops(dm);
|
2013-04-15 10:43:17 +02:00
|
|
|
unsigned char(*wtcol_l)[4] = CustomData_get_layer(dm->getLoopDataLayout(dm), CD_PREVIEW_MLOOPCOL);
|
|
|
|
MLoop *mloop = dm->getLoopArray(dm), *ml;
|
|
|
|
MPoly *mp = dm->getPolyArray(dm);
|
2013-05-03 10:37:18 +02:00
|
|
|
int l_index;
|
2013-04-15 10:43:17 +02:00
|
|
|
int j;
|
|
|
|
|
2016-01-28 06:30:50 +01:00
|
|
|
/* now add to loops, so the data can be passed through the modifier stack
|
|
|
|
* If no CD_PREVIEW_MLOOPCOL existed yet, we have to add a new one! */
|
2013-04-13 22:20:21 +02:00
|
|
|
if (!wtcol_l) {
|
2018-01-14 22:14:20 +01:00
|
|
|
wtcol_l = MEM_malloc_arrayN(dm_totloop, sizeof(*wtcol_l), __func__);
|
2013-05-03 10:37:18 +02:00
|
|
|
CustomData_add_layer(&dm->loopData, CD_PREVIEW_MLOOPCOL, CD_ASSIGN, wtcol_l, dm_totloop);
|
2013-04-13 22:20:21 +02:00
|
|
|
}
|
2011-06-14 05:16:08 +02:00
|
|
|
|
2013-05-03 10:37:18 +02:00
|
|
|
l_index = 0;
|
2013-05-02 03:49:10 +02:00
|
|
|
for (i = 0; i < dm_totpoly; i++, mp++) {
|
|
|
|
ml = mloop + mp->loopstart;
|
|
|
|
|
2013-05-03 10:37:18 +02:00
|
|
|
for (j = 0; j < mp->totloop; j++, ml++, l_index++) {
|
2015-10-11 01:44:47 +02:00
|
|
|
copy_v4_v4_uchar(&wtcol_l[l_index][0],
|
|
|
|
&wtcol_v[ml->v][0]);
|
2012-01-22 21:05:26 +01:00
|
|
|
}
|
2009-08-31 17:57:13 +02:00
|
|
|
}
|
2013-04-13 22:20:21 +02:00
|
|
|
MEM_freeN(wtcol_v);
|
Fix [#30234] Various problems with CD layers and tesselation, related to modifiers stack.
Should also fix [#30266], [#29451], and partly [#30316].
Here are the changes made by this commit:
* It adds a "dirty" flag to DerivedMesh struct (for now, only DM_DIRTY_TESS_CDLAYERS, but more might be added as needed).
* It adds a new func, DM_update_tessface_data, which assumes tessfaces themselves are valid, but updates tessellated customdata from their poly/loop counter parts.
* At end of modstack, when valid tessellated faces are present in finaldm , but the cdlayers dirty flag is set, call that function (instead of recomputing the whole tessellation).
* Edits to the codes concerned (UVProject, DynamicPaint, and Subsurf modifiers).
* Also add to subsurf dm generation code the creation of a CD_POLYINDEX layer (mandatory for DM_update_tessface_data to work well, and imho all tessellated dm should have one).
Note: some pieces of old code are just #if 0’ed, will clean them later.
2012-03-18 23:06:57 +01:00
|
|
|
|
2013-04-13 22:20:21 +02:00
|
|
|
dm->dirty |= DM_DIRTY_TESS_CDLAYERS;
|
|
|
|
}
|
2009-05-23 05:24:15 +02:00
|
|
|
}
|
|
|
|
|
2018-05-16 12:44:49 +02:00
|
|
|
static void mesh_update_weight_mcol(
|
2018-05-11 09:53:52 +02:00
|
|
|
Object *ob, Mesh *mesh, int const draw_flag,
|
|
|
|
float *weights, int num, const int *indices)
|
|
|
|
{
|
|
|
|
BMEditMesh *em = BKE_editmesh_from_object(ob);
|
|
|
|
unsigned char (*wtcol_v)[4];
|
|
|
|
int numVerts = mesh->totvert;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (em) {
|
|
|
|
BKE_editmesh_color_ensure(em, BM_VERT);
|
|
|
|
wtcol_v = em->derivedVertColor;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
wtcol_v = MEM_malloc_arrayN(numVerts, sizeof(*wtcol_v), __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Weights are given by caller. */
|
|
|
|
if (weights) {
|
|
|
|
float *w = weights;
|
|
|
|
/* If indices is not NULL, it means we do not have weights for all vertices,
|
|
|
|
* so we must create them (and set them to zero)... */
|
|
|
|
if (indices) {
|
|
|
|
w = MEM_calloc_arrayN(numVerts, sizeof(float), "Temp weight array DM_update_weight_mcol");
|
|
|
|
i = num;
|
|
|
|
while (i--)
|
|
|
|
w[indices[i]] = weights[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert float weights to colors. */
|
|
|
|
calc_colors_from_weights_array(numVerts, w, wtcol_v);
|
|
|
|
|
|
|
|
if (indices)
|
|
|
|
MEM_freeN(w);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* No weights given, take them from active vgroup(s). */
|
|
|
|
calc_weightpaint_vert_array_mesh(ob, mesh, draw_flag, &G_dm_wcinfo, wtcol_v);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (em) {
|
|
|
|
/* editmesh draw function checks specifically for this */
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
const int totpoly = mesh->totpoly;
|
|
|
|
const int totloop = mesh->totloop;
|
|
|
|
unsigned char(*wtcol_l)[4] = CustomData_get_layer(&mesh->ldata, CD_PREVIEW_MLOOPCOL);
|
|
|
|
MLoop *mloop = mesh->mloop, *ml;
|
|
|
|
MPoly *mp = mesh->mpoly;
|
|
|
|
int l_index;
|
|
|
|
int j;
|
|
|
|
|
|
|
|
/* now add to loops, so the data can be passed through the modifier stack
|
|
|
|
* If no CD_PREVIEW_MLOOPCOL existed yet, we have to add a new one! */
|
|
|
|
if (!wtcol_l) {
|
|
|
|
wtcol_l = MEM_malloc_arrayN(totloop, sizeof(*wtcol_l), __func__);
|
|
|
|
CustomData_add_layer(&mesh->ldata, CD_PREVIEW_MLOOPCOL, CD_ASSIGN, wtcol_l, totloop);
|
|
|
|
}
|
|
|
|
|
|
|
|
l_index = 0;
|
|
|
|
for (i = 0; i < totpoly; i++, mp++) {
|
|
|
|
ml = mloop + mp->loopstart;
|
|
|
|
|
|
|
|
for (j = 0; j < mp->totloop; j++, ml++, l_index++) {
|
|
|
|
copy_v4_v4_uchar(&wtcol_l[l_index][0],
|
|
|
|
&wtcol_v[ml->v][0]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
MEM_freeN(wtcol_v);
|
|
|
|
|
2018-05-22 17:53:18 +02:00
|
|
|
BKE_mesh_tessface_clear(mesh);
|
2018-05-11 09:53:52 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-21 12:10:43 +01:00
|
|
|
static void DM_update_statvis_color(const Scene *scene, Object *ob, DerivedMesh *dm)
|
2013-04-17 11:27:23 +02:00
|
|
|
{
|
|
|
|
BMEditMesh *em = BKE_editmesh_from_object(ob);
|
|
|
|
|
2013-04-18 19:09:56 +02:00
|
|
|
BKE_editmesh_statvis_calc(em, dm, &scene->toolsettings->statvis);
|
2013-04-17 11:27:23 +02:00
|
|
|
}
|
2011-04-15 07:20:18 +02:00
|
|
|
|
|
|
|
static void shapekey_layers_to_keyblocks(DerivedMesh *dm, Mesh *me, int actshape_uid)
|
|
|
|
{
|
|
|
|
KeyBlock *kb;
|
|
|
|
int i, j, tot;
|
|
|
|
|
|
|
|
if (!me->key)
|
2012-10-21 07:46:41 +02:00
|
|
|
return;
|
2011-04-15 07:20:18 +02:00
|
|
|
|
|
|
|
tot = CustomData_number_of_layers(&dm->vertData, CD_SHAPEKEY);
|
2012-05-12 21:18:02 +02:00
|
|
|
for (i = 0; i < tot; i++) {
|
2011-04-15 07:20:18 +02:00
|
|
|
CustomDataLayer *layer = &dm->vertData.layers[CustomData_get_layer_index_n(&dm->vertData, CD_SHAPEKEY, i)];
|
|
|
|
float (*cos)[3], (*kbcos)[3];
|
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
for (kb = me->key->block.first; kb; kb = kb->next) {
|
2011-04-15 07:20:18 +02:00
|
|
|
if (kb->uid == layer->uid)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!kb) {
|
2012-09-19 12:12:07 +02:00
|
|
|
kb = BKE_keyblock_add(me->key, layer->name);
|
2011-04-15 07:20:18 +02:00
|
|
|
kb->uid = layer->uid;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (kb->data)
|
|
|
|
MEM_freeN(kb->data);
|
|
|
|
|
|
|
|
cos = CustomData_get_layer_n(&dm->vertData, CD_SHAPEKEY, i);
|
|
|
|
kb->totelem = dm->numVertData;
|
|
|
|
|
2018-02-01 15:53:49 +01:00
|
|
|
kb->data = kbcos = MEM_malloc_arrayN(kb->totelem, 3 * sizeof(float), "kbcos DerivedMesh.c");
|
2011-04-15 07:20:18 +02:00
|
|
|
if (kb->uid == actshape_uid) {
|
|
|
|
MVert *mvert = dm->getVertArray(dm);
|
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
for (j = 0; j < dm->numVertData; j++, kbcos++, mvert++) {
|
2011-04-15 07:20:18 +02:00
|
|
|
copy_v3_v3(*kbcos, mvert->co);
|
|
|
|
}
|
2012-03-24 07:18:31 +01:00
|
|
|
}
|
|
|
|
else {
|
2012-05-12 21:18:02 +02:00
|
|
|
for (j = 0; j < kb->totelem; j++, cos++, kbcos++) {
|
2011-04-15 07:20:18 +02:00
|
|
|
copy_v3_v3(*kbcos, *cos);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
for (kb = me->key->block.first; kb; kb = kb->next) {
|
2011-04-15 07:20:18 +02:00
|
|
|
if (kb->totelem != dm->numVertData) {
|
|
|
|
if (kb->data)
|
|
|
|
MEM_freeN(kb->data);
|
|
|
|
|
|
|
|
kb->totelem = dm->numVertData;
|
2018-01-14 22:14:20 +01:00
|
|
|
kb->data = MEM_calloc_arrayN(kb->totelem, 3 * sizeof(float), "kb->data derivedmesh.c");
|
2012-04-12 16:36:57 +02:00
|
|
|
fprintf(stderr, "%s: lost a shapekey layer: '%s'! (bmesh internal error)\n", __func__, kb->name);
|
2011-04-15 07:20:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-09 16:32:55 +02:00
|
|
|
static void add_shapekey_layers(DerivedMesh *dm, Mesh *me, Object *UNUSED(ob))
|
2011-04-15 07:20:18 +02:00
|
|
|
{
|
|
|
|
KeyBlock *kb;
|
|
|
|
Key *key = me->key;
|
2012-01-30 02:18:49 +01:00
|
|
|
int i;
|
|
|
|
|
2011-04-15 07:20:18 +02:00
|
|
|
if (!me->key)
|
|
|
|
return;
|
2012-01-30 02:18:49 +01:00
|
|
|
|
|
|
|
/* ensure we can use mesh vertex count for derived mesh custom data */
|
|
|
|
if (me->totvert != dm->getNumVerts(dm)) {
|
|
|
|
fprintf(stderr,
|
|
|
|
"%s: vertex size mismatch (mesh/dm) '%s' (%d != %d)\n",
|
2012-05-12 21:18:02 +02:00
|
|
|
__func__, me->id.name + 2, me->totvert, dm->getNumVerts(dm));
|
2011-04-15 07:20:18 +02:00
|
|
|
return;
|
|
|
|
}
|
2012-01-30 02:18:49 +01:00
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
for (i = 0, kb = key->block.first; kb; kb = kb->next, i++) {
|
2012-01-30 02:18:49 +01:00
|
|
|
int ci;
|
|
|
|
float *array;
|
|
|
|
|
|
|
|
if (me->totvert != kb->totelem) {
|
|
|
|
fprintf(stderr,
|
2012-04-12 16:36:57 +02:00
|
|
|
"%s: vertex size mismatch (Mesh '%s':%d != KeyBlock '%s':%d)\n",
|
|
|
|
__func__, me->id.name + 2, me->totvert, kb->name, kb->totelem);
|
2018-01-14 22:14:20 +01:00
|
|
|
array = MEM_calloc_arrayN((size_t)me->totvert, 3 * sizeof(float), __func__);
|
2011-04-15 07:20:18 +02:00
|
|
|
}
|
2012-01-30 02:18:49 +01:00
|
|
|
else {
|
2018-01-14 22:14:20 +01:00
|
|
|
array = MEM_malloc_arrayN((size_t)me->totvert, 3 * sizeof(float), __func__);
|
|
|
|
memcpy(array, kb->data, (size_t)me->totvert * 3 * sizeof(float));
|
2011-04-15 07:20:18 +02:00
|
|
|
}
|
2012-01-30 02:18:49 +01:00
|
|
|
|
|
|
|
CustomData_add_layer_named(&dm->vertData, CD_SHAPEKEY, CD_ASSIGN, array, dm->numVertData, kb->name);
|
|
|
|
ci = CustomData_get_layer_index_n(&dm->vertData, CD_SHAPEKEY, i);
|
|
|
|
|
|
|
|
dm->vertData.layers[ci].uid = kb->uid;
|
2011-04-15 07:20:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-30 19:36:43 +02:00
|
|
|
/**
|
|
|
|
* Called after calculating all modifiers.
|
|
|
|
*
|
|
|
|
* \note tessfaces should already be calculated.
|
|
|
|
*/
|
|
|
|
static void dm_ensure_display_normals(DerivedMesh *dm)
|
|
|
|
{
|
2015-01-09 21:19:12 +01:00
|
|
|
/* Note: dm *may* have a poly CD_NORMAL layer (generated by a modifier needing poly normals e.g.).
|
|
|
|
* We do not use it here, though. And it should be tagged as temp!
|
|
|
|
*/
|
|
|
|
/* BLI_assert((CustomData_has_layer(&dm->polyData, CD_NORMAL) == false)); */
|
2013-05-30 20:09:19 +02:00
|
|
|
|
2013-05-30 19:36:43 +02:00
|
|
|
if ((dm->type == DM_TYPE_CDDM) &&
|
2015-07-27 13:10:04 +02:00
|
|
|
((dm->dirty & DM_DIRTY_NORMALS) || CustomData_has_layer(&dm->polyData, CD_NORMAL) == false))
|
2013-05-30 19:36:43 +02:00
|
|
|
{
|
|
|
|
/* if normals are dirty we want to calculate vertex normals too */
|
|
|
|
CDDM_calc_normals_mapping_ex(dm, (dm->dirty & DM_DIRTY_NORMALS) ? false : true);
|
|
|
|
}
|
|
|
|
}
|
2015-07-02 08:20:22 +02:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
static void mesh_ensure_display_normals(Mesh *mesh)
|
|
|
|
{
|
|
|
|
/* Note: mesh *may* have a poly CD_NORMAL layer (generated by a modifier needing poly normals e.g.).
|
|
|
|
* We do not use it here, though. And it should be tagged as temp!
|
|
|
|
*/
|
|
|
|
/* BLI_assert((CustomData_has_layer(&mesh->pdata, CD_NORMAL) == false)); */
|
|
|
|
|
2018-05-20 08:52:10 +02:00
|
|
|
if (mesh->runtime.cd_dirty_vert & CD_MASK_NORMAL || !CustomData_has_layer(&mesh->pdata, CD_NORMAL)) {
|
2018-05-11 09:53:52 +02:00
|
|
|
float (*face_nors)[3] = NULL;
|
|
|
|
face_nors = MEM_malloc_arrayN(mesh->totpoly, sizeof(*face_nors), "face_nors");
|
|
|
|
|
|
|
|
/* if normals are dirty we want to calculate vertex normals too */
|
|
|
|
bool only_face_normals = !(mesh->runtime.cd_dirty_vert & CD_MASK_NORMAL);
|
|
|
|
|
|
|
|
/* calculate face normals */
|
|
|
|
BKE_mesh_calc_normals_poly(
|
2018-05-20 08:52:10 +02:00
|
|
|
mesh->mvert, NULL, mesh->totvert, mesh->mloop, mesh->mpoly,
|
|
|
|
mesh->totloop, mesh->totpoly, face_nors,
|
|
|
|
only_face_normals);
|
2018-05-11 09:53:52 +02:00
|
|
|
|
|
|
|
CustomData_add_layer(&mesh->pdata, CD_NORMAL, CD_ASSIGN, face_nors, mesh->totpoly);
|
|
|
|
|
|
|
|
mesh->runtime.cd_dirty_vert &= ~CD_MASK_NORMAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
static void mesh_calc_modifiers(
|
2018-04-06 12:07:27 +02:00
|
|
|
struct Depsgraph *depsgraph, Scene *scene, Object *ob, float (*inputVertexCos)[3],
|
2018-05-22 19:42:41 +02:00
|
|
|
int useDeform,
|
2015-07-02 08:20:22 +02:00
|
|
|
const bool need_mapping, CustomDataMask dataMask,
|
|
|
|
const int index, const bool useCache, const bool build_shapekey_layers,
|
2015-07-20 16:08:06 +02:00
|
|
|
const bool allow_gpu,
|
2015-07-02 08:20:22 +02:00
|
|
|
/* return args */
|
2018-05-11 09:53:52 +02:00
|
|
|
Mesh **r_deform_mesh, Mesh **r_final_mesh)
|
2005-03-27 22:34:18 +02:00
|
|
|
{
|
2005-07-20 06:44:02 +02:00
|
|
|
Mesh *me = ob->data;
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
ModifierData *firstmd, *md, *previewmd = NULL;
|
2012-03-26 18:25:21 +02:00
|
|
|
CDMaskLink *datamasks, *curr;
|
2012-03-20 23:56:26 +01:00
|
|
|
/* XXX Always copying POLYINDEX, else tessellated data are no more valid! */
|
2013-06-13 02:33:48 +02:00
|
|
|
CustomDataMask mask, nextmask, previewmask = 0, append_mask = CD_MASK_ORIGINDEX;
|
2005-08-11 05:31:33 +02:00
|
|
|
float (*deformedVerts)[3] = NULL;
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
int numVerts = me->totvert;
|
2018-05-22 19:42:41 +02:00
|
|
|
const bool useRenderParams = (DEG_get_mode(depsgraph) == DAG_EVAL_RENDER);
|
2015-07-02 08:20:22 +02:00
|
|
|
const int required_mode = useRenderParams ? eModifierMode_Render : eModifierMode_Realtime;
|
2014-01-27 17:52:21 +01:00
|
|
|
bool isPrevDeform = false;
|
2012-05-12 21:18:02 +02:00
|
|
|
MultiresModifierData *mmd = get_multires_modifier(scene, ob, 0);
|
2014-01-27 17:52:21 +01:00
|
|
|
const bool has_multires = (mmd && mmd->sculptlvl != 0);
|
|
|
|
bool multires_applied = false;
|
2018-04-05 18:20:27 +02:00
|
|
|
const bool sculpt_mode = ob->mode & OB_MODE_SCULPT && ob->sculpt && !useRenderParams;
|
2014-12-09 12:57:59 +01:00
|
|
|
const bool sculpt_dyntopo = (sculpt_mode && ob->sculpt->bm) && !useRenderParams;
|
2016-01-20 22:03:15 +01:00
|
|
|
const int draw_flag = dm_drawflag_calc(scene->toolsettings, me);
|
2013-02-22 05:09:04 +01:00
|
|
|
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
/* Generic preview only in object mode! */
|
2018-04-05 18:20:27 +02:00
|
|
|
const bool do_mod_mcol = (ob->mode == OB_MODE_OBJECT);
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
#if 0 /* XXX Will re-enable this when we have global mod stack options. */
|
2014-01-27 17:52:21 +01:00
|
|
|
const bool do_final_wmcol = (scene->toolsettings->weights_preview == WP_WPREVIEW_FINAL) && do_wmcol;
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
#endif
|
2014-04-01 02:34:00 +02:00
|
|
|
const bool do_final_wmcol = false;
|
2018-04-05 18:20:27 +02:00
|
|
|
const bool do_init_wmcol = ((dataMask & CD_MASK_PREVIEW_MLOOPCOL) && (ob->mode & OB_MODE_WEIGHT_PAINT) && !do_final_wmcol);
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
/* XXX Same as above... For now, only weights preview in WPaint mode. */
|
2014-02-03 08:55:59 +01:00
|
|
|
const bool do_mod_wmcol = do_init_wmcol;
|
2011-09-14 04:04:26 +02:00
|
|
|
|
2015-01-19 14:11:40 +01:00
|
|
|
const bool do_loop_normals = (me->flag & ME_AUTOSMOOTH) != 0;
|
2014-04-13 12:18:51 +02:00
|
|
|
|
2013-08-19 11:05:34 +02:00
|
|
|
VirtualModifierData virtualModifierData;
|
|
|
|
|
2012-05-09 17:00:26 +02:00
|
|
|
ModifierApplyFlag app_flags = useRenderParams ? MOD_APPLY_RENDER : 0;
|
|
|
|
ModifierApplyFlag deform_app_flags = app_flags;
|
2015-07-02 08:20:22 +02:00
|
|
|
|
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
if (useCache)
|
2012-05-09 17:00:26 +02:00
|
|
|
app_flags |= MOD_APPLY_USECACHE;
|
2015-07-20 16:08:06 +02:00
|
|
|
if (allow_gpu)
|
|
|
|
app_flags |= MOD_APPLY_ALLOW_GPU;
|
2012-05-12 21:18:02 +02:00
|
|
|
if (useDeform)
|
2012-05-09 17:00:26 +02:00
|
|
|
deform_app_flags |= MOD_APPLY_USECACHE;
|
|
|
|
|
2018-05-01 17:33:04 +02:00
|
|
|
/* TODO(sybren): do we really need three context objects? Or do we modify
|
|
|
|
* them on the fly to change the flags where needed? */
|
|
|
|
const ModifierEvalContext mectx_deform = {depsgraph, ob, deform_app_flags};
|
|
|
|
const ModifierEvalContext mectx_apply = {depsgraph, ob, app_flags};
|
|
|
|
const ModifierEvalContext mectx_orco = {depsgraph, ob, (app_flags & ~MOD_APPLY_USECACHE) | MOD_APPLY_ORCO};
|
|
|
|
|
2018-04-16 14:07:42 +02:00
|
|
|
md = firstmd = modifiers_getVirtualModifierList(ob, &virtualModifierData);
|
2007-12-17 12:47:24 +01:00
|
|
|
|
- added eModifierTypeFlag_RequiresOriginalData for modifiers that
can only follow deform (for example, they store mesh vertex
indices)
- added ModifierType.foreachObjectLink for iterating over Object
links inside modifier data (used for file load, relinking, etc)
- switched various modifiers_ functions to take object argument
instead of ListBase
- added user editable name field to modifiers
- bug fix, duplicate and make single user didn't relink object
pointers in modifier data
- added modifiers to outliner, needs icon
- added armature, hook, and softbody modifiers (softbody doesn't
do anything atm). added conversion of old hooks to modifiers.
NOTE-THE-FIRST: User name field is not initialized on loading 2.38 files
so if you have saved stuff with a cvs blender you will see blank names.
NOTE-THE-SECOND: Since modifiers aren't evaluated yet for non-Mesh
objects, hooks for lattices and curves are broken. Don't updated if
you actually, say, *use* Blender.
NOTE-THE-THIRD: Old hooks used a quirky weighting system during
deformation which can't be extended to modifiers. On the upside,
I doubt anyone relied on the old quirky system and the new system
makes much more sense. (Although the way falloff works is still
quite stupid I think).
2005-08-11 00:05:52 +02:00
|
|
|
modifiers_clearErrors(ob);
|
2005-08-04 09:25:43 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (do_mod_wmcol || do_mod_mcol) {
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
/* Find the last active modifier generating a preview, or NULL if none. */
|
|
|
|
/* XXX Currently, DPaint modifier just ignores this.
|
|
|
|
* Needs a stupid hack...
|
|
|
|
* The whole "modifier preview" thing has to be (re?)designed, anyway! */
|
|
|
|
previewmd = modifiers_getLastPreview(scene, md, required_mode);
|
2013-06-13 02:33:48 +02:00
|
|
|
|
|
|
|
/* even if the modifier doesn't need the data, to make a preview it may */
|
|
|
|
if (previewmd) {
|
|
|
|
if (do_mod_wmcol) {
|
|
|
|
previewmask = CD_MASK_MDEFORMVERT;
|
|
|
|
}
|
|
|
|
}
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
}
|
|
|
|
|
2013-06-13 02:33:48 +02:00
|
|
|
datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode, previewmd, previewmask);
|
|
|
|
curr = datamasks;
|
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
if (r_deform_mesh) {
|
|
|
|
*r_deform_mesh = NULL;
|
2015-07-02 08:20:22 +02:00
|
|
|
}
|
2018-05-11 09:53:52 +02:00
|
|
|
*r_final_mesh = NULL;
|
2005-07-19 02:21:01 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (useDeform) {
|
|
|
|
if (inputVertexCos)
|
2009-06-08 22:08:19 +02:00
|
|
|
deformedVerts = inputVertexCos;
|
2005-09-26 17:34:21 +02:00
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
/* Apply all leading deforming modifiers */
|
2012-05-12 21:18:02 +02:00
|
|
|
for (; md; md = md->next, curr = curr->next) {
|
2015-03-30 12:17:07 +02:00
|
|
|
const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
|
2005-07-19 22:14:17 +02:00
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
md->scene = scene;
|
2009-01-04 15:14:06 +01:00
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
if (!modifier_isEnabled(scene, md, required_mode)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (useDeform < 0 && mti->dependsOnTime && mti->dependsOnTime(md)) {
|
|
|
|
continue;
|
|
|
|
}
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2012-12-30 19:29:41 +01:00
|
|
|
if (mti->type == eModifierTypeType_OnlyDeform && !sculpt_dyntopo) {
|
2012-03-24 07:18:31 +01:00
|
|
|
if (!deformedVerts)
|
2018-05-22 17:36:58 +02:00
|
|
|
deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
|
2005-07-19 22:14:17 +02:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
modifier_deformVerts_ensure_normals(md, &mectx_deform, NULL, deformedVerts, numVerts);
|
2012-03-24 07:18:31 +01:00
|
|
|
}
|
|
|
|
else {
|
2005-07-19 22:14:17 +02:00
|
|
|
break;
|
|
|
|
}
|
2008-07-28 13:01:34 +02:00
|
|
|
|
|
|
|
/* grab modifiers until index i */
|
2015-07-02 08:20:22 +02:00
|
|
|
if ((index != -1) && (BLI_findindex(&ob->modifiers, md) >= index))
|
2008-07-28 13:01:34 +02:00
|
|
|
break;
|
2005-07-19 22:14:17 +02:00
|
|
|
}
|
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
/* Result of all leading deforming modifiers is cached for
|
|
|
|
* places that wish to use the original mesh but with deformed
|
|
|
|
* coordinates (vpaint, etc.)
|
|
|
|
*/
|
2018-05-11 09:53:52 +02:00
|
|
|
if (r_deform_mesh) {
|
2018-05-20 08:52:10 +02:00
|
|
|
BKE_id_copy_ex(
|
|
|
|
NULL, &me->id, (ID **)r_deform_mesh,
|
2018-05-30 16:25:35 +02:00
|
|
|
(LIB_ID_CREATE_NO_MAIN |
|
|
|
|
LIB_ID_CREATE_NO_USER_REFCOUNT |
|
|
|
|
LIB_ID_CREATE_NO_DEG_TAG |
|
|
|
|
LIB_ID_COPY_CD_REFERENCE),
|
|
|
|
false);
|
2018-05-11 09:53:52 +02:00
|
|
|
|
|
|
|
/* XXX: Is build_shapekey_layers ever even true? This should have crashed long ago... */
|
|
|
|
BLI_assert(!build_shapekey_layers);
|
|
|
|
//if (build_shapekey_layers)
|
|
|
|
// add_shapekey_layers(*r_deform_mesh, me, ob);
|
2011-04-15 07:20:18 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (deformedVerts) {
|
2018-05-11 09:53:52 +02:00
|
|
|
BKE_mesh_apply_vert_coords(*r_deform_mesh, deformedVerts);
|
2006-09-07 08:44:25 +02:00
|
|
|
}
|
2006-08-30 05:05:30 +02:00
|
|
|
}
|
2012-03-24 07:18:31 +01:00
|
|
|
}
|
|
|
|
else {
|
2012-03-01 13:20:18 +01:00
|
|
|
/* default behavior for meshes */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (inputVertexCos)
|
2008-07-25 20:57:16 +02:00
|
|
|
deformedVerts = inputVertexCos;
|
|
|
|
else
|
2018-05-22 17:36:58 +02:00
|
|
|
deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
|
2005-07-19 02:21:01 +02:00
|
|
|
}
|
|
|
|
|
2005-09-23 16:42:14 +02:00
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
/* Now apply all remaining modifiers. If useDeform is off then skip
|
|
|
|
* OnlyDeform ones.
|
|
|
|
*/
|
2018-05-11 09:53:52 +02:00
|
|
|
Mesh *mesh = NULL;
|
|
|
|
Mesh *orco_mesh = NULL;
|
|
|
|
Mesh *cloth_orco_mesh = NULL;
|
2006-08-30 12:55:46 +02:00
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
for (; md; md = md->next, curr = curr->next) {
|
2015-03-30 12:17:07 +02:00
|
|
|
const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
|
2005-07-19 22:14:17 +02:00
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
md->scene = scene;
|
2011-01-31 21:02:51 +01:00
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
if (!modifier_isEnabled(scene, md, required_mode)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mti->type == eModifierTypeType_OnlyDeform && !useDeform) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
if ((mti->flags & eModifierTypeFlag_RequiresOriginalData) && mesh) {
|
2012-10-27 13:12:09 +02:00
|
|
|
modifier_setError(md, "Modifier requires original data, bad stack position");
|
- added eModifierTypeFlag_RequiresOriginalData for modifiers that
can only follow deform (for example, they store mesh vertex
indices)
- added ModifierType.foreachObjectLink for iterating over Object
links inside modifier data (used for file load, relinking, etc)
- switched various modifiers_ functions to take object argument
instead of ListBase
- added user editable name field to modifiers
- bug fix, duplicate and make single user didn't relink object
pointers in modifier data
- added modifiers to outliner, needs icon
- added armature, hook, and softbody modifiers (softbody doesn't
do anything atm). added conversion of old hooks to modifiers.
NOTE-THE-FIRST: User name field is not initialized on loading 2.38 files
so if you have saved stuff with a cvs blender you will see blank names.
NOTE-THE-SECOND: Since modifiers aren't evaluated yet for non-Mesh
objects, hooks for lattices and curves are broken. Don't updated if
you actually, say, *use* Blender.
NOTE-THE-THIRD: Old hooks used a quirky weighting system during
deformation which can't be extended to modifiers. On the upside,
I doubt anyone relied on the old quirky system and the new system
makes much more sense. (Although the way falloff works is still
quite stupid I think).
2005-08-11 00:05:52 +02:00
|
|
|
continue;
|
|
|
|
}
|
2015-07-02 08:20:22 +02:00
|
|
|
|
2012-12-30 19:29:41 +01:00
|
|
|
if (sculpt_mode &&
|
2014-05-09 10:29:21 +02:00
|
|
|
(!has_multires || multires_applied || sculpt_dyntopo))
|
2012-12-30 19:29:41 +01:00
|
|
|
{
|
2014-01-27 17:52:21 +01:00
|
|
|
bool unsupported = false;
|
2011-05-04 15:15:42 +02:00
|
|
|
|
2013-06-03 10:26:12 +02:00
|
|
|
if (md->type == eModifierType_Multires && ((MultiresModifierData *)md)->sculptlvl == 0) {
|
|
|
|
/* If multires is on level 0 skip it silently without warning message. */
|
2015-07-02 08:20:22 +02:00
|
|
|
if (!sculpt_dyntopo) {
|
2014-05-08 18:25:46 +02:00
|
|
|
continue;
|
2015-07-02 08:20:22 +02:00
|
|
|
}
|
2013-06-03 10:26:12 +02:00
|
|
|
}
|
|
|
|
|
2013-05-15 10:25:42 +02:00
|
|
|
if (sculpt_dyntopo && !useRenderParams)
|
2014-01-27 17:52:21 +01:00
|
|
|
unsupported = true;
|
2012-12-30 19:29:41 +01:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (scene->toolsettings->sculpt->flags & SCULPT_ONLY_DEFORM)
|
2014-01-27 17:52:21 +01:00
|
|
|
unsupported |= (mti->type != eModifierTypeType_OnlyDeform);
|
2011-05-04 15:15:42 +02:00
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
unsupported |= multires_applied;
|
2011-05-04 15:15:42 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (unsupported) {
|
2014-05-08 18:25:46 +02:00
|
|
|
if (sculpt_dyntopo)
|
|
|
|
modifier_setError(md, "Not supported in dyntopo");
|
|
|
|
else
|
|
|
|
modifier_setError(md, "Not supported in sculpt mode");
|
2011-01-31 21:02:51 +01:00
|
|
|
continue;
|
|
|
|
}
|
2014-05-08 18:15:36 +02:00
|
|
|
else {
|
|
|
|
modifier_setError(md, "Hide, Mask and optimized display disabled");
|
|
|
|
}
|
2011-05-04 15:15:42 +02:00
|
|
|
}
|
2015-07-02 08:20:22 +02:00
|
|
|
|
|
|
|
if (need_mapping && !modifier_supportsMapping(md)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (useDeform < 0 && mti->dependsOnTime && mti->dependsOnTime(md)) {
|
|
|
|
continue;
|
|
|
|
}
|
2005-07-19 22:14:17 +02:00
|
|
|
|
2007-12-05 13:40:54 +01:00
|
|
|
/* add an orco layer if needed by this modifier */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (mti->requiredDataMask)
|
2009-06-15 13:48:42 +02:00
|
|
|
mask = mti->requiredDataMask(ob, md);
|
2010-03-30 13:49:07 +02:00
|
|
|
else
|
|
|
|
mask = 0;
|
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
if (mesh && (mask & CD_MASK_ORCO)) {
|
|
|
|
add_orco_mesh(ob, NULL, mesh, orco_mesh, CD_ORCO);
|
|
|
|
}
|
2007-12-05 13:40:54 +01:00
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
/* How to apply modifier depends on (a) what we already have as
|
2018-05-11 09:53:52 +02:00
|
|
|
* a result of previous modifiers (could be a Mesh or just
|
2006-08-28 03:12:36 +02:00
|
|
|
* deformed vertices) and (b) what type the modifier is.
|
|
|
|
*/
|
2005-07-19 22:14:17 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (mti->type == eModifierTypeType_OnlyDeform) {
|
2006-08-28 03:12:36 +02:00
|
|
|
/* No existing verts to deform, need to build them. */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (!deformedVerts) {
|
2018-05-11 09:53:52 +02:00
|
|
|
if (mesh) {
|
|
|
|
/* Deforming a mesh, read the vertex locations
|
2006-08-28 03:12:36 +02:00
|
|
|
* out of the mesh and deform them. Once done with this
|
|
|
|
* run of deformers verts will be written back.
|
|
|
|
*/
|
2018-05-11 09:53:52 +02:00
|
|
|
deformedVerts = BKE_mesh_vertexCos_get(mesh, &numVerts);
|
2012-03-24 07:18:31 +01:00
|
|
|
}
|
|
|
|
else {
|
2018-05-22 17:36:58 +02:00
|
|
|
deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
|
2005-07-19 22:14:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-30 12:51:36 +02:00
|
|
|
/* if this is not the last modifier in the stack then recalculate the normals
|
|
|
|
* to avoid giving bogus normals to the next modifier see: [#23673] */
|
2012-05-20 21:49:27 +02:00
|
|
|
if (isPrevDeform && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
|
2010-09-30 12:51:36 +02:00
|
|
|
/* XXX, this covers bug #23673, but we may need normal calc for other types */
|
2018-05-11 09:53:52 +02:00
|
|
|
if (mesh) {
|
|
|
|
BKE_mesh_apply_vert_coords(mesh, deformedVerts);
|
2010-09-30 12:51:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
modifier_deformVerts_ensure_normals(md, &mectx_deform, mesh, deformedVerts, numVerts);
|
2012-03-24 07:18:31 +01:00
|
|
|
}
|
|
|
|
else {
|
2010-10-21 03:08:12 +02:00
|
|
|
/* determine which data layers are needed by following modifiers */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (curr->next)
|
2012-05-12 21:18:02 +02:00
|
|
|
nextmask = curr->next->mask;
|
2010-10-21 03:08:12 +02:00
|
|
|
else
|
2012-05-12 21:18:02 +02:00
|
|
|
nextmask = dataMask;
|
2010-10-21 03:08:12 +02:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
/* apply vertex coordinates or build a Mesh as necessary */
|
|
|
|
if (mesh) {
|
2012-03-24 07:18:31 +01:00
|
|
|
if (deformedVerts) {
|
2018-05-11 09:53:52 +02:00
|
|
|
BKE_mesh_apply_vert_coords(mesh, deformedVerts);
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
2012-03-24 07:18:31 +01:00
|
|
|
}
|
|
|
|
else {
|
2018-05-20 08:52:10 +02:00
|
|
|
BKE_id_copy_ex(
|
|
|
|
NULL, &me->id, (ID **)&mesh,
|
2018-05-30 16:25:35 +02:00
|
|
|
(LIB_ID_CREATE_NO_MAIN |
|
|
|
|
LIB_ID_CREATE_NO_USER_REFCOUNT |
|
|
|
|
LIB_ID_CREATE_NO_DEG_TAG |
|
|
|
|
LIB_ID_COPY_CD_REFERENCE),
|
|
|
|
false);
|
2018-05-11 09:53:52 +02:00
|
|
|
ASSERT_IS_VALID_MESH(mesh);
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
// XXX: port to Mesh if build_shapekey_layers can ever be true
|
|
|
|
//if (build_shapekey_layers)
|
|
|
|
// add_shapekey_layers(mesh, me, ob);
|
2011-04-15 07:20:18 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (deformedVerts) {
|
2018-05-11 09:53:52 +02:00
|
|
|
BKE_mesh_apply_vert_coords(mesh, deformedVerts);
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
2009-05-23 05:24:15 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (do_init_wmcol)
|
2018-05-11 09:53:52 +02:00
|
|
|
mesh_update_weight_mcol(ob, mesh, draw_flag, NULL, 0, NULL);
|
2010-02-09 19:06:57 +01:00
|
|
|
|
2010-10-21 03:08:12 +02:00
|
|
|
/* Constructive modifiers need to have an origindex
|
|
|
|
* otherwise they wont have anywhere to copy the data from.
|
|
|
|
*
|
|
|
|
* Also create ORIGINDEX data if any of the following modifiers
|
|
|
|
* requests it, this way Mirror, Solidify etc will keep ORIGINDEX
|
|
|
|
* data by using generic DM_copy_vert_data() functions.
|
|
|
|
*/
|
2015-07-02 08:20:22 +02:00
|
|
|
if (need_mapping || (nextmask & CD_MASK_ORIGINDEX)) {
|
2010-10-21 03:08:12 +02:00
|
|
|
/* calc */
|
2018-05-11 09:53:52 +02:00
|
|
|
CustomData_add_layer(&mesh->vdata, CD_ORIGINDEX, CD_CALLOC, NULL, mesh->totvert);
|
|
|
|
CustomData_add_layer(&mesh->edata, CD_ORIGINDEX, CD_CALLOC, NULL, mesh->totedge);
|
|
|
|
CustomData_add_layer(&mesh->pdata, CD_ORIGINDEX, CD_CALLOC, NULL, mesh->totpoly);
|
2010-02-09 19:06:57 +01:00
|
|
|
|
2016-05-29 20:14:42 +02:00
|
|
|
/* Not worth parallelizing this, gives less than 0.1% overall speedup in best of best cases... */
|
2018-05-11 09:53:52 +02:00
|
|
|
range_vn_i(CustomData_get_layer(&mesh->vdata, CD_ORIGINDEX), mesh->totvert, 0);
|
|
|
|
range_vn_i(CustomData_get_layer(&mesh->edata, CD_ORIGINDEX), mesh->totedge, 0);
|
|
|
|
range_vn_i(CustomData_get_layer(&mesh->pdata, CD_ORIGINDEX), mesh->totpoly, 0);
|
2010-02-09 19:06:57 +01:00
|
|
|
}
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
|
|
|
|
2010-03-30 13:49:07 +02:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
/* set the Mesh to only copy needed data */
|
2012-05-12 21:18:02 +02:00
|
|
|
mask = curr->mask;
|
2016-01-28 06:30:50 +01:00
|
|
|
/* needMapping check here fixes bug [#28112], otherwise it's
|
|
|
|
* possible that it won't be copied */
|
2011-07-08 13:03:37 +02:00
|
|
|
mask |= append_mask;
|
2018-05-11 09:53:52 +02:00
|
|
|
mesh_set_only_copy(mesh, mask | (need_mapping ? CD_MASK_ORIGINDEX : 0));
|
|
|
|
|
2016-01-28 06:30:50 +01:00
|
|
|
/* add cloth rest shape key if needed */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (mask & CD_MASK_CLOTH_ORCO)
|
2018-05-11 09:53:52 +02:00
|
|
|
add_orco_mesh(ob, NULL, mesh, orco_mesh, CD_CLOTH_ORCO);
|
2010-03-30 13:49:07 +02:00
|
|
|
|
2007-12-05 13:40:54 +01:00
|
|
|
/* add an origspace layer if needed */
|
2012-03-26 18:25:21 +02:00
|
|
|
if ((curr->mask) & CD_MASK_ORIGSPACE_MLOOP) {
|
2018-05-11 09:53:52 +02:00
|
|
|
if (!CustomData_has_layer(&mesh->ldata, CD_ORIGSPACE_MLOOP)) {
|
|
|
|
CustomData_add_layer(&mesh->ldata, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL, mesh->totloop);
|
|
|
|
mesh_init_origspace(mesh);
|
2012-02-05 12:30:26 +01:00
|
|
|
}
|
|
|
|
}
|
2007-12-05 13:40:54 +01:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
Mesh *new_mesh = modifier_applyModifier_ensure_normals(md, &mectx_apply, mesh);
|
|
|
|
ASSERT_IS_VALID_MESH(new_mesh);
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
if (new_mesh) {
|
|
|
|
/* if the modifier returned a new mesh, release the old one */
|
|
|
|
if (mesh && mesh != new_mesh) {
|
2018-05-16 17:35:54 +02:00
|
|
|
BLI_assert(mesh != me);
|
|
|
|
BKE_id_free(NULL, mesh);
|
2018-05-11 09:53:52 +02:00
|
|
|
}
|
2005-08-03 06:04:05 +02:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
mesh = new_mesh;
|
2005-07-26 04:44:59 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (deformedVerts) {
|
|
|
|
if (deformedVerts != inputVertexCos)
|
2005-07-26 04:44:59 +02:00
|
|
|
MEM_freeN(deformedVerts);
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2005-07-26 04:44:59 +02:00
|
|
|
deformedVerts = NULL;
|
2005-07-19 22:14:17 +02:00
|
|
|
}
|
2012-04-01 17:02:19 +02:00
|
|
|
}
|
2010-03-30 13:49:07 +02:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
/* create an orco mesh in parallel */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (nextmask & CD_MASK_ORCO) {
|
2018-05-11 09:53:52 +02:00
|
|
|
if (!orco_mesh) {
|
|
|
|
orco_mesh = create_orco_mesh(ob, me, NULL, CD_ORCO);
|
|
|
|
}
|
2010-03-30 13:49:07 +02:00
|
|
|
|
|
|
|
nextmask &= ~CD_MASK_ORCO;
|
2018-05-11 09:53:52 +02:00
|
|
|
mesh_set_only_copy(orco_mesh, nextmask | CD_MASK_ORIGINDEX |
|
2012-11-09 10:33:28 +01:00
|
|
|
(mti->requiredDataMask ?
|
|
|
|
mti->requiredDataMask(ob, md) : 0));
|
2013-05-30 19:36:43 +02:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
new_mesh = modifier_applyModifier_ensure_normals(md, &mectx_orco, orco_mesh);
|
|
|
|
ASSERT_IS_VALID_MESH(new_mesh);
|
2010-03-30 13:49:07 +02:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
if (new_mesh) {
|
|
|
|
/* if the modifier returned a new mesh, release the old one */
|
|
|
|
if (orco_mesh && orco_mesh != new_mesh) {
|
2018-05-16 17:35:54 +02:00
|
|
|
BLI_assert(orco_mesh != me);
|
2018-05-11 09:53:52 +02:00
|
|
|
BKE_id_free(NULL, orco_mesh);
|
|
|
|
}
|
|
|
|
|
|
|
|
orco_mesh = new_mesh;
|
2010-03-30 13:49:07 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
/* create cloth orco mesh in parallel */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (nextmask & CD_MASK_CLOTH_ORCO) {
|
2018-05-16 17:35:54 +02:00
|
|
|
if (!cloth_orco_mesh) {
|
2018-05-11 09:53:52 +02:00
|
|
|
cloth_orco_mesh = create_orco_mesh(ob, me, NULL, CD_CLOTH_ORCO);
|
2018-05-16 17:35:54 +02:00
|
|
|
}
|
2010-03-30 13:49:07 +02:00
|
|
|
|
|
|
|
nextmask &= ~CD_MASK_CLOTH_ORCO;
|
2018-05-11 09:53:52 +02:00
|
|
|
mesh_set_only_copy(cloth_orco_mesh, nextmask | CD_MASK_ORIGINDEX);
|
2013-05-30 19:36:43 +02:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
new_mesh = modifier_applyModifier_ensure_normals(md, &mectx_orco, cloth_orco_mesh);
|
|
|
|
ASSERT_IS_VALID_DM(new_mesh);
|
2010-03-30 13:49:07 +02:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
if (new_mesh) {
|
|
|
|
/* if the modifier returned a new mesh, release the old one */
|
|
|
|
if (cloth_orco_mesh && cloth_orco_mesh != new_mesh) {
|
2018-05-16 17:35:54 +02:00
|
|
|
BLI_assert(orco_mesh != me);
|
2018-05-11 09:53:52 +02:00
|
|
|
BKE_id_free(NULL, cloth_orco_mesh);
|
2015-07-02 08:20:22 +02:00
|
|
|
}
|
2018-05-11 09:53:52 +02:00
|
|
|
|
|
|
|
cloth_orco_mesh = new_mesh;
|
2010-03-30 13:49:07 +02:00
|
|
|
}
|
|
|
|
}
|
2011-07-08 13:03:37 +02:00
|
|
|
|
|
|
|
/* in case of dynamic paint, make sure preview mask remains for following modifiers */
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
/* XXX Temp and hackish solution! */
|
2011-07-08 13:03:37 +02:00
|
|
|
if (md->type == eModifierType_DynamicPaint)
|
2012-03-22 09:41:50 +01:00
|
|
|
append_mask |= CD_MASK_PREVIEW_MLOOPCOL;
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
/* In case of active preview modifier, make sure preview mask remains for following modifiers. */
|
|
|
|
else if ((md == previewmd) && (do_mod_wmcol)) {
|
2018-05-11 09:53:52 +02:00
|
|
|
mesh_update_weight_mcol(ob, mesh, draw_flag, NULL, 0, NULL);
|
2012-03-22 09:41:50 +01:00
|
|
|
append_mask |= CD_MASK_PREVIEW_MLOOPCOL;
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
}
|
2017-05-29 16:05:35 +02:00
|
|
|
|
2018-05-15 13:26:24 +02:00
|
|
|
mesh->runtime.deformed_only = false;
|
2005-07-19 22:14:17 +02:00
|
|
|
}
|
2010-05-03 18:06:36 +02:00
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
isPrevDeform = (mti->type == eModifierTypeType_OnlyDeform);
|
2010-09-30 12:51:36 +02:00
|
|
|
|
2008-07-28 13:01:34 +02:00
|
|
|
/* grab modifiers until index i */
|
2015-07-02 08:20:22 +02:00
|
|
|
if ((index != -1) && (BLI_findindex(&ob->modifiers, md) >= index))
|
2008-07-28 13:01:34 +02:00
|
|
|
break;
|
2011-01-31 21:02:51 +01:00
|
|
|
|
2014-01-27 17:52:21 +01:00
|
|
|
if (sculpt_mode && md->type == eModifierType_Multires) {
|
|
|
|
multires_applied = true;
|
|
|
|
}
|
2005-07-19 22:14:17 +02:00
|
|
|
}
|
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
for (md = firstmd; md; md = md->next)
|
2007-12-17 12:47:24 +01:00
|
|
|
modifier_freeTemporaryData(md);
|
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
/* Yay, we are done. If we have a Mesh and deformed vertices
|
|
|
|
* need to apply these back onto the Mesh. If we have no
|
|
|
|
* Mesh then we need to build one.
|
2006-08-28 03:12:36 +02:00
|
|
|
*/
|
2018-05-11 09:53:52 +02:00
|
|
|
Mesh *final_mesh;
|
2005-07-19 22:14:17 +02:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
if (mesh) {
|
|
|
|
final_mesh = mesh;
|
2009-04-02 16:38:40 +02:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
if (deformedVerts) {
|
|
|
|
BKE_mesh_apply_vert_coords(final_mesh, deformedVerts);
|
|
|
|
}
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
|
|
|
|
#if 0 /* For later nice mod preview! */
|
2012-03-22 09:41:50 +01:00
|
|
|
/* In case we need modified weights in CD_PREVIEW_MCOL, we have to re-compute it. */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (do_final_wmcol)
|
2018-05-11 09:53:52 +02:00
|
|
|
mesh_update_weight_mcol(ob, final_mesh, draw_flag, NULL, 0, NULL);
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
#endif
|
2012-03-24 07:18:31 +01:00
|
|
|
}
|
|
|
|
else {
|
2018-05-20 08:52:10 +02:00
|
|
|
BKE_id_copy_ex(
|
|
|
|
NULL, &me->id, (ID **)&final_mesh,
|
2018-05-30 16:25:35 +02:00
|
|
|
(LIB_ID_CREATE_NO_MAIN |
|
|
|
|
LIB_ID_CREATE_NO_USER_REFCOUNT |
|
|
|
|
LIB_ID_CREATE_NO_DEG_TAG |
|
|
|
|
LIB_ID_COPY_CD_REFERENCE),
|
|
|
|
false);
|
2018-05-11 09:53:52 +02:00
|
|
|
|
|
|
|
//if (build_shapekey_layers) {
|
|
|
|
// add_shapekey_layers(final_mesh, me, ob);
|
|
|
|
//}
|
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (deformedVerts) {
|
2018-05-11 09:53:52 +02:00
|
|
|
BKE_mesh_apply_vert_coords(final_mesh, deformedVerts);
|
2006-09-07 08:44:25 +02:00
|
|
|
}
|
2009-04-02 16:38:40 +02:00
|
|
|
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
/* In this case, we should never have weight-modifying modifiers in stack... */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (do_init_wmcol)
|
2018-05-11 09:53:52 +02:00
|
|
|
mesh_update_weight_mcol(ob, final_mesh, draw_flag, NULL, 0, NULL);
|
2005-03-27 22:34:18 +02:00
|
|
|
}
|
|
|
|
|
2007-12-05 13:40:54 +01:00
|
|
|
/* add an orco layer if needed */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (dataMask & CD_MASK_ORCO) {
|
2018-05-11 09:53:52 +02:00
|
|
|
add_orco_mesh(ob, NULL, final_mesh, orco_mesh, CD_ORCO);
|
2007-12-05 13:40:54 +01:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
if (r_deform_mesh && *r_deform_mesh)
|
|
|
|
add_orco_mesh(ob, NULL, *r_deform_mesh, NULL, CD_ORCO);
|
2008-01-09 15:40:25 +01:00
|
|
|
}
|
2007-12-05 13:40:54 +01:00
|
|
|
|
2014-04-13 12:18:51 +02:00
|
|
|
if (do_loop_normals) {
|
|
|
|
/* Compute loop normals (note: will compute poly and vert normals as well, if needed!) */
|
2018-05-11 09:53:52 +02:00
|
|
|
BKE_mesh_calc_normals_split(final_mesh);
|
2018-05-22 19:10:30 +02:00
|
|
|
BKE_mesh_tessface_clear(final_mesh);
|
2014-04-13 12:18:51 +02:00
|
|
|
}
|
2014-04-21 17:56:05 +02:00
|
|
|
|
2015-04-15 20:14:01 +02:00
|
|
|
if (sculpt_dyntopo == false) {
|
2015-07-16 19:36:03 +02:00
|
|
|
/* watch this! after 2.75a we move to from tessface to looptri (by default) */
|
2015-07-17 12:14:17 +02:00
|
|
|
if (dataMask & CD_MASK_MFACE) {
|
2018-05-22 17:53:18 +02:00
|
|
|
BKE_mesh_tessface_ensure(final_mesh);
|
2015-07-17 12:14:17 +02:00
|
|
|
}
|
2012-03-18 07:49:32 +01:00
|
|
|
|
|
|
|
/* without this, drawing ngon tri's faces will show ugly tessellated face
|
|
|
|
* normals and will also have to calculate normals on the fly, try avoid
|
|
|
|
* this where possible since calculating polygon normals isn't fast,
|
|
|
|
* note that this isn't a problem for subsurf (only quads) or editmode
|
|
|
|
* which deals with drawing differently.
|
|
|
|
*
|
2013-05-30 19:36:43 +02:00
|
|
|
* Only calc vertex normals if they are flagged as dirty.
|
2014-05-08 17:48:00 +02:00
|
|
|
* If using loop normals, poly nors have already been computed.
|
2012-03-18 07:49:32 +01:00
|
|
|
*/
|
2014-05-08 17:48:00 +02:00
|
|
|
if (!do_loop_normals) {
|
2018-05-11 09:53:52 +02:00
|
|
|
mesh_ensure_display_normals(final_mesh);
|
2014-05-08 17:48:00 +02:00
|
|
|
}
|
2012-02-06 07:56:54 +01:00
|
|
|
}
|
2011-12-07 02:12:53 +01:00
|
|
|
|
2017-01-27 18:47:11 +01:00
|
|
|
/* Some modifiers, like datatransfer, may generate those data as temp layer, we do not want to keep them,
|
|
|
|
* as they are used by display code when available (i.e. even if autosmooth is disabled). */
|
2018-05-11 09:53:52 +02:00
|
|
|
if (!do_loop_normals && CustomData_has_layer(&final_mesh->ldata, CD_NORMAL)) {
|
|
|
|
CustomData_free_layers(&final_mesh->ldata, CD_NORMAL, final_mesh->totloop);
|
2017-01-27 18:47:11 +01:00
|
|
|
}
|
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
*r_final_mesh = final_mesh;
|
2007-12-05 13:40:54 +01:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
if (orco_mesh) {
|
|
|
|
BKE_id_free(NULL, orco_mesh);
|
|
|
|
}
|
|
|
|
if (cloth_orco_mesh) {
|
|
|
|
BKE_id_free(NULL, cloth_orco_mesh);
|
|
|
|
}
|
2007-12-05 13:40:54 +01:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (deformedVerts && deformedVerts != inputVertexCos)
|
2005-07-19 02:21:01 +02:00
|
|
|
MEM_freeN(deformedVerts);
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
BLI_linklist_free((LinkNode *)datamasks, NULL);
|
2005-03-27 22:34:18 +02:00
|
|
|
}
|
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
static void mesh_calc_modifiers_dm(
|
|
|
|
struct Depsgraph *depsgraph, Scene *scene, Object *ob, float (*inputVertexCos)[3],
|
2018-05-22 19:42:41 +02:00
|
|
|
int useDeform,
|
2018-05-11 09:53:52 +02:00
|
|
|
const bool need_mapping, CustomDataMask dataMask,
|
|
|
|
const int index, const bool useCache, const bool build_shapekey_layers,
|
|
|
|
const bool allow_gpu,
|
|
|
|
/* return args */
|
|
|
|
DerivedMesh **r_deformdm, DerivedMesh **r_finaldm)
|
|
|
|
{
|
|
|
|
Mesh *deform_mesh = NULL, *final_mesh = NULL;
|
|
|
|
|
2018-05-20 08:52:10 +02:00
|
|
|
mesh_calc_modifiers(
|
2018-05-22 19:42:41 +02:00
|
|
|
depsgraph, scene, ob, inputVertexCos, useDeform,
|
2018-05-20 08:52:10 +02:00
|
|
|
need_mapping, dataMask, index, useCache, build_shapekey_layers, allow_gpu,
|
|
|
|
(r_deformdm ? &deform_mesh : NULL), &final_mesh);
|
2018-05-11 09:53:52 +02:00
|
|
|
|
2018-05-20 08:52:10 +02:00
|
|
|
if (deform_mesh) {
|
2018-05-22 17:53:18 +02:00
|
|
|
*r_deformdm = CDDM_from_mesh_ex(deform_mesh, CD_DUPLICATE, CD_MASK_MESH);
|
2018-05-11 09:53:52 +02:00
|
|
|
BKE_id_free(NULL, deform_mesh);
|
|
|
|
}
|
|
|
|
|
2018-05-22 17:53:18 +02:00
|
|
|
*r_finaldm = CDDM_from_mesh_ex(final_mesh, CD_DUPLICATE, CD_MASK_MESH);
|
2018-05-11 09:53:52 +02:00
|
|
|
BKE_id_free(NULL, final_mesh);
|
|
|
|
}
|
|
|
|
|
2014-03-15 17:24:05 +01:00
|
|
|
float (*editbmesh_get_vertex_cos(BMEditMesh *em, int *r_numVerts))[3]
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
{
|
2009-05-16 18:18:08 +02:00
|
|
|
BMIter iter;
|
|
|
|
BMVert *eve;
|
2012-12-21 08:28:14 +01:00
|
|
|
float (*cos)[3];
|
|
|
|
int i;
|
|
|
|
|
2014-03-15 17:24:05 +01:00
|
|
|
*r_numVerts = em->bm->totvert;
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
|
2018-01-14 22:14:20 +01:00
|
|
|
cos = MEM_malloc_arrayN(em->bm->totvert, 3 * sizeof(float), "vertexcos");
|
2009-05-16 18:18:08 +02:00
|
|
|
|
2012-12-21 08:28:14 +01:00
|
|
|
BM_ITER_MESH_INDEX (eve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
|
2011-11-06 16:39:20 +01:00
|
|
|
copy_v3_v3(cos[i], eve->co);
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
}
|
|
|
|
|
2005-10-09 18:59:10 +02:00
|
|
|
return cos;
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
}
|
|
|
|
|
2014-02-03 08:55:59 +01:00
|
|
|
bool editbmesh_modifier_is_enabled(Scene *scene, ModifierData *md, DerivedMesh *dm)
|
2007-07-28 23:04:30 +02:00
|
|
|
{
|
2015-03-30 12:17:07 +02:00
|
|
|
const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
|
2015-07-02 08:20:22 +02:00
|
|
|
const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
|
|
|
|
|
|
|
|
if (!modifier_isEnabled(scene, md, required_mode)) {
|
|
|
|
return false;
|
|
|
|
}
|
2007-07-28 23:04:30 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if ((mti->flags & eModifierTypeFlag_RequiresOriginalData) && dm) {
|
2012-10-27 13:12:09 +02:00
|
|
|
modifier_setError(md, "Modifier requires original data, bad stack position");
|
2014-12-01 17:11:18 +01:00
|
|
|
return false;
|
2007-07-28 23:04:30 +02:00
|
|
|
}
|
|
|
|
|
2014-12-01 17:11:18 +01:00
|
|
|
return true;
|
2007-07-28 23:04:30 +02:00
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
static void editbmesh_calc_modifiers(
|
2018-04-06 12:07:27 +02:00
|
|
|
struct Depsgraph *depsgraph, Scene *scene, Object *ob,
|
2017-07-21 11:53:13 +02:00
|
|
|
BMEditMesh *em, CustomDataMask dataMask,
|
2015-07-02 08:20:22 +02:00
|
|
|
/* return args */
|
|
|
|
DerivedMesh **r_cage, DerivedMesh **r_final)
|
2013-07-05 02:13:14 +02:00
|
|
|
{
|
2013-07-01 02:42:44 +02:00
|
|
|
ModifierData *md, *previewmd = NULL;
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
float (*deformedVerts)[3] = NULL;
|
2016-09-03 18:00:40 +02:00
|
|
|
CustomDataMask mask = 0, previewmask = 0, append_mask = 0;
|
2014-04-13 12:18:51 +02:00
|
|
|
DerivedMesh *dm = NULL, *orcodm = NULL;
|
2010-01-25 12:39:56 +01:00
|
|
|
int i, numVerts = 0, cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
|
2012-03-26 18:25:21 +02:00
|
|
|
CDMaskLink *datamasks, *curr;
|
2015-07-02 08:20:22 +02:00
|
|
|
const int required_mode = eModifierMode_Realtime | eModifierMode_Editmode;
|
2016-01-20 22:03:15 +01:00
|
|
|
int draw_flag = dm_drawflag_calc(scene->toolsettings, ob->data);
|
2013-04-13 22:20:21 +02:00
|
|
|
|
2014-02-03 08:55:59 +01:00
|
|
|
// const bool do_mod_mcol = true; // (ob->mode == OB_MODE_OBJECT);
|
2013-04-13 22:20:21 +02:00
|
|
|
#if 0 /* XXX Will re-enable this when we have global mod stack options. */
|
2014-02-03 08:55:59 +01:00
|
|
|
const bool do_final_wmcol = (scene->toolsettings->weights_preview == WP_WPREVIEW_FINAL) && do_wmcol;
|
2013-04-13 22:20:21 +02:00
|
|
|
#endif
|
2014-04-01 02:34:00 +02:00
|
|
|
const bool do_final_wmcol = false;
|
2014-01-27 17:52:21 +01:00
|
|
|
const bool do_init_wmcol = ((((Mesh *)ob->data)->drawflag & ME_DRAWEIGHT) && !do_final_wmcol);
|
2015-08-28 12:40:52 +02:00
|
|
|
|
2014-01-27 17:52:21 +01:00
|
|
|
const bool do_init_statvis = ((((Mesh *)ob->data)->drawflag & ME_DRAW_STATVIS) && !do_init_wmcol);
|
|
|
|
const bool do_mod_wmcol = do_init_wmcol;
|
2013-08-19 11:05:34 +02:00
|
|
|
VirtualModifierData virtualModifierData;
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
|
2018-05-01 17:33:04 +02:00
|
|
|
/* TODO(sybren): do we really need multiple objects, or shall we change the flags where needed? */
|
|
|
|
const ModifierEvalContext mectx = {depsgraph, ob, 0};
|
|
|
|
const ModifierEvalContext mectx_orco = {depsgraph, ob, MOD_APPLY_ORCO};
|
|
|
|
const ModifierEvalContext mectx_cache_gpu = {depsgraph, ob, MOD_APPLY_USECACHE | MOD_APPLY_ALLOW_GPU};
|
|
|
|
|
2015-01-19 14:11:40 +01:00
|
|
|
const bool do_loop_normals = (((Mesh *)(ob->data))->flag & ME_AUTOSMOOTH) != 0;
|
2014-04-13 12:18:51 +02:00
|
|
|
const float loop_normals_split_angle = ((Mesh *)(ob->data))->smoothresh;
|
|
|
|
|
- added eModifierTypeFlag_RequiresOriginalData for modifiers that
can only follow deform (for example, they store mesh vertex
indices)
- added ModifierType.foreachObjectLink for iterating over Object
links inside modifier data (used for file load, relinking, etc)
- switched various modifiers_ functions to take object argument
instead of ListBase
- added user editable name field to modifiers
- bug fix, duplicate and make single user didn't relink object
pointers in modifier data
- added modifiers to outliner, needs icon
- added armature, hook, and softbody modifiers (softbody doesn't
do anything atm). added conversion of old hooks to modifiers.
NOTE-THE-FIRST: User name field is not initialized on loading 2.38 files
so if you have saved stuff with a cvs blender you will see blank names.
NOTE-THE-SECOND: Since modifiers aren't evaluated yet for non-Mesh
objects, hooks for lattices and curves are broken. Don't updated if
you actually, say, *use* Blender.
NOTE-THE-THIRD: Old hooks used a quirky weighting system during
deformation which can't be extended to modifiers. On the upside,
I doubt anyone relied on the old quirky system and the new system
makes much more sense. (Although the way falloff works is still
quite stupid I think).
2005-08-11 00:05:52 +02:00
|
|
|
modifiers_clearErrors(ob);
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
if (r_cage && cageIndex == -1) {
|
2016-06-22 13:20:09 +02:00
|
|
|
*r_cage = getEditDerivedBMesh(em, ob, dataMask, NULL);
|
2005-08-03 06:04:05 +02:00
|
|
|
}
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
|
2013-08-19 11:05:34 +02:00
|
|
|
md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
|
2006-12-05 18:42:03 +01:00
|
|
|
|
2013-07-01 02:42:44 +02:00
|
|
|
/* copied from mesh_calc_modifiers */
|
|
|
|
if (do_mod_wmcol) {
|
|
|
|
previewmd = modifiers_getLastPreview(scene, md, required_mode);
|
|
|
|
/* even if the modifier doesn't need the data, to make a preview it may */
|
|
|
|
if (previewmd) {
|
2014-08-15 10:07:39 +02:00
|
|
|
previewmask = CD_MASK_MDEFORMVERT;
|
2013-07-01 02:42:44 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
datamasks = modifiers_calcDataMasks(scene, ob, md, dataMask, required_mode, previewmd, previewmask);
|
2006-12-05 18:42:03 +01:00
|
|
|
|
|
|
|
curr = datamasks;
|
2012-03-24 07:18:31 +01:00
|
|
|
for (i = 0; md; i++, md = md->next, curr = curr->next) {
|
2015-03-30 12:17:07 +02:00
|
|
|
const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
md->scene = scene;
|
2009-01-04 15:14:06 +01:00
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
if (!editbmesh_modifier_is_enabled(scene, md, dm)) {
|
- added eModifierTypeFlag_RequiresOriginalData for modifiers that
can only follow deform (for example, they store mesh vertex
indices)
- added ModifierType.foreachObjectLink for iterating over Object
links inside modifier data (used for file load, relinking, etc)
- switched various modifiers_ functions to take object argument
instead of ListBase
- added user editable name field to modifiers
- bug fix, duplicate and make single user didn't relink object
pointers in modifier data
- added modifiers to outliner, needs icon
- added armature, hook, and softbody modifiers (softbody doesn't
do anything atm). added conversion of old hooks to modifiers.
NOTE-THE-FIRST: User name field is not initialized on loading 2.38 files
so if you have saved stuff with a cvs blender you will see blank names.
NOTE-THE-SECOND: Since modifiers aren't evaluated yet for non-Mesh
objects, hooks for lattices and curves are broken. Don't updated if
you actually, say, *use* Blender.
NOTE-THE-THIRD: Old hooks used a quirky weighting system during
deformation which can't be extended to modifiers. On the upside,
I doubt anyone relied on the old quirky system and the new system
makes much more sense. (Although the way falloff works is still
quite stupid I think).
2005-08-11 00:05:52 +02:00
|
|
|
continue;
|
2015-07-02 08:20:22 +02:00
|
|
|
}
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 22:51:28 +02:00
|
|
|
/* add an orco layer if needed by this modifier */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (dm && mti->requiredDataMask) {
|
2009-06-15 13:48:42 +02:00
|
|
|
mask = mti->requiredDataMask(ob, md);
|
2012-03-24 07:18:31 +01:00
|
|
|
if (mask & CD_MASK_ORCO)
|
2010-03-30 13:49:07 +02:00
|
|
|
add_orco_dm(ob, em, dm, orcodm, CD_ORCO);
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 22:51:28 +02:00
|
|
|
}
|
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
/* How to apply modifier depends on (a) what we already have as
|
|
|
|
* a result of previous modifiers (could be a DerivedMesh or just
|
|
|
|
* deformed vertices) and (b) what type the modifier is.
|
|
|
|
*/
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (mti->type == eModifierTypeType_OnlyDeform) {
|
2006-08-28 03:12:36 +02:00
|
|
|
/* No existing verts to deform, need to build them. */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (!deformedVerts) {
|
|
|
|
if (dm) {
|
2006-08-28 03:12:36 +02:00
|
|
|
/* Deforming a derived mesh, read the vertex locations
|
|
|
|
* out of the mesh and deform them. Once done with this
|
|
|
|
* run of deformers verts will be written back.
|
|
|
|
*/
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
numVerts = dm->getNumVerts(dm);
|
2006-08-28 03:12:36 +02:00
|
|
|
deformedVerts =
|
2018-01-14 22:14:20 +01:00
|
|
|
MEM_malloc_arrayN(numVerts, sizeof(*deformedVerts), "dfmv");
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
dm->getVertCos(dm, deformedVerts);
|
2012-03-24 07:18:31 +01:00
|
|
|
}
|
|
|
|
else {
|
2011-02-27 07:19:40 +01:00
|
|
|
deformedVerts = editbmesh_get_vertex_cos(em, &numVerts);
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-18 15:45:54 +02:00
|
|
|
if (mti->deformVertsEM || mti->deformVertsEM_DM)
|
2018-05-01 17:33:04 +02:00
|
|
|
modwrap_deformVertsEM(md, &mectx, em, dm, deformedVerts, numVerts);
|
2012-05-09 17:00:26 +02:00
|
|
|
else
|
2018-05-01 17:33:04 +02:00
|
|
|
modwrap_deformVerts(md, &mectx, dm, deformedVerts, numVerts);
|
2012-03-24 07:18:31 +01:00
|
|
|
}
|
|
|
|
else {
|
2006-08-28 03:12:36 +02:00
|
|
|
DerivedMesh *ndm;
|
|
|
|
|
|
|
|
/* apply vertex coordinates or build a DerivedMesh as necessary */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (dm) {
|
|
|
|
if (deformedVerts) {
|
2012-01-29 22:59:47 +01:00
|
|
|
DerivedMesh *tdm = CDDM_copy(dm);
|
2015-07-02 08:20:22 +02:00
|
|
|
if (!(r_cage && dm == *r_cage)) {
|
|
|
|
dm->release(dm);
|
|
|
|
}
|
2006-08-28 03:12:36 +02:00
|
|
|
dm = tdm;
|
|
|
|
|
|
|
|
CDDM_apply_vert_coords(dm, deformedVerts);
|
2012-03-24 07:18:31 +01:00
|
|
|
}
|
2015-07-02 08:20:22 +02:00
|
|
|
else if (r_cage && dm == *r_cage) {
|
|
|
|
/* dm may be changed by this modifier, so we need to copy it */
|
2012-01-29 22:59:47 +01:00
|
|
|
dm = CDDM_copy(dm);
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
}
|
|
|
|
else {
|
2014-01-23 14:50:50 +01:00
|
|
|
dm = CDDM_from_editbmesh(em, false, false);
|
2013-09-04 03:29:34 +02:00
|
|
|
ASSERT_IS_VALID_DM(dm);
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (deformedVerts) {
|
2006-08-28 03:12:36 +02:00
|
|
|
CDDM_apply_vert_coords(dm, deformedVerts);
|
|
|
|
}
|
2013-04-13 22:20:21 +02:00
|
|
|
|
|
|
|
if (do_init_wmcol) {
|
|
|
|
DM_update_weight_mcol(ob, dm, draw_flag, NULL, 0, NULL);
|
|
|
|
}
|
2006-08-28 03:12:36 +02:00
|
|
|
}
|
|
|
|
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 22:51:28 +02:00
|
|
|
/* create an orco derivedmesh in parallel */
|
2012-05-12 21:18:02 +02:00
|
|
|
mask = curr->mask;
|
2012-03-24 07:18:31 +01:00
|
|
|
if (mask & CD_MASK_ORCO) {
|
|
|
|
if (!orcodm)
|
2012-05-12 21:18:02 +02:00
|
|
|
orcodm = create_orco_dm(ob, ob->data, em, CD_ORCO);
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 22:51:28 +02:00
|
|
|
|
|
|
|
mask &= ~CD_MASK_ORCO;
|
2010-10-21 03:08:12 +02:00
|
|
|
DM_set_only_copy(orcodm, mask | CD_MASK_ORIGINDEX);
|
2010-05-03 12:09:26 +02:00
|
|
|
|
2018-04-18 15:45:54 +02:00
|
|
|
if (mti->applyModifierEM || mti->applyModifierEM_DM) {
|
2018-05-01 17:33:04 +02:00
|
|
|
ndm = modwrap_applyModifierEM(md, &mectx_orco, em, orcodm);
|
2013-09-12 10:28:41 +02:00
|
|
|
}
|
2013-09-12 12:41:00 +02:00
|
|
|
else {
|
2018-05-01 17:33:04 +02:00
|
|
|
ndm = modwrap_applyModifier(md, &mectx_orco, orcodm);
|
2013-09-12 10:28:41 +02:00
|
|
|
}
|
2013-09-04 03:29:34 +02:00
|
|
|
ASSERT_IS_VALID_DM(ndm);
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 22:51:28 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (ndm) {
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 22:51:28 +02:00
|
|
|
/* if the modifier returned a new dm, release the old one */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (orcodm && orcodm != ndm) orcodm->release(orcodm);
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 22:51:28 +02:00
|
|
|
orcodm = ndm;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-12-05 18:42:03 +01:00
|
|
|
/* set the DerivedMesh to only copy needed data */
|
2013-07-05 00:24:39 +02:00
|
|
|
mask |= append_mask;
|
2012-05-12 21:18:02 +02:00
|
|
|
mask = curr->mask; /* CD_MASK_ORCO may have been cleared above */
|
2006-12-05 18:42:03 +01:00
|
|
|
|
2010-10-21 03:08:12 +02:00
|
|
|
DM_set_only_copy(dm, mask | CD_MASK_ORIGINDEX);
|
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (mask & CD_MASK_ORIGSPACE_MLOOP) {
|
|
|
|
if (!CustomData_has_layer(&dm->loopData, CD_ORIGSPACE_MLOOP)) {
|
2012-02-05 12:30:26 +01:00
|
|
|
DM_add_loop_layer(dm, CD_ORIGSPACE_MLOOP, CD_CALLOC, NULL);
|
|
|
|
DM_init_origspace(dm);
|
|
|
|
}
|
|
|
|
}
|
2013-05-30 19:36:43 +02:00
|
|
|
|
2018-04-18 15:45:54 +02:00
|
|
|
if (mti->applyModifierEM || mti->applyModifierEM_DM)
|
2018-05-01 17:33:04 +02:00
|
|
|
ndm = modwrap_applyModifierEM(md, &mectx_cache_gpu, em, dm);
|
2010-05-03 12:09:26 +02:00
|
|
|
else
|
2018-05-01 17:33:04 +02:00
|
|
|
ndm = modwrap_applyModifier(md, &mectx_cache_gpu, dm);
|
2013-09-04 03:29:34 +02:00
|
|
|
ASSERT_IS_VALID_DM(ndm);
|
2005-08-03 06:04:05 +02:00
|
|
|
|
|
|
|
if (ndm) {
|
2012-03-24 07:18:31 +01:00
|
|
|
if (dm && dm != ndm)
|
2006-08-28 03:12:36 +02:00
|
|
|
dm->release(dm);
|
2005-08-03 06:04:05 +02:00
|
|
|
|
|
|
|
dm = ndm;
|
|
|
|
|
|
|
|
if (deformedVerts) {
|
|
|
|
MEM_freeN(deformedVerts);
|
|
|
|
deformedVerts = NULL;
|
|
|
|
}
|
|
|
|
}
|
2017-05-29 16:05:35 +02:00
|
|
|
|
|
|
|
dm->deformedOnly = false;
|
2005-08-03 06:04:05 +02:00
|
|
|
}
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
|
2013-07-05 00:24:39 +02:00
|
|
|
/* In case of active preview modifier, make sure preview mask remains for following modifiers. */
|
|
|
|
if ((md == previewmd) && (do_mod_wmcol)) {
|
|
|
|
DM_update_weight_mcol(ob, dm, draw_flag, NULL, 0, NULL);
|
|
|
|
append_mask |= CD_MASK_PREVIEW_MLOOPCOL;
|
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
if (r_cage && i == cageIndex) {
|
2012-03-24 07:18:31 +01:00
|
|
|
if (dm && deformedVerts) {
|
2015-07-02 08:20:22 +02:00
|
|
|
*r_cage = CDDM_copy(dm);
|
|
|
|
CDDM_apply_vert_coords(*r_cage, deformedVerts);
|
2012-03-24 07:18:31 +01:00
|
|
|
}
|
|
|
|
else if (dm) {
|
2015-07-02 08:20:22 +02:00
|
|
|
*r_cage = dm;
|
2012-03-24 07:18:31 +01:00
|
|
|
}
|
|
|
|
else {
|
2018-04-19 11:03:58 +02:00
|
|
|
struct Mesh *mesh = ob->data;
|
|
|
|
if (mesh->id.tag & LIB_TAG_COPY_ON_WRITE) {
|
2018-05-11 20:48:14 +02:00
|
|
|
BKE_mesh_runtime_ensure_edit_data(mesh);
|
2018-05-02 15:47:45 +02:00
|
|
|
mesh->runtime.edit_data->vertexCos = MEM_dupallocN(deformedVerts);
|
2018-04-19 11:03:58 +02:00
|
|
|
}
|
2015-07-02 08:20:22 +02:00
|
|
|
*r_cage = getEditDerivedBMesh(
|
2016-06-22 13:20:09 +02:00
|
|
|
em, ob, mask,
|
2015-07-02 08:20:22 +02:00
|
|
|
deformedVerts ? MEM_dupallocN(deformedVerts) : NULL);
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
BLI_linklist_free((LinkNode *)datamasks, NULL);
|
2006-12-05 18:42:03 +01:00
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
/* Yay, we are done. If we have a DerivedMesh and deformed vertices need
|
|
|
|
* to apply these back onto the DerivedMesh. If we have no DerivedMesh
|
|
|
|
* then we need to build one.
|
|
|
|
*/
|
2012-03-24 07:18:31 +01:00
|
|
|
if (dm && deformedVerts) {
|
2015-07-02 08:20:22 +02:00
|
|
|
*r_final = CDDM_copy(dm);
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
if (!(r_cage && dm == *r_cage)) {
|
|
|
|
dm->release(dm);
|
|
|
|
}
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
CDDM_apply_vert_coords(*r_final, deformedVerts);
|
2012-02-28 11:22:21 +01:00
|
|
|
}
|
|
|
|
else if (dm) {
|
2015-07-02 08:20:22 +02:00
|
|
|
*r_final = dm;
|
2012-02-28 11:22:21 +01:00
|
|
|
}
|
2015-07-02 08:20:22 +02:00
|
|
|
else if (!deformedVerts && r_cage && *r_cage) {
|
2012-02-28 11:22:21 +01:00
|
|
|
/* cage should already have up to date normals */
|
2015-07-02 08:20:22 +02:00
|
|
|
*r_final = *r_cage;
|
2013-04-13 22:20:21 +02:00
|
|
|
|
|
|
|
/* In this case, we should never have weight-modifying modifiers in stack... */
|
|
|
|
if (do_init_wmcol)
|
2015-07-02 08:20:22 +02:00
|
|
|
DM_update_weight_mcol(ob, *r_final, draw_flag, NULL, 0, NULL);
|
2013-04-17 11:27:23 +02:00
|
|
|
if (do_init_statvis)
|
2015-07-02 08:20:22 +02:00
|
|
|
DM_update_statvis_color(scene, ob, *r_final);
|
2012-02-28 11:22:21 +01:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* this is just a copy of the editmesh, no need to calc normals */
|
2018-04-19 11:03:58 +02:00
|
|
|
struct Mesh *mesh = ob->data;
|
|
|
|
if (mesh->id.tag & LIB_TAG_COPY_ON_WRITE) {
|
2018-05-11 20:48:14 +02:00
|
|
|
BKE_mesh_runtime_ensure_edit_data(mesh);
|
2018-05-02 15:47:45 +02:00
|
|
|
if (mesh->runtime.edit_data->vertexCos != NULL)
|
|
|
|
MEM_freeN((void *)mesh->runtime.edit_data->vertexCos);
|
|
|
|
mesh->runtime.edit_data->vertexCos = MEM_dupallocN(deformedVerts);
|
2018-04-19 11:03:58 +02:00
|
|
|
}
|
2016-06-22 13:20:09 +02:00
|
|
|
*r_final = getEditDerivedBMesh(em, ob, dataMask, deformedVerts);
|
2007-02-03 15:46:30 +01:00
|
|
|
deformedVerts = NULL;
|
2013-04-13 22:20:21 +02:00
|
|
|
|
|
|
|
/* In this case, we should never have weight-modifying modifiers in stack... */
|
|
|
|
if (do_init_wmcol)
|
2015-07-02 08:20:22 +02:00
|
|
|
DM_update_weight_mcol(ob, *r_final, draw_flag, NULL, 0, NULL);
|
2013-04-17 11:27:23 +02:00
|
|
|
if (do_init_statvis)
|
2015-07-02 08:20:22 +02:00
|
|
|
DM_update_statvis_color(scene, ob, *r_final);
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
}
|
2007-02-03 15:46:30 +01:00
|
|
|
|
2014-04-13 12:18:51 +02:00
|
|
|
if (do_loop_normals) {
|
|
|
|
/* Compute loop normals */
|
2015-07-02 08:20:22 +02:00
|
|
|
DM_calc_loop_normals(*r_final, do_loop_normals, loop_normals_split_angle);
|
|
|
|
if (r_cage && *r_cage && (*r_cage != *r_final)) {
|
|
|
|
DM_calc_loop_normals(*r_cage, do_loop_normals, loop_normals_split_angle);
|
2014-04-13 12:18:51 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-20 14:53:47 +01:00
|
|
|
/* BMESH_ONLY, ensure tessface's used for drawing,
|
2012-03-18 08:38:51 +01:00
|
|
|
* but don't recalculate if the last modifier in the stack gives us tessfaces
|
|
|
|
* check if the derived meshes are DM_TYPE_EDITBMESH before calling, this isn't essential
|
2012-02-28 11:22:21 +01:00
|
|
|
* but quiets annoying error messages since tessfaces wont be created. */
|
2015-07-17 12:14:17 +02:00
|
|
|
if (dataMask & CD_MASK_MFACE) {
|
|
|
|
if ((*r_final)->type != DM_TYPE_EDITBMESH) {
|
|
|
|
DM_ensure_tessface(*r_final);
|
|
|
|
}
|
|
|
|
if (r_cage && *r_cage) {
|
|
|
|
if ((*r_cage)->type != DM_TYPE_EDITBMESH) {
|
|
|
|
if (*r_cage != *r_final) {
|
|
|
|
DM_ensure_tessface(*r_cage);
|
|
|
|
}
|
2012-02-28 11:22:21 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-01-20 14:53:47 +01:00
|
|
|
/* --- */
|
2012-01-20 00:34:53 +01:00
|
|
|
|
2014-04-13 12:18:51 +02:00
|
|
|
/* same as mesh_calc_modifiers (if using loop normals, poly nors have already been computed). */
|
|
|
|
if (!do_loop_normals) {
|
2015-07-02 08:20:22 +02:00
|
|
|
dm_ensure_display_normals(*r_final);
|
2017-01-27 18:47:11 +01:00
|
|
|
|
|
|
|
/* Some modifiers, like datatransfer, may generate those data, we do not want to keep them,
|
|
|
|
* as they are used by display code when available (i.e. even if autosmooth is disabled). */
|
|
|
|
if (CustomData_has_layer(&(*r_final)->loopData, CD_NORMAL)) {
|
|
|
|
CustomData_free_layers(&(*r_final)->loopData, CD_NORMAL, (*r_final)->numLoopData);
|
|
|
|
}
|
|
|
|
if (r_cage && CustomData_has_layer(&(*r_cage)->loopData, CD_NORMAL)) {
|
|
|
|
CustomData_free_layers(&(*r_cage)->loopData, CD_NORMAL, (*r_cage)->numLoopData);
|
|
|
|
}
|
2014-04-13 12:18:51 +02:00
|
|
|
}
|
2013-05-30 19:36:43 +02:00
|
|
|
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 22:51:28 +02:00
|
|
|
/* add an orco layer if needed */
|
2012-03-24 07:18:31 +01:00
|
|
|
if (dataMask & CD_MASK_ORCO)
|
2015-07-02 08:20:22 +02:00
|
|
|
add_orco_dm(ob, em, *r_final, orcodm, CD_ORCO);
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 22:51:28 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (orcodm)
|
Merge of first part of changes from the apricot branch, especially
the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:
* GLSL support in the viewport and game engine, enable in the game
menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.
* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
An extra texture slot shows up once the last slot is used.
* Memory limit for undo, not enabled by default yet because it
needs the .B.blend to be changed.
* Multiple undo for image painting.
* An offset for dupligroups, so not all objects in a group have to
be at the origin.
2008-09-04 22:51:28 +02:00
|
|
|
orcodm->release(orcodm);
|
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (deformedVerts)
|
2007-02-03 15:46:30 +01:00
|
|
|
MEM_freeN(deformedVerts);
|
- added data arguments to deformer modifiers, in case someone wants
to write one that is based on geometry (and not just vertex position)
- added editmode versions of modifier deform/apply calls and flag
to tag modifiers that support editmode
- added isFinalCalc param to applyModifier, basically a switch to let
subsurf know if it is calc'ng orco or not (so it can deal with cache
appropriately). This is kinda hacky and perhaps I can come up with
a better solution (its also a waste to do a complete subdivide just
to get vertex locations).
- changed ccgsubsurf to not preallocate hash's to be approximately correct
size... this was probably not a big performance savings but means that
the order of faces returned by the iterator can vary after the first
call, this messes up orco calculation so dropped for time being.
- minor bug fix, meshes with only key didn't get vertex normals correctly
calc'd
- updated editmesh derivedmesh to support auxiliary locations
- changed mesh_calc_modifiers to alloc deformVerts on demand
- added editmesh_calc_modifiers for calculating editmesh cage and final
derivedmesh's
- bug fix, update shadedisplist to always calc colors (even if totvert==0)
- changed load_editMesh and make_edge to build me->medge even if totedge==0
(incremental subsurf checks this)
todo: add drawFacesTex for ccgderivedmesh
So, modifiers in editmode are back (which means auto-mirror
in edit mode works now) although still not finished. Currently
no cage is computed, the cage is always the base mesh (in
other words, Optimal edge style editing is off), and the final
mesh currently includes all modifiers that work in edit mode
(including lattice and curve). At some point there will be toggles
for which modifiers affect the final/cage editmode derivedmesh's.
Also, very nice new feature is that incremental subsurf in object
mode returns a ccgderivedmesh object instead of copying to a new
displistmesh. This can make a *huge* speed difference, and is very
nice for working with deformed armatures (esp. with only small
per frame changes).
2005-07-22 09:37:15 +02:00
|
|
|
}
|
|
|
|
|
2015-07-20 16:08:06 +02:00
|
|
|
#ifdef WITH_OPENSUBDIV
|
|
|
|
/* The idea is to skip CPU-side ORCO calculation when
|
|
|
|
* we'll be using GPU backend of OpenSubdiv. This is so
|
2015-09-13 18:21:15 +02:00
|
|
|
* playback performance is kept as high as possible.
|
2015-07-20 16:08:06 +02:00
|
|
|
*/
|
2018-04-06 12:07:27 +02:00
|
|
|
static bool calc_modifiers_skip_orco(Depsgraph *depsgraph,
|
2017-10-20 17:01:35 +02:00
|
|
|
Scene *scene,
|
2016-09-05 17:08:09 +02:00
|
|
|
Object *ob,
|
2016-09-01 15:27:08 +02:00
|
|
|
bool use_render_params)
|
2015-07-20 16:08:06 +02:00
|
|
|
{
|
2016-09-01 15:27:08 +02:00
|
|
|
ModifierData *last_md = ob->modifiers.last;
|
|
|
|
const int required_mode = use_render_params ? eModifierMode_Render : eModifierMode_Realtime;
|
2015-07-20 16:08:06 +02:00
|
|
|
if (last_md != NULL &&
|
2016-09-01 15:27:08 +02:00
|
|
|
last_md->type == eModifierType_Subsurf &&
|
|
|
|
modifier_isEnabled(scene, last_md, required_mode))
|
2015-07-20 16:08:06 +02:00
|
|
|
{
|
2016-09-05 17:08:09 +02:00
|
|
|
if (U.opensubdiv_compute_type == USER_OPENSUBDIV_COMPUTE_NONE) {
|
|
|
|
return false;
|
|
|
|
}
|
2018-04-05 18:20:27 +02:00
|
|
|
else if ((ob->mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT | OB_MODE_TEXTURE_PAINT)) != 0) {
|
2016-09-05 17:08:09 +02:00
|
|
|
return false;
|
|
|
|
}
|
2018-04-06 12:07:27 +02:00
|
|
|
else if ((DEG_get_eval_flags_for_id(depsgraph, &ob->id) & DAG_EVAL_NEED_CPU) != 0) {
|
2016-09-05 17:08:09 +02:00
|
|
|
return false;
|
|
|
|
}
|
2015-08-03 20:35:43 +02:00
|
|
|
SubsurfModifierData *smd = (SubsurfModifierData *)last_md;
|
|
|
|
/* TODO(sergey): Deduplicate this with checks from subsurf_ccg.c. */
|
2016-09-05 17:08:09 +02:00
|
|
|
return smd->use_opensubdiv != 0;
|
2015-07-20 16:08:06 +02:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2018-05-30 12:56:20 +02:00
|
|
|
static void mesh_finalize_eval(Object *object)
|
|
|
|
{
|
|
|
|
Mesh *mesh = (Mesh *)object->data;
|
|
|
|
Mesh *mesh_eval = object->runtime.mesh_eval;
|
|
|
|
/* Special Tweaks for cases when evaluated mesh came from
|
|
|
|
* BKE_mesh_new_nomain_from_template().
|
|
|
|
*/
|
|
|
|
BLI_strncpy(mesh_eval->id.name, mesh->id.name, sizeof(mesh_eval->id.name));
|
|
|
|
if (mesh_eval->mat != NULL) {
|
|
|
|
MEM_freeN(mesh_eval->mat);
|
|
|
|
}
|
|
|
|
mesh_eval->mat = MEM_dupallocN(mesh->mat);
|
|
|
|
mesh_eval->totcol = mesh->totcol;
|
|
|
|
/* Make evaluated mesh to share same edit mesh pointer as original
|
|
|
|
* and copied meshes.
|
|
|
|
*/
|
|
|
|
mesh_eval->edit_btmesh = mesh->edit_btmesh;
|
|
|
|
/* Special flags to help debugging and also to allow copy-on-write core
|
|
|
|
* to understand that on re-evaluation this mesh is to be preserved and
|
|
|
|
* to be remapped back to copied original mesh when used as object data.
|
|
|
|
*/
|
|
|
|
mesh_eval->id.tag |= LIB_TAG_COPY_ON_WRITE_EVAL;
|
|
|
|
mesh_eval->id.orig_id = &mesh->id;
|
|
|
|
/* Copy autosmooth settings from original mesh.
|
|
|
|
* This is not done by BKE_mesh_new_nomain_from_template(), so need to take
|
|
|
|
* extra care here.
|
|
|
|
*/
|
|
|
|
mesh_eval->flag |= (mesh->flag & ME_AUTOSMOOTH);
|
|
|
|
mesh_eval->smoothresh = mesh->smoothresh;
|
|
|
|
/* Replace evaluated object's data with fully evaluated mesh. */
|
|
|
|
/* TODO(sergey): There was statement done by Sybren and Mai that this
|
|
|
|
* caused modifiers to be applied twice. which is weirtd and shouldn't
|
|
|
|
* really happen. But since there is no reference to the report, can not
|
|
|
|
* do much about this.
|
|
|
|
*/
|
2018-06-01 11:44:50 +02:00
|
|
|
|
|
|
|
/* Object is sometimes not evaluated!
|
|
|
|
* TODO(sergey): BAD TEMPORARY HACK FOR UNTIL WE ARE SMARTER */
|
|
|
|
if(object->id.tag & LIB_TAG_COPY_ON_WRITE) {
|
|
|
|
object->data = mesh_eval;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* evaluated will be available via: 'object->runtime.mesh_eval' */
|
|
|
|
}
|
2018-05-30 12:56:20 +02:00
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
static void mesh_build_data(
|
2018-04-06 12:07:27 +02:00
|
|
|
struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask,
|
2015-07-02 08:20:22 +02:00
|
|
|
const bool build_shapekey_layers, const bool need_mapping)
|
- shuffled editmesh derived function name/function
- added ModifierTypeInfo.freeData function
- added modifier_{new,free] utility function
- added ccgSubSurf_getUseAgeCounts to query info
- removed subsurf modifier faking (ME_SUBSURF flag is no
longer valid). subsurf modifier gets converted on file load
although there is obscure linked mesh situation where this
can go wrong, will fix shortly. this also means that some
places in the code that test/copy subsurf settings are broken
for the time being.
- shuffled modifier calculation to be simpler. note that
all modifiers are currently disabled in editmode (including
subsurf). don't worry, will return shortly.
- bug fix, build modifier didn't randomize meshes with only verts
- cleaned up subsurf_ccg and adapted for future editmode modifier
work
- added editmesh.derived{Cage,Final}, not used yet
- added SubsurfModifierData.{mCache,emCache}, will be used to cache
subsurf instead of caching in derivedmesh itself
- removed old subsurf buttons
- added do_modifiers_buttons to handle modifier events
- removed count_object counting of modifier (subsurfed) objects...
this would be nice to add back at some point but requires care.
probably requires rewrite of counting system.
New feature: Incremental Subsurf in Object Mode
The previous release introduce incremental subsurf calculation during
editmode but it was not turned on during object mode. In general it
does not make sense to have it always enabled during object mode because
it requires caching a fair amount of information about the mesh which
is a waste of memory unless the mesh is often recalculated.
However, for mesh's that have subsurfed armatures for example, or that
have other modifiers so that the mesh is essentially changing on every
frame, it makes a lot of sense to keep the subsurf'd object around and
that is what the new incremental subsurf modifier toggle is for. The
intent is that the user will enable this option for (a) a mesh that is
currently under active editing or (b) a mesh that is heavily updated
in the scene, such as a character.
I will try to write more about this feature for release, because it
has advantages and disadvantages that are not immediately obvious (the
first user reaction will be to turn it on for ever object, which is
probably not correct).
2005-07-21 22:30:33 +02:00
|
|
|
{
|
2012-11-21 01:31:47 +01:00
|
|
|
BLI_assert(ob->type == OB_MESH);
|
|
|
|
|
2013-05-18 12:24:34 +02:00
|
|
|
BKE_object_free_derived_caches(ob);
|
|
|
|
BKE_object_sculpt_modifiers_changed(ob);
|
- shuffled editmesh derived function name/function
- added ModifierTypeInfo.freeData function
- added modifier_{new,free] utility function
- added ccgSubSurf_getUseAgeCounts to query info
- removed subsurf modifier faking (ME_SUBSURF flag is no
longer valid). subsurf modifier gets converted on file load
although there is obscure linked mesh situation where this
can go wrong, will fix shortly. this also means that some
places in the code that test/copy subsurf settings are broken
for the time being.
- shuffled modifier calculation to be simpler. note that
all modifiers are currently disabled in editmode (including
subsurf). don't worry, will return shortly.
- bug fix, build modifier didn't randomize meshes with only verts
- cleaned up subsurf_ccg and adapted for future editmode modifier
work
- added editmesh.derived{Cage,Final}, not used yet
- added SubsurfModifierData.{mCache,emCache}, will be used to cache
subsurf instead of caching in derivedmesh itself
- removed old subsurf buttons
- added do_modifiers_buttons to handle modifier events
- removed count_object counting of modifier (subsurfed) objects...
this would be nice to add back at some point but requires care.
probably requires rewrite of counting system.
New feature: Incremental Subsurf in Object Mode
The previous release introduce incremental subsurf calculation during
editmode but it was not turned on during object mode. In general it
does not make sense to have it always enabled during object mode because
it requires caching a fair amount of information about the mesh which
is a waste of memory unless the mesh is often recalculated.
However, for mesh's that have subsurfed armatures for example, or that
have other modifiers so that the mesh is essentially changing on every
frame, it makes a lot of sense to keep the subsurf'd object around and
that is what the new incremental subsurf modifier toggle is for. The
intent is that the user will enable this option for (a) a mesh that is
currently under active editing or (b) a mesh that is heavily updated
in the scene, such as a character.
I will try to write more about this feature for release, because it
has advantages and disadvantages that are not immediately obvious (the
first user reaction will be to turn it on for ever object, which is
probably not correct).
2005-07-21 22:30:33 +02:00
|
|
|
|
2015-07-20 16:08:06 +02:00
|
|
|
#ifdef WITH_OPENSUBDIV
|
2018-04-06 12:07:27 +02:00
|
|
|
if (calc_modifiers_skip_orco(depsgraph, scene, ob, false)) {
|
2015-07-22 11:58:48 +02:00
|
|
|
dataMask &= ~(CD_MASK_ORCO | CD_MASK_PREVIEW_MCOL);
|
2015-07-20 16:08:06 +02:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2018-05-30 12:56:20 +02:00
|
|
|
mesh_calc_modifiers(
|
2018-05-22 19:42:41 +02:00
|
|
|
depsgraph, scene, ob, NULL, 1, need_mapping, dataMask, -1, true, build_shapekey_layers,
|
2015-07-20 16:08:06 +02:00
|
|
|
true,
|
2018-05-30 12:56:20 +02:00
|
|
|
&ob->runtime.mesh_deform_eval, &ob->runtime.mesh_eval);
|
|
|
|
|
|
|
|
mesh_finalize_eval(ob);
|
|
|
|
|
|
|
|
ob->derivedDeform = CDDM_from_mesh_ex(ob->runtime.mesh_deform_eval, CD_REFERENCE, CD_MASK_MESH);
|
|
|
|
ob->derivedFinal = CDDM_from_mesh_ex(ob->runtime.mesh_eval, CD_REFERENCE, CD_MASK_MESH);
|
2009-01-02 20:10:35 +01:00
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
DM_set_object_boundbox(ob, ob->derivedFinal);
|
2018-05-30 12:56:20 +02:00
|
|
|
/* TODO(sergey): Convert bounding box calculation to use mesh, then
|
|
|
|
* we can skip this copy.
|
|
|
|
*/
|
|
|
|
BKE_mesh_texspace_copy_from_object(ob->runtime.mesh_eval, ob);
|
2005-07-19 04:36:21 +02:00
|
|
|
|
2009-01-02 20:10:35 +01:00
|
|
|
ob->derivedFinal->needsFree = 0;
|
|
|
|
ob->derivedDeform->needsFree = 0;
|
|
|
|
ob->lastDataMask = dataMask;
|
2015-07-02 08:20:22 +02:00
|
|
|
ob->lastNeedMapping = need_mapping;
|
2012-03-14 07:30:55 +01:00
|
|
|
|
2018-04-05 18:20:27 +02:00
|
|
|
if ((ob->mode & OB_MODE_ALL_SCULPT) && ob->sculpt) {
|
2012-03-14 07:30:55 +01:00
|
|
|
/* create PBVH immediately (would be created on the fly too,
|
2012-04-22 13:54:53 +02:00
|
|
|
* but this avoids waiting on first stroke) */
|
2014-05-06 22:30:51 +02:00
|
|
|
|
2018-04-06 12:07:27 +02:00
|
|
|
BKE_sculpt_update_mesh_elements(depsgraph, scene, scene->toolsettings->sculpt, ob, false, false);
|
2012-03-14 07:30:55 +01:00
|
|
|
}
|
2013-05-30 19:36:43 +02:00
|
|
|
|
|
|
|
BLI_assert(!(ob->derivedFinal->dirty & DM_DIRTY_NORMALS));
|
- shuffled editmesh derived function name/function
- added ModifierTypeInfo.freeData function
- added modifier_{new,free] utility function
- added ccgSubSurf_getUseAgeCounts to query info
- removed subsurf modifier faking (ME_SUBSURF flag is no
longer valid). subsurf modifier gets converted on file load
although there is obscure linked mesh situation where this
can go wrong, will fix shortly. this also means that some
places in the code that test/copy subsurf settings are broken
for the time being.
- shuffled modifier calculation to be simpler. note that
all modifiers are currently disabled in editmode (including
subsurf). don't worry, will return shortly.
- bug fix, build modifier didn't randomize meshes with only verts
- cleaned up subsurf_ccg and adapted for future editmode modifier
work
- added editmesh.derived{Cage,Final}, not used yet
- added SubsurfModifierData.{mCache,emCache}, will be used to cache
subsurf instead of caching in derivedmesh itself
- removed old subsurf buttons
- added do_modifiers_buttons to handle modifier events
- removed count_object counting of modifier (subsurfed) objects...
this would be nice to add back at some point but requires care.
probably requires rewrite of counting system.
New feature: Incremental Subsurf in Object Mode
The previous release introduce incremental subsurf calculation during
editmode but it was not turned on during object mode. In general it
does not make sense to have it always enabled during object mode because
it requires caching a fair amount of information about the mesh which
is a waste of memory unless the mesh is often recalculated.
However, for mesh's that have subsurfed armatures for example, or that
have other modifiers so that the mesh is essentially changing on every
frame, it makes a lot of sense to keep the subsurf'd object around and
that is what the new incremental subsurf modifier toggle is for. The
intent is that the user will enable this option for (a) a mesh that is
currently under active editing or (b) a mesh that is heavily updated
in the scene, such as a character.
I will try to write more about this feature for release, because it
has advantages and disadvantages that are not immediately obvious (the
first user reaction will be to turn it on for ever object, which is
probably not correct).
2005-07-21 22:30:33 +02:00
|
|
|
}
|
|
|
|
|
2017-08-16 04:45:11 +02:00
|
|
|
static void editbmesh_build_data(
|
2018-04-06 12:07:27 +02:00
|
|
|
struct Depsgraph *depsgraph, Scene *scene,
|
2017-08-16 04:45:11 +02:00
|
|
|
Object *obedit, BMEditMesh *em, CustomDataMask dataMask)
|
- shuffled editmesh derived function name/function
- added ModifierTypeInfo.freeData function
- added modifier_{new,free] utility function
- added ccgSubSurf_getUseAgeCounts to query info
- removed subsurf modifier faking (ME_SUBSURF flag is no
longer valid). subsurf modifier gets converted on file load
although there is obscure linked mesh situation where this
can go wrong, will fix shortly. this also means that some
places in the code that test/copy subsurf settings are broken
for the time being.
- shuffled modifier calculation to be simpler. note that
all modifiers are currently disabled in editmode (including
subsurf). don't worry, will return shortly.
- bug fix, build modifier didn't randomize meshes with only verts
- cleaned up subsurf_ccg and adapted for future editmode modifier
work
- added editmesh.derived{Cage,Final}, not used yet
- added SubsurfModifierData.{mCache,emCache}, will be used to cache
subsurf instead of caching in derivedmesh itself
- removed old subsurf buttons
- added do_modifiers_buttons to handle modifier events
- removed count_object counting of modifier (subsurfed) objects...
this would be nice to add back at some point but requires care.
probably requires rewrite of counting system.
New feature: Incremental Subsurf in Object Mode
The previous release introduce incremental subsurf calculation during
editmode but it was not turned on during object mode. In general it
does not make sense to have it always enabled during object mode because
it requires caching a fair amount of information about the mesh which
is a waste of memory unless the mesh is often recalculated.
However, for mesh's that have subsurfed armatures for example, or that
have other modifiers so that the mesh is essentially changing on every
frame, it makes a lot of sense to keep the subsurf'd object around and
that is what the new incremental subsurf modifier toggle is for. The
intent is that the user will enable this option for (a) a mesh that is
currently under active editing or (b) a mesh that is heavily updated
in the scene, such as a character.
I will try to write more about this feature for release, because it
has advantages and disadvantages that are not immediately obvious (the
first user reaction will be to turn it on for ever object, which is
probably not correct).
2005-07-21 22:30:33 +02:00
|
|
|
{
|
2013-05-18 12:24:34 +02:00
|
|
|
BKE_object_free_derived_caches(obedit);
|
|
|
|
BKE_object_sculpt_modifiers_changed(obedit);
|
- shuffled editmesh derived function name/function
- added ModifierTypeInfo.freeData function
- added modifier_{new,free] utility function
- added ccgSubSurf_getUseAgeCounts to query info
- removed subsurf modifier faking (ME_SUBSURF flag is no
longer valid). subsurf modifier gets converted on file load
although there is obscure linked mesh situation where this
can go wrong, will fix shortly. this also means that some
places in the code that test/copy subsurf settings are broken
for the time being.
- shuffled modifier calculation to be simpler. note that
all modifiers are currently disabled in editmode (including
subsurf). don't worry, will return shortly.
- bug fix, build modifier didn't randomize meshes with only verts
- cleaned up subsurf_ccg and adapted for future editmode modifier
work
- added editmesh.derived{Cage,Final}, not used yet
- added SubsurfModifierData.{mCache,emCache}, will be used to cache
subsurf instead of caching in derivedmesh itself
- removed old subsurf buttons
- added do_modifiers_buttons to handle modifier events
- removed count_object counting of modifier (subsurfed) objects...
this would be nice to add back at some point but requires care.
probably requires rewrite of counting system.
New feature: Incremental Subsurf in Object Mode
The previous release introduce incremental subsurf calculation during
editmode but it was not turned on during object mode. In general it
does not make sense to have it always enabled during object mode because
it requires caching a fair amount of information about the mesh which
is a waste of memory unless the mesh is often recalculated.
However, for mesh's that have subsurfed armatures for example, or that
have other modifiers so that the mesh is essentially changing on every
frame, it makes a lot of sense to keep the subsurf'd object around and
that is what the new incremental subsurf modifier toggle is for. The
intent is that the user will enable this option for (a) a mesh that is
currently under active editing or (b) a mesh that is heavily updated
in the scene, such as a character.
I will try to write more about this feature for release, because it
has advantages and disadvantages that are not immediately obvious (the
first user reaction will be to turn it on for ever object, which is
probably not correct).
2005-07-21 22:30:33 +02:00
|
|
|
|
2014-02-28 10:02:30 +01:00
|
|
|
BKE_editmesh_free_derivedmesh(em);
|
- shuffled editmesh derived function name/function
- added ModifierTypeInfo.freeData function
- added modifier_{new,free] utility function
- added ccgSubSurf_getUseAgeCounts to query info
- removed subsurf modifier faking (ME_SUBSURF flag is no
longer valid). subsurf modifier gets converted on file load
although there is obscure linked mesh situation where this
can go wrong, will fix shortly. this also means that some
places in the code that test/copy subsurf settings are broken
for the time being.
- shuffled modifier calculation to be simpler. note that
all modifiers are currently disabled in editmode (including
subsurf). don't worry, will return shortly.
- bug fix, build modifier didn't randomize meshes with only verts
- cleaned up subsurf_ccg and adapted for future editmode modifier
work
- added editmesh.derived{Cage,Final}, not used yet
- added SubsurfModifierData.{mCache,emCache}, will be used to cache
subsurf instead of caching in derivedmesh itself
- removed old subsurf buttons
- added do_modifiers_buttons to handle modifier events
- removed count_object counting of modifier (subsurfed) objects...
this would be nice to add back at some point but requires care.
probably requires rewrite of counting system.
New feature: Incremental Subsurf in Object Mode
The previous release introduce incremental subsurf calculation during
editmode but it was not turned on during object mode. In general it
does not make sense to have it always enabled during object mode because
it requires caching a fair amount of information about the mesh which
is a waste of memory unless the mesh is often recalculated.
However, for mesh's that have subsurfed armatures for example, or that
have other modifiers so that the mesh is essentially changing on every
frame, it makes a lot of sense to keep the subsurf'd object around and
that is what the new incremental subsurf modifier toggle is for. The
intent is that the user will enable this option for (a) a mesh that is
currently under active editing or (b) a mesh that is heavily updated
in the scene, such as a character.
I will try to write more about this feature for release, because it
has advantages and disadvantages that are not immediately obvious (the
first user reaction will be to turn it on for ever object, which is
probably not correct).
2005-07-21 22:30:33 +02:00
|
|
|
|
2015-07-20 16:08:06 +02:00
|
|
|
#ifdef WITH_OPENSUBDIV
|
2018-04-06 12:07:27 +02:00
|
|
|
if (calc_modifiers_skip_orco(depsgraph, scene, obedit, false)) {
|
2015-07-22 11:58:48 +02:00
|
|
|
dataMask &= ~(CD_MASK_ORCO | CD_MASK_PREVIEW_MCOL);
|
2015-07-20 16:08:06 +02:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
editbmesh_calc_modifiers(
|
2018-04-06 12:07:27 +02:00
|
|
|
depsgraph, scene, obedit, em, dataMask,
|
2015-07-02 08:20:22 +02:00
|
|
|
&em->derivedCage, &em->derivedFinal);
|
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
DM_set_object_boundbox(obedit, em->derivedFinal);
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
|
2010-03-05 17:47:52 +01:00
|
|
|
em->lastDataMask = dataMask;
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
em->derivedFinal->needsFree = 0;
|
|
|
|
em->derivedCage->needsFree = 0;
|
2013-05-30 19:36:43 +02:00
|
|
|
|
|
|
|
BLI_assert(!(em->derivedFinal->dirty & DM_DIRTY_NORMALS));
|
2005-07-19 04:36:21 +02:00
|
|
|
}
|
|
|
|
|
2018-04-06 12:07:27 +02:00
|
|
|
static CustomDataMask object_get_datamask(const Depsgraph *depsgraph, Object *ob, bool *r_need_mapping)
|
2013-05-01 16:34:12 +02:00
|
|
|
{
|
2018-04-06 12:07:27 +02:00
|
|
|
ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
|
2017-11-23 16:51:49 +01:00
|
|
|
Object *actob = view_layer->basact ? view_layer->basact->object : NULL;
|
2013-05-01 16:34:12 +02:00
|
|
|
CustomDataMask mask = ob->customdata_mask;
|
2015-06-04 17:39:43 +02:00
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
if (r_need_mapping) {
|
|
|
|
*r_need_mapping = false;
|
|
|
|
}
|
2013-05-01 16:34:12 +02:00
|
|
|
|
|
|
|
if (ob == actob) {
|
2018-04-05 18:20:27 +02:00
|
|
|
bool editing = BKE_paint_select_face_test(ob);
|
2015-06-04 17:39:43 +02:00
|
|
|
|
|
|
|
/* weight paint and face select need original indices because of selection buffer drawing */
|
2015-07-02 08:20:22 +02:00
|
|
|
if (r_need_mapping) {
|
2018-04-05 18:20:27 +02:00
|
|
|
*r_need_mapping = (editing || (ob->mode & (OB_MODE_WEIGHT_PAINT | OB_MODE_VERTEX_PAINT)));
|
2015-07-02 08:20:22 +02:00
|
|
|
}
|
2015-06-04 17:39:43 +02:00
|
|
|
|
2013-05-01 16:34:12 +02:00
|
|
|
/* check if we need tfaces & mcols due to face select or texture paint */
|
2018-04-05 18:20:27 +02:00
|
|
|
if ((ob->mode & OB_MODE_TEXTURE_PAINT) || editing) {
|
2015-07-27 12:59:10 +02:00
|
|
|
mask |= CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL;
|
2013-05-01 16:34:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* check if we need mcols due to vertex paint or weightpaint */
|
2018-04-05 18:20:27 +02:00
|
|
|
if (ob->mode & OB_MODE_VERTEX_PAINT) {
|
2015-07-27 12:59:10 +02:00
|
|
|
mask |= CD_MASK_MLOOPCOL;
|
2013-05-01 16:34:12 +02:00
|
|
|
}
|
|
|
|
|
2018-04-05 18:20:27 +02:00
|
|
|
if (ob->mode & OB_MODE_WEIGHT_PAINT) {
|
2015-07-27 12:59:10 +02:00
|
|
|
mask |= CD_MASK_PREVIEW_MLOOPCOL;
|
2013-05-01 16:34:12 +02:00
|
|
|
}
|
|
|
|
|
2018-04-05 18:20:27 +02:00
|
|
|
if (ob->mode & OB_MODE_EDIT)
|
2013-05-01 16:34:12 +02:00
|
|
|
mask |= CD_MASK_MVERT_SKIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
return mask;
|
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
void makeDerivedMesh(
|
2018-04-06 12:07:27 +02:00
|
|
|
struct Depsgraph *depsgraph, Scene *scene, Object *ob, BMEditMesh *em,
|
2015-07-02 08:20:22 +02:00
|
|
|
CustomDataMask dataMask, const bool build_shapekey_layers)
|
2005-07-19 04:36:21 +02:00
|
|
|
{
|
2015-07-02 08:20:22 +02:00
|
|
|
bool need_mapping;
|
2018-04-06 12:07:27 +02:00
|
|
|
dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
|
2013-05-01 16:34:12 +02:00
|
|
|
|
2008-12-31 18:11:42 +01:00
|
|
|
if (em) {
|
2018-04-06 12:07:27 +02:00
|
|
|
editbmesh_build_data(depsgraph, scene, ob, em, dataMask);
|
2012-03-24 07:18:31 +01:00
|
|
|
}
|
|
|
|
else {
|
2018-04-06 12:07:27 +02:00
|
|
|
mesh_build_data(depsgraph, scene, ob, dataMask, build_shapekey_layers, need_mapping);
|
- shuffled editmesh derived function name/function
- added ModifierTypeInfo.freeData function
- added modifier_{new,free] utility function
- added ccgSubSurf_getUseAgeCounts to query info
- removed subsurf modifier faking (ME_SUBSURF flag is no
longer valid). subsurf modifier gets converted on file load
although there is obscure linked mesh situation where this
can go wrong, will fix shortly. this also means that some
places in the code that test/copy subsurf settings are broken
for the time being.
- shuffled modifier calculation to be simpler. note that
all modifiers are currently disabled in editmode (including
subsurf). don't worry, will return shortly.
- bug fix, build modifier didn't randomize meshes with only verts
- cleaned up subsurf_ccg and adapted for future editmode modifier
work
- added editmesh.derived{Cage,Final}, not used yet
- added SubsurfModifierData.{mCache,emCache}, will be used to cache
subsurf instead of caching in derivedmesh itself
- removed old subsurf buttons
- added do_modifiers_buttons to handle modifier events
- removed count_object counting of modifier (subsurfed) objects...
this would be nice to add back at some point but requires care.
probably requires rewrite of counting system.
New feature: Incremental Subsurf in Object Mode
The previous release introduce incremental subsurf calculation during
editmode but it was not turned on during object mode. In general it
does not make sense to have it always enabled during object mode because
it requires caching a fair amount of information about the mesh which
is a waste of memory unless the mesh is often recalculated.
However, for mesh's that have subsurfed armatures for example, or that
have other modifiers so that the mesh is essentially changing on every
frame, it makes a lot of sense to keep the subsurf'd object around and
that is what the new incremental subsurf modifier toggle is for. The
intent is that the user will enable this option for (a) a mesh that is
currently under active editing or (b) a mesh that is heavily updated
in the scene, such as a character.
I will try to write more about this feature for release, because it
has advantages and disadvantages that are not immediately obvious (the
first user reaction will be to turn it on for ever object, which is
probably not correct).
2005-07-21 22:30:33 +02:00
|
|
|
}
|
2005-07-19 04:36:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/***/
|
|
|
|
|
2017-08-16 04:45:11 +02:00
|
|
|
DerivedMesh *mesh_get_derived_final(
|
2018-04-06 12:07:27 +02:00
|
|
|
struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
|
2005-03-27 22:34:18 +02:00
|
|
|
{
|
2006-12-05 18:42:03 +01:00
|
|
|
/* if there's no derived mesh or the last data mask used doesn't include
|
|
|
|
* the data we need, rebuild the derived mesh
|
|
|
|
*/
|
2015-07-02 08:20:22 +02:00
|
|
|
bool need_mapping;
|
2018-04-06 12:07:27 +02:00
|
|
|
dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
|
2013-05-01 16:34:12 +02:00
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
if (!ob->derivedFinal ||
|
|
|
|
((dataMask & ob->lastDataMask) != dataMask) ||
|
|
|
|
(need_mapping != ob->lastNeedMapping))
|
|
|
|
{
|
2018-04-06 12:07:27 +02:00
|
|
|
mesh_build_data(depsgraph, scene, ob, dataMask, false, need_mapping);
|
2015-07-02 08:20:22 +02:00
|
|
|
}
|
2005-07-13 22:16:35 +02:00
|
|
|
|
2013-05-30 19:36:43 +02:00
|
|
|
if (ob->derivedFinal) { BLI_assert(!(ob->derivedFinal->dirty & DM_DIRTY_NORMALS)); }
|
2005-07-19 04:36:21 +02:00
|
|
|
return ob->derivedFinal;
|
2005-07-19 02:21:01 +02:00
|
|
|
}
|
|
|
|
|
2018-04-06 12:07:27 +02:00
|
|
|
DerivedMesh *mesh_get_derived_deform(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
|
2005-07-19 02:21:01 +02:00
|
|
|
{
|
2006-12-05 18:42:03 +01:00
|
|
|
/* if there's no derived mesh or the last data mask used doesn't include
|
|
|
|
* the data we need, rebuild the derived mesh
|
|
|
|
*/
|
2015-07-02 08:20:22 +02:00
|
|
|
bool need_mapping;
|
2015-06-04 17:39:43 +02:00
|
|
|
|
2018-04-06 12:07:27 +02:00
|
|
|
dataMask |= object_get_datamask(depsgraph, ob, &need_mapping);
|
2013-05-01 16:34:12 +02:00
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
if (!ob->derivedDeform ||
|
|
|
|
((dataMask & ob->lastDataMask) != dataMask) ||
|
|
|
|
(need_mapping != ob->lastNeedMapping))
|
|
|
|
{
|
2018-04-06 12:07:27 +02:00
|
|
|
mesh_build_data(depsgraph, scene, ob, dataMask, false, need_mapping);
|
2015-07-02 08:20:22 +02:00
|
|
|
}
|
2005-03-28 23:49:49 +02:00
|
|
|
|
2005-07-19 02:21:01 +02:00
|
|
|
return ob->derivedDeform;
|
2005-03-28 23:49:49 +02:00
|
|
|
}
|
|
|
|
|
2018-04-06 12:07:27 +02:00
|
|
|
DerivedMesh *mesh_create_derived_render(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask)
|
2007-01-22 00:46:00 +01:00
|
|
|
{
|
|
|
|
DerivedMesh *final;
|
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
mesh_calc_modifiers_dm(
|
2018-05-22 19:42:41 +02:00
|
|
|
depsgraph, scene, ob, NULL, 1, false, dataMask, -1, false, false, false,
|
2015-07-02 08:20:22 +02:00
|
|
|
NULL, &final);
|
2008-07-28 13:01:34 +02:00
|
|
|
|
|
|
|
return final;
|
|
|
|
}
|
|
|
|
|
2018-04-06 12:07:27 +02:00
|
|
|
DerivedMesh *mesh_create_derived_index_render(struct Depsgraph *depsgraph, Scene *scene, Object *ob, CustomDataMask dataMask, int index)
|
2008-07-28 13:01:34 +02:00
|
|
|
{
|
|
|
|
DerivedMesh *final;
|
2015-07-02 08:20:22 +02:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
mesh_calc_modifiers_dm(
|
2018-05-22 19:42:41 +02:00
|
|
|
depsgraph, scene, ob, NULL, 1, false, dataMask, index, false, false, false,
|
2015-07-02 08:20:22 +02:00
|
|
|
NULL, &final);
|
2006-11-06 02:08:26 +01:00
|
|
|
|
2005-07-19 02:21:01 +02:00
|
|
|
return final;
|
2005-07-16 23:03:28 +02:00
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
DerivedMesh *mesh_create_derived_view(
|
2018-04-06 12:07:27 +02:00
|
|
|
struct Depsgraph *depsgraph, Scene *scene,
|
2017-07-21 11:53:13 +02:00
|
|
|
Object *ob, CustomDataMask dataMask)
|
2006-09-17 07:15:56 +02:00
|
|
|
{
|
|
|
|
DerivedMesh *final;
|
|
|
|
|
2012-10-18 17:54:24 +02:00
|
|
|
/* XXX hack
|
|
|
|
* psys modifier updates particle state when called during dupli-list generation,
|
|
|
|
* which can lead to wrong transforms. This disables particle system modifier execution.
|
|
|
|
*/
|
|
|
|
ob->transflag |= OB_NO_PSYS_UPDATE;
|
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
mesh_calc_modifiers_dm(
|
2018-05-22 19:42:41 +02:00
|
|
|
depsgraph, scene, ob, NULL, 1, false, dataMask, -1, false, false, false,
|
2015-07-02 08:20:22 +02:00
|
|
|
NULL, &final);
|
2006-09-17 07:15:56 +02:00
|
|
|
|
2012-10-18 17:54:24 +02:00
|
|
|
ob->transflag &= ~OB_NO_PSYS_UPDATE;
|
|
|
|
|
2006-09-17 07:15:56 +02:00
|
|
|
return final;
|
|
|
|
}
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
DerivedMesh *mesh_create_derived_no_deform(
|
2018-04-06 12:07:27 +02:00
|
|
|
struct Depsgraph *depsgraph, Scene *scene, Object *ob,
|
2017-07-21 11:53:13 +02:00
|
|
|
float (*vertCos)[3], CustomDataMask dataMask)
|
2005-07-17 03:18:59 +02:00
|
|
|
{
|
2005-07-19 02:21:01 +02:00
|
|
|
DerivedMesh *final;
|
2007-01-22 00:46:00 +01:00
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
mesh_calc_modifiers_dm(
|
2018-05-22 19:42:41 +02:00
|
|
|
depsgraph, scene, ob, vertCos, 0, false, dataMask, -1, false, false, false,
|
2015-07-02 08:20:22 +02:00
|
|
|
NULL, &final);
|
2005-04-04 14:22:33 +02:00
|
|
|
|
2005-07-19 02:21:01 +02:00
|
|
|
return final;
|
|
|
|
}
|
2005-04-04 05:38:21 +02:00
|
|
|
|
2005-07-19 02:21:01 +02:00
|
|
|
/***/
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
DerivedMesh *editbmesh_get_derived_cage_and_final(
|
2018-04-06 12:07:27 +02:00
|
|
|
struct Depsgraph *depsgraph, Scene *scene, Object *obedit, BMEditMesh *em,
|
2015-07-02 08:20:22 +02:00
|
|
|
CustomDataMask dataMask,
|
|
|
|
/* return args */
|
|
|
|
DerivedMesh **r_final)
|
2005-07-19 02:21:01 +02:00
|
|
|
{
|
2006-12-05 18:42:03 +01:00
|
|
|
/* if there's no derived mesh or the last data mask used doesn't include
|
|
|
|
* the data we need, rebuild the derived mesh
|
|
|
|
*/
|
2018-04-06 12:07:27 +02:00
|
|
|
dataMask |= object_get_datamask(depsgraph, obedit, NULL);
|
2013-05-01 16:34:12 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (!em->derivedCage ||
|
2012-04-28 08:31:57 +02:00
|
|
|
(em->lastDataMask & dataMask) != dataMask)
|
|
|
|
{
|
2018-04-06 12:07:27 +02:00
|
|
|
editbmesh_build_data(depsgraph, scene, obedit, em, dataMask);
|
2012-04-28 08:31:57 +02:00
|
|
|
}
|
2005-03-27 22:34:18 +02:00
|
|
|
|
2014-03-15 17:24:05 +01:00
|
|
|
*r_final = em->derivedFinal;
|
2013-05-30 19:36:43 +02:00
|
|
|
if (em->derivedFinal) { BLI_assert(!(em->derivedFinal->dirty & DM_DIRTY_NORMALS)); }
|
2008-12-31 18:11:42 +01:00
|
|
|
return em->derivedCage;
|
2005-03-27 22:34:18 +02:00
|
|
|
}
|
2005-03-28 07:58:43 +02:00
|
|
|
|
2017-08-16 04:45:11 +02:00
|
|
|
DerivedMesh *editbmesh_get_derived_cage(
|
2018-04-06 12:07:27 +02:00
|
|
|
struct Depsgraph *depsgraph, Scene *scene, Object *obedit, BMEditMesh *em,
|
2017-08-16 04:45:11 +02:00
|
|
|
CustomDataMask dataMask)
|
2005-03-28 07:58:43 +02:00
|
|
|
{
|
2006-12-05 18:42:03 +01:00
|
|
|
/* if there's no derived mesh or the last data mask used doesn't include
|
|
|
|
* the data we need, rebuild the derived mesh
|
|
|
|
*/
|
2018-04-06 12:07:27 +02:00
|
|
|
dataMask |= object_get_datamask(depsgraph, obedit, NULL);
|
2013-05-01 16:34:12 +02:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (!em->derivedCage ||
|
2012-04-28 08:31:57 +02:00
|
|
|
(em->lastDataMask & dataMask) != dataMask)
|
|
|
|
{
|
2018-04-06 12:07:27 +02:00
|
|
|
editbmesh_build_data(depsgraph, scene, obedit, em, dataMask);
|
2012-04-28 08:31:57 +02:00
|
|
|
}
|
2005-03-28 07:58:43 +02:00
|
|
|
|
2008-12-31 18:11:42 +01:00
|
|
|
return em->derivedCage;
|
2005-03-28 07:58:43 +02:00
|
|
|
}
|
2005-08-06 22:44:59 +02:00
|
|
|
|
2016-06-22 13:20:09 +02:00
|
|
|
DerivedMesh *editbmesh_get_derived_base(Object *obedit, BMEditMesh *em, CustomDataMask data_mask)
|
2005-08-06 22:44:59 +02:00
|
|
|
{
|
2016-06-22 13:20:09 +02:00
|
|
|
return getEditDerivedBMesh(em, obedit, data_mask, NULL);
|
2005-08-06 22:44:59 +02:00
|
|
|
}
|
2005-09-18 15:27:12 +02:00
|
|
|
|
2014-08-01 15:42:17 +02:00
|
|
|
/***/
|
|
|
|
|
|
|
|
/* get derived mesh from an object, using editbmesh if available. */
|
|
|
|
DerivedMesh *object_get_derived_final(Object *ob, const bool for_render)
|
|
|
|
{
|
|
|
|
if (for_render) {
|
|
|
|
/* TODO(sergey): use proper derived render here in the future. */
|
|
|
|
return ob->derivedFinal;
|
|
|
|
}
|
|
|
|
|
2015-01-06 04:01:18 +01:00
|
|
|
/* only return the editmesh if its from this object because
|
|
|
|
* we don't a mesh from another object's modifier stack: T43122 */
|
2017-03-18 08:29:16 +01:00
|
|
|
if (ob->type == OB_MESH) {
|
|
|
|
Mesh *me = ob->data;
|
|
|
|
BMEditMesh *em = me->edit_btmesh;
|
|
|
|
if (em && (em->ob == ob)) {
|
|
|
|
DerivedMesh *dm = em->derivedFinal;
|
|
|
|
return dm;
|
|
|
|
}
|
2014-08-01 15:42:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return ob->derivedFinal;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-26 20:40:55 +02:00
|
|
|
/* UNUSED */
|
|
|
|
#if 0
|
2005-09-23 16:42:14 +02:00
|
|
|
|
2005-11-12 11:35:14 +01:00
|
|
|
/* ********* For those who don't grasp derived stuff! (ton) :) *************** */
|
|
|
|
|
2012-04-09 09:06:06 +02:00
|
|
|
static void make_vertexcosnos__mapFunc(void *userData, int index, const float co[3],
|
|
|
|
const float no_f[3], const short no_s[3])
|
2005-11-12 11:35:14 +01:00
|
|
|
{
|
2012-12-23 03:32:03 +01:00
|
|
|
DMCoNo *co_no = &((DMCoNo *)userData)[index];
|
2006-08-28 03:12:36 +02:00
|
|
|
|
|
|
|
/* check if we've been here before (normal should not be 0) */
|
2012-12-23 03:32:03 +01:00
|
|
|
if (!is_zero_v3(co_no->no)) {
|
|
|
|
return;
|
|
|
|
}
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2012-12-23 03:32:03 +01:00
|
|
|
copy_v3_v3(co_no->co, co);
|
2012-03-24 07:18:31 +01:00
|
|
|
if (no_f) {
|
2012-12-23 03:32:03 +01:00
|
|
|
copy_v3_v3(co_no->no, no_f);
|
2005-11-12 11:35:14 +01:00
|
|
|
}
|
|
|
|
else {
|
2012-12-23 03:32:03 +01:00
|
|
|
normal_short_to_float_v3(co_no->no, no_s);
|
2005-11-12 11:35:14 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* always returns original amount me->totvert of vertices and normals, but fully deformed and subsurfered */
|
|
|
|
/* this is needed for all code using vertexgroups (no subsurf support) */
|
|
|
|
/* it stores the normals as floats, but they can still be scaled as shorts (32767 = unit) */
|
|
|
|
/* in use now by vertex/weight paint and particle generating */
|
|
|
|
|
2012-12-15 17:13:27 +01:00
|
|
|
DMCoNo *mesh_get_mapped_verts_nors(Scene *scene, Object *ob)
|
2005-11-12 11:35:14 +01:00
|
|
|
{
|
2012-05-12 21:18:02 +02:00
|
|
|
Mesh *me = ob->data;
|
2005-11-12 15:39:14 +01:00
|
|
|
DerivedMesh *dm;
|
2012-12-15 17:13:27 +01:00
|
|
|
DMCoNo *vertexcosnos;
|
2005-11-12 11:35:14 +01:00
|
|
|
|
|
|
|
/* lets prevent crashing... */
|
2012-05-12 21:18:02 +02:00
|
|
|
if (ob->type != OB_MESH || me->totvert == 0)
|
2005-11-12 11:35:14 +01:00
|
|
|
return NULL;
|
|
|
|
|
2012-05-12 21:18:02 +02:00
|
|
|
dm = mesh_get_derived_final(scene, ob, CD_MASK_BAREMESH | CD_MASK_ORIGINDEX);
|
2005-11-12 11:35:14 +01:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (dm->foreachMappedVert) {
|
2018-01-14 22:14:20 +01:00
|
|
|
vertexcosnos = MEM_calloc_arrayN(me->totvert, sizeof(DMCoNo), "vertexcosnos map");
|
2005-11-12 11:35:14 +01:00
|
|
|
dm->foreachMappedVert(dm, make_vertexcosnos__mapFunc, vertexcosnos);
|
2005-11-23 20:19:44 +01:00
|
|
|
}
|
2005-11-12 11:35:14 +01:00
|
|
|
else {
|
2018-01-14 22:14:20 +01:00
|
|
|
DMCoNo *v_co_no = vertexcosnos = MEM_malloc_arrayN(me->totvert, sizeof(DMCoNo), "vertexcosnos map");
|
2005-11-12 11:35:14 +01:00
|
|
|
int a;
|
2012-12-15 17:13:27 +01:00
|
|
|
for (a = 0; a < me->totvert; a++, v_co_no++) {
|
|
|
|
dm->getVertCo(dm, a, v_co_no->co);
|
|
|
|
dm->getVertNo(dm, a, v_co_no->no);
|
2005-11-12 11:35:14 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Added custom vertex/edge/face data for meshes:
All data layers, including MVert/MEdge/MFace, are now managed as custom
data layers. The pointers like Mesh.mvert, Mesh.dvert or Mesh.mcol are
still used of course, but allocating, copying or freeing these arrays
should be done through the CustomData API.
Work in progress documentation on this is here:
http://mediawiki.blender.org/index.php/BlenderDev/BlenderArchitecture/CustomData
Replaced TFace by MTFace:
This is the same struct, except that it does not contain color, that now
always stays separated in MCol. This was not a good design decision to
begin with, and it is needed for adding multiple color layers later. Note
that this does mean older Blender versions will not be able to read UV
coordinates from the next release, due to an SDNA limitation.
Removed DispListMesh:
This now fully replaced by DerivedMesh. To provide access to arrays of
vertices, edges and faces, like DispListMesh does. The semantics of the
DerivedMesh.getVertArray() and similar functions were changed to return
a pointer to an array if one exists, or otherwise allocate a temporary
one. On releasing the DerivedMesh, this temporary array will be removed
automatically.
Removed ssDM and meshDM DerivedMesh backends:
The ssDM backend was for DispListMesh, so that became obsolete automatically.
The meshDM backend was replaced by the custom data backend, that now figures
out which layers need to be modified, and only duplicates those.
This changes code in many places, and overall removes 2514 lines of code.
So, there's a good chance this might break some stuff, although I've been
testing it for a few days now. The good news is, adding multiple color and
uv layers should now become easy.
2006-11-20 05:28:02 +01:00
|
|
|
dm->release(dm);
|
2005-11-12 11:35:14 +01:00
|
|
|
return vertexcosnos;
|
|
|
|
}
|
|
|
|
|
2013-06-26 20:40:55 +02:00
|
|
|
#endif
|
|
|
|
|
2014-09-04 09:53:10 +02:00
|
|
|
/* same as above but for vert coords */
|
|
|
|
typedef struct {
|
|
|
|
float (*vertexcos)[3];
|
|
|
|
BLI_bitmap *vertex_visit;
|
|
|
|
} MappedUserData;
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
static void make_vertexcos__mapFunc(
|
|
|
|
void *userData, int index, const float co[3],
|
|
|
|
const float UNUSED(no_f[3]), const short UNUSED(no_s[3]))
|
2014-09-04 09:53:10 +02:00
|
|
|
{
|
|
|
|
MappedUserData *mappedData = (MappedUserData *)userData;
|
|
|
|
|
|
|
|
if (BLI_BITMAP_TEST(mappedData->vertex_visit, index) == 0) {
|
|
|
|
/* we need coord from prototype vertex, not from copies,
|
|
|
|
* assume they stored in the beginning of vertex array stored in DM
|
|
|
|
* (mirror modifier for eg does this) */
|
|
|
|
copy_v3_v3(mappedData->vertexcos[index], co);
|
|
|
|
BLI_BITMAP_ENABLE(mappedData->vertex_visit, index);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void mesh_get_mapped_verts_coords(DerivedMesh *dm, float (*r_cos)[3], const int totcos)
|
|
|
|
{
|
|
|
|
if (dm->foreachMappedVert) {
|
|
|
|
MappedUserData userData;
|
2014-09-14 10:50:59 +02:00
|
|
|
memset(r_cos, 0, sizeof(*r_cos) * totcos);
|
2014-09-04 09:53:10 +02:00
|
|
|
userData.vertexcos = r_cos;
|
|
|
|
userData.vertex_visit = BLI_BITMAP_NEW(totcos, "vertexcos flags");
|
|
|
|
dm->foreachMappedVert(dm, make_vertexcos__mapFunc, &userData, DM_FOREACH_NOP);
|
|
|
|
MEM_freeN(userData.vertex_visit);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < totcos; i++) {
|
2014-09-25 23:51:41 +02:00
|
|
|
dm->getVertCo(dm, i, r_cos[i]);
|
2014-09-04 09:53:10 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-26 10:43:02 +02:00
|
|
|
void DM_add_named_tangent_layer_for_uv(
|
|
|
|
CustomData *uv_data, CustomData *tan_data, int numLoopData,
|
|
|
|
const char *layer_name)
|
|
|
|
{
|
|
|
|
if (CustomData_get_named_layer_index(tan_data, CD_TANGENT, layer_name) == -1 &&
|
|
|
|
CustomData_get_named_layer_index(uv_data, CD_MLOOPUV, layer_name) != -1)
|
|
|
|
{
|
|
|
|
CustomData_add_layer_named(
|
|
|
|
tan_data, CD_TANGENT, CD_CALLOC, NULL,
|
|
|
|
numLoopData, layer_name);
|
|
|
|
}
|
|
|
|
}
|
2016-01-20 05:35:51 +01:00
|
|
|
|
2016-04-26 10:43:02 +02:00
|
|
|
void DM_calc_loop_tangents(
|
|
|
|
DerivedMesh *dm, bool calc_active_tangent,
|
2017-05-24 14:33:21 +02:00
|
|
|
const char (*tangent_names)[MAX_NAME], int tangent_names_len)
|
2016-04-26 10:43:02 +02:00
|
|
|
{
|
2017-05-24 14:33:21 +02:00
|
|
|
BKE_mesh_calc_loop_tangent_ex(
|
|
|
|
dm->getVertArray(dm),
|
|
|
|
dm->getPolyArray(dm), dm->getNumPolys(dm),
|
|
|
|
dm->getLoopArray(dm),
|
|
|
|
dm->getLoopTriArray(dm), dm->getNumLoopTri(dm),
|
|
|
|
&dm->loopData,
|
|
|
|
calc_active_tangent,
|
|
|
|
tangent_names, tangent_names_len,
|
|
|
|
CustomData_get_layer(&dm->polyData, CD_NORMAL),
|
|
|
|
dm->getLoopDataArray(dm, CD_NORMAL),
|
|
|
|
dm->getVertDataArray(dm, CD_ORCO), /* may be NULL */
|
|
|
|
/* result */
|
|
|
|
&dm->loopData, dm->getNumLoops(dm),
|
|
|
|
&dm->tangent_mask);
|
|
|
|
}
|
2016-01-20 05:05:01 +01:00
|
|
|
|
2010-03-05 17:47:52 +01:00
|
|
|
/* Set object's bounding box based on DerivedMesh min/max data */
|
|
|
|
void DM_set_object_boundbox(Object *ob, DerivedMesh *dm)
|
|
|
|
{
|
|
|
|
float min[3], max[3];
|
|
|
|
|
2015-08-05 14:43:51 +02:00
|
|
|
INIT_MINMAX(min, max);
|
|
|
|
dm->getMinMax(dm, min, max);
|
2010-03-05 17:47:52 +01:00
|
|
|
|
2012-03-24 07:18:31 +01:00
|
|
|
if (!ob->bb)
|
2012-05-12 21:18:02 +02:00
|
|
|
ob->bb = MEM_callocN(sizeof(BoundBox), "DM-BoundBox");
|
2010-03-05 17:47:52 +01:00
|
|
|
|
2012-05-05 16:03:12 +02:00
|
|
|
BKE_boundbox_init_from_minmax(ob->bb, min, max);
|
2016-03-04 11:50:54 +01:00
|
|
|
|
|
|
|
ob->bb->flag &= ~BOUNDBOX_DIRTY;
|
2010-03-05 17:47:52 +01:00
|
|
|
}
|
2011-10-09 23:11:51 +02:00
|
|
|
|
2012-02-05 12:30:26 +01:00
|
|
|
void DM_init_origspace(DerivedMesh *dm)
|
|
|
|
{
|
Fix T47038: Particles in Particle Edit Mode get added in completely wrong location.
It also fixes another issue (crash) related to symmetric editing.
Quite involved, we (try to!) fix complete broken logic of parts of particle code, which would use poly index
as tessface one (or vice-versa). Issue most probably goes back to BMesh integration time...
This patch mostly fixes particle editing mode:
- Adding/removing particles when using generative modifiers (like subsurf) should now work.
- Adding/removing particles with a non-tessellated mesh (i.e. one having ngons) should also mostly work.
- X-axis-mirror-editing particles over ngons does not really work, not sure why currently.
- All this in both 'modes' (with or without using modifier stack for particles).
Tech side:
- Store a deformed-only DM in particle modifier data.
- Rename existing DM to make it clear it's a final one.
- Use deformed-only DM's tessface2poly mapping to 'solve' poly/tessface mismatches.
- Make (part of) mirror-editing code able to use a DM instead of raw mesh, so that we can mirror based on final DM
when editing particles using modifier stack (mandatory, since there is no way currently to find orig tessface
from an final DM tessface index).
Note that this patch is not really nice and clean (current particles are beyond hope on this side anyway),
it's more like some urgency bandage. Whole crap needs complete rewrite anyway,
BMesh's polygons make it really hard to work with current system (and looptri would not help much here).
Also, did not test everything possibly affected by those changes, so it needs some users' testing & validation too.
Reviewers: psy-fi
Subscribers: dfelinto, eyecandy
Maniphest Tasks: T47038
Differential Revision: https://developer.blender.org/D1685
2016-01-04 12:19:45 +01:00
|
|
|
const float default_osf[4][2] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
|
2012-02-05 12:30:26 +01:00
|
|
|
|
|
|
|
OrigSpaceLoop *lof_array = CustomData_get_layer(&dm->loopData, CD_ORIGSPACE_MLOOP);
|
|
|
|
const int numpoly = dm->getNumPolys(dm);
|
|
|
|
// const int numloop = dm->getNumLoops(dm);
|
Fix T47038: Particles in Particle Edit Mode get added in completely wrong location.
It also fixes another issue (crash) related to symmetric editing.
Quite involved, we (try to!) fix complete broken logic of parts of particle code, which would use poly index
as tessface one (or vice-versa). Issue most probably goes back to BMesh integration time...
This patch mostly fixes particle editing mode:
- Adding/removing particles when using generative modifiers (like subsurf) should now work.
- Adding/removing particles with a non-tessellated mesh (i.e. one having ngons) should also mostly work.
- X-axis-mirror-editing particles over ngons does not really work, not sure why currently.
- All this in both 'modes' (with or without using modifier stack for particles).
Tech side:
- Store a deformed-only DM in particle modifier data.
- Rename existing DM to make it clear it's a final one.
- Use deformed-only DM's tessface2poly mapping to 'solve' poly/tessface mismatches.
- Make (part of) mirror-editing code able to use a DM instead of raw mesh, so that we can mirror based on final DM
when editing particles using modifier stack (mandatory, since there is no way currently to find orig tessface
from an final DM tessface index).
Note that this patch is not really nice and clean (current particles are beyond hope on this side anyway),
it's more like some urgency bandage. Whole crap needs complete rewrite anyway,
BMesh's polygons make it really hard to work with current system (and looptri would not help much here).
Also, did not test everything possibly affected by those changes, so it needs some users' testing & validation too.
Reviewers: psy-fi
Subscribers: dfelinto, eyecandy
Maniphest Tasks: T47038
Differential Revision: https://developer.blender.org/D1685
2016-01-04 12:19:45 +01:00
|
|
|
MVert *mv = dm->getVertArray(dm);
|
|
|
|
MLoop *ml = dm->getLoopArray(dm);
|
2012-02-05 12:30:26 +01:00
|
|
|
MPoly *mp = dm->getPolyArray(dm);
|
Fix T47038: Particles in Particle Edit Mode get added in completely wrong location.
It also fixes another issue (crash) related to symmetric editing.
Quite involved, we (try to!) fix complete broken logic of parts of particle code, which would use poly index
as tessface one (or vice-versa). Issue most probably goes back to BMesh integration time...
This patch mostly fixes particle editing mode:
- Adding/removing particles when using generative modifiers (like subsurf) should now work.
- Adding/removing particles with a non-tessellated mesh (i.e. one having ngons) should also mostly work.
- X-axis-mirror-editing particles over ngons does not really work, not sure why currently.
- All this in both 'modes' (with or without using modifier stack for particles).
Tech side:
- Store a deformed-only DM in particle modifier data.
- Rename existing DM to make it clear it's a final one.
- Use deformed-only DM's tessface2poly mapping to 'solve' poly/tessface mismatches.
- Make (part of) mirror-editing code able to use a DM instead of raw mesh, so that we can mirror based on final DM
when editing particles using modifier stack (mandatory, since there is no way currently to find orig tessface
from an final DM tessface index).
Note that this patch is not really nice and clean (current particles are beyond hope on this side anyway),
it's more like some urgency bandage. Whole crap needs complete rewrite anyway,
BMesh's polygons make it really hard to work with current system (and looptri would not help much here).
Also, did not test everything possibly affected by those changes, so it needs some users' testing & validation too.
Reviewers: psy-fi
Subscribers: dfelinto, eyecandy
Maniphest Tasks: T47038
Differential Revision: https://developer.blender.org/D1685
2016-01-04 12:19:45 +01:00
|
|
|
int i, j, k;
|
|
|
|
|
|
|
|
float (*vcos_2d)[2] = NULL;
|
|
|
|
BLI_array_staticdeclare(vcos_2d, 64);
|
2012-02-05 12:30:26 +01:00
|
|
|
|
|
|
|
for (i = 0; i < numpoly; i++, mp++) {
|
Fix T47038: Particles in Particle Edit Mode get added in completely wrong location.
It also fixes another issue (crash) related to symmetric editing.
Quite involved, we (try to!) fix complete broken logic of parts of particle code, which would use poly index
as tessface one (or vice-versa). Issue most probably goes back to BMesh integration time...
This patch mostly fixes particle editing mode:
- Adding/removing particles when using generative modifiers (like subsurf) should now work.
- Adding/removing particles with a non-tessellated mesh (i.e. one having ngons) should also mostly work.
- X-axis-mirror-editing particles over ngons does not really work, not sure why currently.
- All this in both 'modes' (with or without using modifier stack for particles).
Tech side:
- Store a deformed-only DM in particle modifier data.
- Rename existing DM to make it clear it's a final one.
- Use deformed-only DM's tessface2poly mapping to 'solve' poly/tessface mismatches.
- Make (part of) mirror-editing code able to use a DM instead of raw mesh, so that we can mirror based on final DM
when editing particles using modifier stack (mandatory, since there is no way currently to find orig tessface
from an final DM tessface index).
Note that this patch is not really nice and clean (current particles are beyond hope on this side anyway),
it's more like some urgency bandage. Whole crap needs complete rewrite anyway,
BMesh's polygons make it really hard to work with current system (and looptri would not help much here).
Also, did not test everything possibly affected by those changes, so it needs some users' testing & validation too.
Reviewers: psy-fi
Subscribers: dfelinto, eyecandy
Maniphest Tasks: T47038
Differential Revision: https://developer.blender.org/D1685
2016-01-04 12:19:45 +01:00
|
|
|
OrigSpaceLoop *lof = lof_array + mp->loopstart;
|
|
|
|
|
2012-02-05 12:30:26 +01:00
|
|
|
if (mp->totloop == 3 || mp->totloop == 4) {
|
|
|
|
for (j = 0; j < mp->totloop; j++, lof++) {
|
|
|
|
copy_v2_v2(lof->uv, default_osf[j]);
|
|
|
|
}
|
|
|
|
}
|
Fix T47038: Particles in Particle Edit Mode get added in completely wrong location.
It also fixes another issue (crash) related to symmetric editing.
Quite involved, we (try to!) fix complete broken logic of parts of particle code, which would use poly index
as tessface one (or vice-versa). Issue most probably goes back to BMesh integration time...
This patch mostly fixes particle editing mode:
- Adding/removing particles when using generative modifiers (like subsurf) should now work.
- Adding/removing particles with a non-tessellated mesh (i.e. one having ngons) should also mostly work.
- X-axis-mirror-editing particles over ngons does not really work, not sure why currently.
- All this in both 'modes' (with or without using modifier stack for particles).
Tech side:
- Store a deformed-only DM in particle modifier data.
- Rename existing DM to make it clear it's a final one.
- Use deformed-only DM's tessface2poly mapping to 'solve' poly/tessface mismatches.
- Make (part of) mirror-editing code able to use a DM instead of raw mesh, so that we can mirror based on final DM
when editing particles using modifier stack (mandatory, since there is no way currently to find orig tessface
from an final DM tessface index).
Note that this patch is not really nice and clean (current particles are beyond hope on this side anyway),
it's more like some urgency bandage. Whole crap needs complete rewrite anyway,
BMesh's polygons make it really hard to work with current system (and looptri would not help much here).
Also, did not test everything possibly affected by those changes, so it needs some users' testing & validation too.
Reviewers: psy-fi
Subscribers: dfelinto, eyecandy
Maniphest Tasks: T47038
Differential Revision: https://developer.blender.org/D1685
2016-01-04 12:19:45 +01:00
|
|
|
else {
|
|
|
|
MLoop *l = &ml[mp->loopstart];
|
|
|
|
float p_nor[3], co[3];
|
|
|
|
float mat[3][3];
|
|
|
|
|
2016-05-11 13:36:42 +02:00
|
|
|
float min[2] = {FLT_MAX, FLT_MAX}, max[2] = {-FLT_MAX, -FLT_MAX};
|
Fix T47038: Particles in Particle Edit Mode get added in completely wrong location.
It also fixes another issue (crash) related to symmetric editing.
Quite involved, we (try to!) fix complete broken logic of parts of particle code, which would use poly index
as tessface one (or vice-versa). Issue most probably goes back to BMesh integration time...
This patch mostly fixes particle editing mode:
- Adding/removing particles when using generative modifiers (like subsurf) should now work.
- Adding/removing particles with a non-tessellated mesh (i.e. one having ngons) should also mostly work.
- X-axis-mirror-editing particles over ngons does not really work, not sure why currently.
- All this in both 'modes' (with or without using modifier stack for particles).
Tech side:
- Store a deformed-only DM in particle modifier data.
- Rename existing DM to make it clear it's a final one.
- Use deformed-only DM's tessface2poly mapping to 'solve' poly/tessface mismatches.
- Make (part of) mirror-editing code able to use a DM instead of raw mesh, so that we can mirror based on final DM
when editing particles using modifier stack (mandatory, since there is no way currently to find orig tessface
from an final DM tessface index).
Note that this patch is not really nice and clean (current particles are beyond hope on this side anyway),
it's more like some urgency bandage. Whole crap needs complete rewrite anyway,
BMesh's polygons make it really hard to work with current system (and looptri would not help much here).
Also, did not test everything possibly affected by those changes, so it needs some users' testing & validation too.
Reviewers: psy-fi
Subscribers: dfelinto, eyecandy
Maniphest Tasks: T47038
Differential Revision: https://developer.blender.org/D1685
2016-01-04 12:19:45 +01:00
|
|
|
float translate[2], scale[2];
|
|
|
|
|
|
|
|
BKE_mesh_calc_poly_normal(mp, l, mv, p_nor);
|
|
|
|
axis_dominant_v3_to_m3(mat, p_nor);
|
|
|
|
|
2018-02-01 02:06:57 +01:00
|
|
|
BLI_array_clear(vcos_2d);
|
Fix T47038: Particles in Particle Edit Mode get added in completely wrong location.
It also fixes another issue (crash) related to symmetric editing.
Quite involved, we (try to!) fix complete broken logic of parts of particle code, which would use poly index
as tessface one (or vice-versa). Issue most probably goes back to BMesh integration time...
This patch mostly fixes particle editing mode:
- Adding/removing particles when using generative modifiers (like subsurf) should now work.
- Adding/removing particles with a non-tessellated mesh (i.e. one having ngons) should also mostly work.
- X-axis-mirror-editing particles over ngons does not really work, not sure why currently.
- All this in both 'modes' (with or without using modifier stack for particles).
Tech side:
- Store a deformed-only DM in particle modifier data.
- Rename existing DM to make it clear it's a final one.
- Use deformed-only DM's tessface2poly mapping to 'solve' poly/tessface mismatches.
- Make (part of) mirror-editing code able to use a DM instead of raw mesh, so that we can mirror based on final DM
when editing particles using modifier stack (mandatory, since there is no way currently to find orig tessface
from an final DM tessface index).
Note that this patch is not really nice and clean (current particles are beyond hope on this side anyway),
it's more like some urgency bandage. Whole crap needs complete rewrite anyway,
BMesh's polygons make it really hard to work with current system (and looptri would not help much here).
Also, did not test everything possibly affected by those changes, so it needs some users' testing & validation too.
Reviewers: psy-fi
Subscribers: dfelinto, eyecandy
Maniphest Tasks: T47038
Differential Revision: https://developer.blender.org/D1685
2016-01-04 12:19:45 +01:00
|
|
|
BLI_array_reserve(vcos_2d, mp->totloop);
|
|
|
|
for (j = 0; j < mp->totloop; j++, l++) {
|
|
|
|
mul_v3_m3v3(co, mat, mv[l->v].co);
|
|
|
|
copy_v2_v2(vcos_2d[j], co);
|
|
|
|
|
|
|
|
for (k = 0; k < 2; k++) {
|
|
|
|
if (co[k] > max[k])
|
|
|
|
max[k] = co[k];
|
|
|
|
else if (co[k] < min[k])
|
|
|
|
min[k] = co[k];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Brings min to (0, 0). */
|
|
|
|
negate_v2_v2(translate, min);
|
|
|
|
|
|
|
|
/* Scale will bring max to (1, 1). */
|
|
|
|
sub_v2_v2v2(scale, max, min);
|
|
|
|
if (scale[0] == 0.0f)
|
|
|
|
scale[0] = 1e-9f;
|
|
|
|
if (scale[1] == 0.0f)
|
|
|
|
scale[1] = 1e-9f;
|
|
|
|
invert_v2(scale);
|
|
|
|
|
|
|
|
/* Finally, transform all vcos_2d into ((0, 0), (1, 1)) square and assing them as origspace. */
|
|
|
|
for (j = 0; j < mp->totloop; j++, lof++) {
|
|
|
|
add_v2_v2v2(lof->uv, vcos_2d[j], translate);
|
|
|
|
mul_v2_v2(lof->uv, scale);
|
|
|
|
}
|
|
|
|
}
|
2012-02-05 12:30:26 +01:00
|
|
|
}
|
2012-04-01 17:02:19 +02:00
|
|
|
|
|
|
|
dm->dirty |= DM_DIRTY_TESS_CDLAYERS;
|
Fix T47038: Particles in Particle Edit Mode get added in completely wrong location.
It also fixes another issue (crash) related to symmetric editing.
Quite involved, we (try to!) fix complete broken logic of parts of particle code, which would use poly index
as tessface one (or vice-versa). Issue most probably goes back to BMesh integration time...
This patch mostly fixes particle editing mode:
- Adding/removing particles when using generative modifiers (like subsurf) should now work.
- Adding/removing particles with a non-tessellated mesh (i.e. one having ngons) should also mostly work.
- X-axis-mirror-editing particles over ngons does not really work, not sure why currently.
- All this in both 'modes' (with or without using modifier stack for particles).
Tech side:
- Store a deformed-only DM in particle modifier data.
- Rename existing DM to make it clear it's a final one.
- Use deformed-only DM's tessface2poly mapping to 'solve' poly/tessface mismatches.
- Make (part of) mirror-editing code able to use a DM instead of raw mesh, so that we can mirror based on final DM
when editing particles using modifier stack (mandatory, since there is no way currently to find orig tessface
from an final DM tessface index).
Note that this patch is not really nice and clean (current particles are beyond hope on this side anyway),
it's more like some urgency bandage. Whole crap needs complete rewrite anyway,
BMesh's polygons make it really hard to work with current system (and looptri would not help much here).
Also, did not test everything possibly affected by those changes, so it needs some users' testing & validation too.
Reviewers: psy-fi
Subscribers: dfelinto, eyecandy
Maniphest Tasks: T47038
Differential Revision: https://developer.blender.org/D1685
2016-01-04 12:19:45 +01:00
|
|
|
BLI_array_free(vcos_2d);
|
2012-02-05 12:30:26 +01:00
|
|
|
}
|
|
|
|
|
2018-05-11 09:53:52 +02:00
|
|
|
static void mesh_init_origspace(Mesh *mesh)
|
|
|
|
{
|
|
|
|
const float default_osf[4][2] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
|
|
|
|
|
|
|
|
OrigSpaceLoop *lof_array = CustomData_get_layer(&mesh->ldata, CD_ORIGSPACE_MLOOP);
|
|
|
|
const int numpoly = mesh->totpoly;
|
|
|
|
// const int numloop = mesh->totloop;
|
|
|
|
MVert *mv = mesh->mvert;
|
|
|
|
MLoop *ml = mesh->mloop;
|
|
|
|
MPoly *mp = mesh->mpoly;
|
|
|
|
int i, j, k;
|
|
|
|
|
|
|
|
float (*vcos_2d)[2] = NULL;
|
|
|
|
BLI_array_staticdeclare(vcos_2d, 64);
|
|
|
|
|
|
|
|
for (i = 0; i < numpoly; i++, mp++) {
|
|
|
|
OrigSpaceLoop *lof = lof_array + mp->loopstart;
|
|
|
|
|
|
|
|
if (mp->totloop == 3 || mp->totloop == 4) {
|
|
|
|
for (j = 0; j < mp->totloop; j++, lof++) {
|
|
|
|
copy_v2_v2(lof->uv, default_osf[j]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
MLoop *l = &ml[mp->loopstart];
|
|
|
|
float p_nor[3], co[3];
|
|
|
|
float mat[3][3];
|
|
|
|
|
|
|
|
float min[2] = {FLT_MAX, FLT_MAX}, max[2] = {-FLT_MAX, -FLT_MAX};
|
|
|
|
float translate[2], scale[2];
|
|
|
|
|
|
|
|
BKE_mesh_calc_poly_normal(mp, l, mv, p_nor);
|
|
|
|
axis_dominant_v3_to_m3(mat, p_nor);
|
|
|
|
|
|
|
|
BLI_array_clear(vcos_2d);
|
|
|
|
BLI_array_reserve(vcos_2d, mp->totloop);
|
|
|
|
for (j = 0; j < mp->totloop; j++, l++) {
|
|
|
|
mul_v3_m3v3(co, mat, mv[l->v].co);
|
|
|
|
copy_v2_v2(vcos_2d[j], co);
|
|
|
|
|
|
|
|
for (k = 0; k < 2; k++) {
|
|
|
|
if (co[k] > max[k])
|
|
|
|
max[k] = co[k];
|
|
|
|
else if (co[k] < min[k])
|
|
|
|
min[k] = co[k];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Brings min to (0, 0). */
|
|
|
|
negate_v2_v2(translate, min);
|
|
|
|
|
|
|
|
/* Scale will bring max to (1, 1). */
|
|
|
|
sub_v2_v2v2(scale, max, min);
|
|
|
|
if (scale[0] == 0.0f)
|
|
|
|
scale[0] = 1e-9f;
|
|
|
|
if (scale[1] == 0.0f)
|
|
|
|
scale[1] = 1e-9f;
|
|
|
|
invert_v2(scale);
|
|
|
|
|
|
|
|
/* Finally, transform all vcos_2d into ((0, 0), (1, 1)) square and assing them as origspace. */
|
|
|
|
for (j = 0; j < mp->totloop; j++, lof++) {
|
|
|
|
add_v2_v2v2(lof->uv, vcos_2d[j], translate);
|
|
|
|
mul_v2_v2(lof->uv, scale);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-22 17:53:18 +02:00
|
|
|
BKE_mesh_tessface_clear(mesh);
|
2018-05-11 09:53:52 +02:00
|
|
|
BLI_array_free(vcos_2d);
|
|
|
|
}
|
2012-02-05 12:30:26 +01:00
|
|
|
|
|
|
|
|
2012-01-19 01:18:25 +01:00
|
|
|
/* derivedmesh info printing function,
|
|
|
|
* to help track down differences DM output */
|
|
|
|
|
|
|
|
#ifndef NDEBUG
|
|
|
|
#include "BLI_dynstr.h"
|
|
|
|
|
2015-07-02 08:20:22 +02:00
|
|
|
static void dm_debug_info_layers(
|
|
|
|
DynStr *dynstr, DerivedMesh *dm, CustomData *cd,
|
|
|
|
void *(*getElemDataArray)(DerivedMesh *, int))
|
2012-01-19 01:18:25 +01:00
|
|
|
{
|
|
|
|
int type;
|
|
|
|
|
|
|
|
for (type = 0; type < CD_NUMTYPES; type++) {
|
2013-05-30 15:13:43 +02:00
|
|
|
if (CustomData_has_layer(cd, type)) {
|
|
|
|
/* note: doesnt account for multiple layers */
|
2012-01-19 01:18:25 +01:00
|
|
|
const char *name = CustomData_layertype_name(type);
|
|
|
|
const int size = CustomData_sizeof(type);
|
2013-05-30 15:13:43 +02:00
|
|
|
const void *pt = getElemDataArray(dm, type);
|
|
|
|
const int pt_size = pt ? (int)(MEM_allocN_len(pt) / size) : 0;
|
2012-01-19 01:18:25 +01:00
|
|
|
const char *structname;
|
|
|
|
int structnum;
|
|
|
|
CustomData_file_write_info(type, &structname, &structnum);
|
|
|
|
BLI_dynstr_appendf(dynstr,
|
|
|
|
" dict(name='%s', struct='%s', type=%d, ptr='%p', elem=%d, length=%d),\n",
|
2015-01-13 19:10:18 +01:00
|
|
|
name, structname, type, (const void *)pt, size, pt_size);
|
2012-01-19 01:18:25 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
char *DM_debug_info(DerivedMesh *dm)
|
|
|
|
{
|
2012-05-12 21:18:02 +02:00
|
|
|
DynStr *dynstr = BLI_dynstr_new();
|
2012-01-19 01:18:25 +01:00
|
|
|
char *ret;
|
|
|
|
const char *tstr;
|
|
|
|
|
|
|
|
BLI_dynstr_appendf(dynstr, "{\n");
|
|
|
|
BLI_dynstr_appendf(dynstr, " 'ptr': '%p',\n", (void *)dm);
|
|
|
|
switch (dm->type) {
|
|
|
|
case DM_TYPE_CDDM: tstr = "DM_TYPE_CDDM"; break;
|
2012-01-19 12:31:31 +01:00
|
|
|
case DM_TYPE_EDITBMESH: tstr = "DM_TYPE_EDITMESH"; break;
|
2012-01-19 01:18:25 +01:00
|
|
|
case DM_TYPE_CCGDM: tstr = "DM_TYPE_CCGDM"; break;
|
|
|
|
default: tstr = "UNKNOWN"; break;
|
|
|
|
}
|
|
|
|
BLI_dynstr_appendf(dynstr, " 'type': '%s',\n", tstr);
|
|
|
|
BLI_dynstr_appendf(dynstr, " 'numVertData': %d,\n", dm->numVertData);
|
|
|
|
BLI_dynstr_appendf(dynstr, " 'numEdgeData': %d,\n", dm->numEdgeData);
|
2012-01-19 12:31:31 +01:00
|
|
|
BLI_dynstr_appendf(dynstr, " 'numTessFaceData': %d,\n", dm->numTessFaceData);
|
|
|
|
BLI_dynstr_appendf(dynstr, " 'numPolyData': %d,\n", dm->numPolyData);
|
2012-01-19 01:18:25 +01:00
|
|
|
BLI_dynstr_appendf(dynstr, " 'deformedOnly': %d,\n", dm->deformedOnly);
|
|
|
|
|
|
|
|
BLI_dynstr_appendf(dynstr, " 'vertexLayers': (\n");
|
2013-05-30 15:13:43 +02:00
|
|
|
dm_debug_info_layers(dynstr, dm, &dm->vertData, dm->getVertDataArray);
|
2012-02-05 12:30:26 +01:00
|
|
|
BLI_dynstr_appendf(dynstr, " ),\n");
|
|
|
|
|
2012-01-19 01:18:25 +01:00
|
|
|
BLI_dynstr_appendf(dynstr, " 'edgeLayers': (\n");
|
2013-05-30 15:13:43 +02:00
|
|
|
dm_debug_info_layers(dynstr, dm, &dm->edgeData, dm->getEdgeDataArray);
|
2012-01-19 01:18:25 +01:00
|
|
|
BLI_dynstr_appendf(dynstr, " ),\n");
|
|
|
|
|
2013-05-30 15:13:43 +02:00
|
|
|
BLI_dynstr_appendf(dynstr, " 'loopLayers': (\n");
|
|
|
|
dm_debug_info_layers(dynstr, dm, &dm->loopData, dm->getLoopDataArray);
|
2012-01-19 12:31:31 +01:00
|
|
|
BLI_dynstr_appendf(dynstr, " ),\n");
|
|
|
|
|
2012-02-05 12:30:26 +01:00
|
|
|
BLI_dynstr_appendf(dynstr, " 'polyLayers': (\n");
|
2013-05-30 15:13:43 +02:00
|
|
|
dm_debug_info_layers(dynstr, dm, &dm->polyData, dm->getPolyDataArray);
|
|
|
|
BLI_dynstr_appendf(dynstr, " ),\n");
|
|
|
|
|
|
|
|
BLI_dynstr_appendf(dynstr, " 'tessFaceLayers': (\n");
|
|
|
|
dm_debug_info_layers(dynstr, dm, &dm->faceData, dm->getTessFaceDataArray);
|
2012-01-19 01:18:25 +01:00
|
|
|
BLI_dynstr_appendf(dynstr, " ),\n");
|
|
|
|
|
|
|
|
BLI_dynstr_appendf(dynstr, "}\n");
|
|
|
|
|
|
|
|
ret = BLI_dynstr_get_cstring(dynstr);
|
|
|
|
BLI_dynstr_free(dynstr);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void DM_debug_print(DerivedMesh *dm)
|
|
|
|
{
|
|
|
|
char *str = DM_debug_info(dm);
|
2012-03-18 07:01:33 +01:00
|
|
|
puts(str);
|
2012-01-19 01:18:25 +01:00
|
|
|
fflush(stdout);
|
2012-01-19 05:00:27 +01:00
|
|
|
MEM_freeN(str);
|
2012-01-19 01:18:25 +01:00
|
|
|
}
|
|
|
|
|
2012-09-03 04:41:12 +02:00
|
|
|
void DM_debug_print_cdlayers(CustomData *data)
|
|
|
|
{
|
|
|
|
int i;
|
2015-01-13 19:10:18 +01:00
|
|
|
const CustomDataLayer *layer;
|
2012-09-03 04:41:12 +02:00
|
|
|
|
|
|
|
printf("{\n");
|
|
|
|
|
|
|
|
for (i = 0, layer = data->layers; i < data->totlayer; i++, layer++) {
|
|
|
|
|
|
|
|
const char *name = CustomData_layertype_name(layer->type);
|
|
|
|
const int size = CustomData_sizeof(layer->type);
|
|
|
|
const char *structname;
|
|
|
|
int structnum;
|
|
|
|
CustomData_file_write_info(layer->type, &structname, &structnum);
|
|
|
|
printf(" dict(name='%s', struct='%s', type=%d, ptr='%p', elem=%d, length=%d),\n",
|
2015-01-13 19:10:18 +01:00
|
|
|
name, structname, layer->type, (const void *)layer->data, size, (int)(MEM_allocN_len(layer->data) / size));
|
2012-09-03 04:41:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
printf("}\n");
|
|
|
|
}
|
|
|
|
|
2013-09-04 03:29:34 +02:00
|
|
|
bool DM_is_valid(DerivedMesh *dm)
|
|
|
|
{
|
|
|
|
const bool do_verbose = true;
|
|
|
|
const bool do_fixes = false;
|
|
|
|
|
|
|
|
bool is_valid = true;
|
2013-11-25 20:39:14 +01:00
|
|
|
bool changed = true;
|
2013-09-04 03:29:34 +02:00
|
|
|
|
|
|
|
is_valid &= BKE_mesh_validate_all_customdata(
|
|
|
|
dm->getVertDataLayout(dm),
|
|
|
|
dm->getEdgeDataLayout(dm),
|
|
|
|
dm->getLoopDataLayout(dm),
|
|
|
|
dm->getPolyDataLayout(dm),
|
2015-02-05 14:03:01 +01:00
|
|
|
false, /* setting mask here isn't useful, gives false positives */
|
2013-11-25 20:39:14 +01:00
|
|
|
do_verbose, do_fixes, &changed);
|
2013-09-04 03:29:34 +02:00
|
|
|
|
|
|
|
is_valid &= BKE_mesh_validate_arrays(
|
|
|
|
NULL,
|
|
|
|
dm->getVertArray(dm), dm->getNumVerts(dm),
|
|
|
|
dm->getEdgeArray(dm), dm->getNumEdges(dm),
|
|
|
|
dm->getTessFaceArray(dm), dm->getNumTessFaces(dm),
|
|
|
|
dm->getLoopArray(dm), dm->getNumLoops(dm),
|
|
|
|
dm->getPolyArray(dm), dm->getNumPolys(dm),
|
|
|
|
dm->getVertDataArray(dm, CD_MDEFORMVERT),
|
2013-11-25 20:39:14 +01:00
|
|
|
do_verbose, do_fixes, &changed);
|
2013-09-04 03:29:34 +02:00
|
|
|
|
2013-11-25 20:39:14 +01:00
|
|
|
BLI_assert(changed == false);
|
2013-09-04 03:29:34 +02:00
|
|
|
|
|
|
|
return is_valid;
|
|
|
|
}
|
|
|
|
|
2012-01-19 01:18:25 +01:00
|
|
|
#endif /* NDEBUG */
|
2014-05-03 15:58:37 +02:00
|
|
|
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
MVert *DM_get_vert_array(DerivedMesh *dm, bool *allocated)
|
|
|
|
{
|
|
|
|
CustomData *vert_data = dm->getVertDataLayout(dm);
|
|
|
|
MVert *mvert = CustomData_get_layer(vert_data, CD_MVERT);
|
|
|
|
*allocated = false;
|
|
|
|
|
|
|
|
if (mvert == NULL) {
|
2018-01-14 22:14:20 +01:00
|
|
|
mvert = MEM_malloc_arrayN(dm->getNumVerts(dm), sizeof(MVert), "dmvh vert data array");
|
2014-05-03 15:58:37 +02:00
|
|
|
dm->copyVertArray(dm, mvert);
|
|
|
|
*allocated = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return mvert;
|
|
|
|
}
|
|
|
|
|
|
|
|
MEdge *DM_get_edge_array(DerivedMesh *dm, bool *allocated)
|
|
|
|
{
|
|
|
|
CustomData *edge_data = dm->getEdgeDataLayout(dm);
|
|
|
|
MEdge *medge = CustomData_get_layer(edge_data, CD_MEDGE);
|
|
|
|
*allocated = false;
|
|
|
|
|
|
|
|
if (medge == NULL) {
|
2018-01-14 22:14:20 +01:00
|
|
|
medge = MEM_malloc_arrayN(dm->getNumEdges(dm), sizeof(MEdge), "dm medge data array");
|
2014-05-03 15:58:37 +02:00
|
|
|
dm->copyEdgeArray(dm, medge);
|
|
|
|
*allocated = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return medge;
|
|
|
|
}
|
|
|
|
|
2015-07-23 07:17:26 +02:00
|
|
|
MLoop *DM_get_loop_array(DerivedMesh *dm, bool *r_allocated)
|
2014-05-03 15:58:37 +02:00
|
|
|
{
|
2015-08-24 16:43:13 +02:00
|
|
|
CustomData *loop_data = dm->getLoopDataLayout(dm);
|
2014-05-03 15:58:37 +02:00
|
|
|
MLoop *mloop = CustomData_get_layer(loop_data, CD_MLOOP);
|
2015-07-23 07:17:26 +02:00
|
|
|
*r_allocated = false;
|
2014-05-03 15:58:37 +02:00
|
|
|
|
|
|
|
if (mloop == NULL) {
|
2018-01-14 22:14:20 +01:00
|
|
|
mloop = MEM_malloc_arrayN(dm->getNumLoops(dm), sizeof(MLoop), "dm loop data array");
|
2014-05-03 15:58:37 +02:00
|
|
|
dm->copyLoopArray(dm, mloop);
|
2015-07-23 07:17:26 +02:00
|
|
|
*r_allocated = true;
|
2014-05-03 15:58:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return mloop;
|
|
|
|
}
|
|
|
|
|
2015-07-23 07:17:26 +02:00
|
|
|
MPoly *DM_get_poly_array(DerivedMesh *dm, bool *r_allocated)
|
2014-05-03 15:58:37 +02:00
|
|
|
{
|
|
|
|
CustomData *poly_data = dm->getPolyDataLayout(dm);
|
|
|
|
MPoly *mpoly = CustomData_get_layer(poly_data, CD_MPOLY);
|
2015-07-23 07:17:26 +02:00
|
|
|
*r_allocated = false;
|
2014-05-03 15:58:37 +02:00
|
|
|
|
|
|
|
if (mpoly == NULL) {
|
2018-01-14 22:14:20 +01:00
|
|
|
mpoly = MEM_malloc_arrayN(dm->getNumPolys(dm), sizeof(MPoly), "dm poly data array");
|
2014-05-03 15:58:37 +02:00
|
|
|
dm->copyPolyArray(dm, mpoly);
|
2015-07-23 07:17:26 +02:00
|
|
|
*r_allocated = true;
|
2014-05-03 15:58:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return mpoly;
|
|
|
|
}
|
|
|
|
|
2015-07-23 07:17:26 +02:00
|
|
|
MFace *DM_get_tessface_array(DerivedMesh *dm, bool *r_allocated)
|
2014-05-03 15:58:37 +02:00
|
|
|
{
|
|
|
|
CustomData *tessface_data = dm->getTessFaceDataLayout(dm);
|
|
|
|
MFace *mface = CustomData_get_layer(tessface_data, CD_MFACE);
|
2015-07-23 07:17:26 +02:00
|
|
|
*r_allocated = false;
|
2014-05-03 15:58:37 +02:00
|
|
|
|
|
|
|
if (mface == NULL) {
|
|
|
|
int numTessFaces = dm->getNumTessFaces(dm);
|
|
|
|
|
|
|
|
if (numTessFaces > 0) {
|
2018-01-14 22:14:20 +01:00
|
|
|
mface = MEM_malloc_arrayN(numTessFaces, sizeof(MFace), "bvh mface data array");
|
2014-05-03 15:58:37 +02:00
|
|
|
dm->copyTessFaceArray(dm, mface);
|
2015-07-23 07:17:26 +02:00
|
|
|
*r_allocated = true;
|
2014-05-03 15:58:37 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return mface;
|
|
|
|
}
|