Subdiv: CCG, initialize grid mask from paint mask
This commit is contained in:
parent
da800621ed
commit
b32832a7e8
|
@ -43,6 +43,31 @@ struct DMFlagMat;
|
|||
struct Mesh;
|
||||
struct Subdiv;
|
||||
|
||||
/* =============================================================================
|
||||
* Masks.
|
||||
*/
|
||||
|
||||
/* Functor which evaluates mask value at a given (u, v) of given ptex face. */
|
||||
typedef struct SubdivCCGMask {
|
||||
float (*eval_mask)(struct SubdivCCGMask *mask,
|
||||
const int ptex_face_index,
|
||||
const float u, const float v);
|
||||
|
||||
/* Free the data, not the evaluator itself. */
|
||||
void (*free)(struct SubdivCCGMask *mask);
|
||||
|
||||
void *user_data;
|
||||
} SubdivCCGMask;
|
||||
|
||||
/* Return true if mesh has mask and evaluator can be used. */
|
||||
bool BKE_subdiv_ccg_mask_init_from_paint(
|
||||
SubdivCCGMask *mask_evaluator,
|
||||
const struct Mesh *mesh);
|
||||
|
||||
/* =============================================================================
|
||||
* SubdivCCG.
|
||||
*/
|
||||
|
||||
typedef struct SubdivToCCGSettings {
|
||||
/* Resolution at which regular ptex (created for quad polygon) are being
|
||||
* evaluated. This defines how many vertices final mesh will have: every
|
||||
|
@ -190,7 +215,8 @@ typedef struct SubdivCCG {
|
|||
*/
|
||||
struct SubdivCCG *BKE_subdiv_to_ccg(
|
||||
struct Subdiv *subdiv,
|
||||
const SubdivToCCGSettings *settings);
|
||||
const SubdivToCCGSettings *settings,
|
||||
SubdivCCGMask *mask_evaluator);
|
||||
|
||||
/* Destroy CCG representation of subdivision surface. */
|
||||
void BKE_subdiv_ccg_destroy(SubdivCCG *subdiv_ccg);
|
||||
|
|
|
@ -195,6 +195,7 @@ set(SRC
|
|||
intern/studiolight.c
|
||||
intern/subdiv.c
|
||||
intern/subdiv_ccg.c
|
||||
intern/subdiv_ccg_mask.c
|
||||
intern/subdiv_converter.c
|
||||
intern/subdiv_converter_mesh.c
|
||||
intern/subdiv_displacement.c
|
||||
|
|
|
@ -183,6 +183,7 @@ typedef struct CCGEvalGridsData {
|
|||
SubdivCCG *subdiv_ccg;
|
||||
Subdiv *subdiv;
|
||||
int *face_ptex_offset;
|
||||
SubdivCCGMask *mask_evaluator;
|
||||
} CCGEvalGridsData;
|
||||
|
||||
static void subdiv_ccg_eval_grid_element(
|
||||
|
@ -207,6 +208,16 @@ static void subdiv_ccg_eval_grid_element(
|
|||
BKE_subdiv_eval_limit_point(
|
||||
subdiv, ptex_face_index, u, v, (float *)element);
|
||||
}
|
||||
if (subdiv_ccg->has_mask) {
|
||||
float *mask_value_ptr = (float *)(element + subdiv_ccg->mask_offset);
|
||||
if (data->mask_evaluator != NULL) {
|
||||
*mask_value_ptr = data->mask_evaluator->eval_mask(
|
||||
data->mask_evaluator, ptex_face_index, u, v);
|
||||
}
|
||||
else {
|
||||
*mask_value_ptr = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BLI_INLINE void rotate_corner_to_quad(
|
||||
|
@ -320,7 +331,8 @@ static void subdiv_ccg_eval_grids_task(
|
|||
|
||||
static bool subdiv_ccg_evaluate_grids(
|
||||
SubdivCCG *subdiv_ccg,
|
||||
Subdiv *subdiv)
|
||||
Subdiv *subdiv,
|
||||
SubdivCCGMask *mask_evaluator)
|
||||
{
|
||||
OpenSubdiv_TopologyRefiner *topology_refiner = subdiv->topology_refiner;
|
||||
const int num_faces = topology_refiner->getNumFaces(topology_refiner);
|
||||
|
@ -329,6 +341,7 @@ static bool subdiv_ccg_evaluate_grids(
|
|||
data.subdiv_ccg = subdiv_ccg;
|
||||
data.subdiv = subdiv;
|
||||
data.face_ptex_offset = BKE_subdiv_face_ptex_offset_get(subdiv);
|
||||
data.mask_evaluator = mask_evaluator;
|
||||
/* Threaded grids evaluation. */
|
||||
ParallelRangeSettings parallel_range_settings;
|
||||
BLI_parallel_range_settings_defaults(¶llel_range_settings);
|
||||
|
@ -626,7 +639,8 @@ static void subdiv_ccg_init_faces_neighborhood(SubdivCCG *subdiv_ccg)
|
|||
|
||||
SubdivCCG *BKE_subdiv_to_ccg(
|
||||
Subdiv *subdiv,
|
||||
const SubdivToCCGSettings *settings)
|
||||
const SubdivToCCGSettings *settings,
|
||||
SubdivCCGMask *mask_evaluator)
|
||||
{
|
||||
BKE_subdiv_stats_begin(&subdiv->stats, SUBDIV_STATS_SUBDIV_TO_CCG);
|
||||
SubdivCCG *subdiv_ccg = MEM_callocN(sizeof(SubdivCCG), "subdiv ccg");
|
||||
|
@ -638,7 +652,7 @@ SubdivCCG *BKE_subdiv_to_ccg(
|
|||
subdiv_ccg_alloc_elements(subdiv_ccg, subdiv);
|
||||
subdiv_ccg_init_faces(subdiv_ccg);
|
||||
subdiv_ccg_init_faces_neighborhood(subdiv_ccg);
|
||||
if (!subdiv_ccg_evaluate_grids(subdiv_ccg, subdiv)) {
|
||||
if (!subdiv_ccg_evaluate_grids(subdiv_ccg, subdiv, mask_evaluator)) {
|
||||
BKE_subdiv_ccg_destroy(subdiv_ccg);
|
||||
BKE_subdiv_stats_end(&subdiv->stats, SUBDIV_STATS_SUBDIV_TO_CCG);
|
||||
return NULL;
|
||||
|
@ -660,7 +674,14 @@ Mesh *BKE_subdiv_to_ccg_mesh(
|
|||
}
|
||||
}
|
||||
BKE_subdiv_stats_end(&subdiv->stats, SUBDIV_STATS_SUBDIV_TO_CCG);
|
||||
SubdivCCG *subdiv_ccg = BKE_subdiv_to_ccg(subdiv, settings);
|
||||
SubdivCCGMask mask_evaluator;
|
||||
bool has_mask = BKE_subdiv_ccg_mask_init_from_paint(
|
||||
&mask_evaluator, coarse_mesh);
|
||||
SubdivCCG *subdiv_ccg = BKE_subdiv_to_ccg(
|
||||
subdiv, settings, has_mask ? &mask_evaluator : NULL);
|
||||
if (has_mask) {
|
||||
mask_evaluator.free(&mask_evaluator);
|
||||
}
|
||||
if (subdiv_ccg == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
@ -0,0 +1,241 @@
|
|||
/*
|
||||
* ***** BEGIN GPL LICENSE BLOCK *****
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* The Original Code is Copyright (C) 2018 by Blender Foundation.
|
||||
* All rights reserved.
|
||||
*
|
||||
* Contributor(s): Sergey Sharybin.
|
||||
*
|
||||
* ***** END GPL LICENSE BLOCK *****
|
||||
*/
|
||||
|
||||
/** \file blender/blenkernel/intern/subdiv_ccg_mask.c
|
||||
* \ingroup bke
|
||||
*/
|
||||
|
||||
#include "BKE_subdiv_ccg.h"
|
||||
|
||||
#include "DNA_mesh_types.h"
|
||||
#include "DNA_meshdata_types.h"
|
||||
#include "DNA_modifier_types.h"
|
||||
#include "DNA_object_types.h"
|
||||
|
||||
#include "BLI_utildefines.h"
|
||||
#include "BLI_math_vector.h"
|
||||
|
||||
#include "BKE_customdata.h"
|
||||
|
||||
#include "MEM_guardedalloc.h"
|
||||
|
||||
typedef struct PolyCornerIndex {
|
||||
int poly_index;
|
||||
int corner;
|
||||
} PolyCornerIndex;
|
||||
|
||||
typedef struct GridPaintMaskData {
|
||||
// int grid_size;
|
||||
const MPoly *mpoly;
|
||||
const GridPaintMask *grid_paint_mask;
|
||||
/* Indexed by ptex face index, contains polygon/corner which corresponds
|
||||
* to it.
|
||||
*
|
||||
* NOTE: For quad polygon this is an index of first corner only, since
|
||||
* there we only have one ptex.
|
||||
*/
|
||||
PolyCornerIndex *ptex_poly_corner;
|
||||
} GridPaintMaskData;
|
||||
|
||||
/* Coordinates within grid has different convention from PTex coordinates.
|
||||
* This function converts the latter ones to former.
|
||||
*/
|
||||
BLI_INLINE void ptex_uv_to_grid_uv(const float ptex_u, const float ptex_v,
|
||||
float *r_grid_u, float *r_grid_v)
|
||||
{
|
||||
*r_grid_u = 1.0f - ptex_v;
|
||||
*r_grid_v = 1.0f - ptex_u;
|
||||
}
|
||||
|
||||
/* Simplified version of mdisp_rot_face_to_crn, only handles quad and
|
||||
* works in normalized coordinates.
|
||||
*
|
||||
* NOTE: Output coordinates are in ptex coordinates.
|
||||
*/
|
||||
BLI_INLINE int rotate_quad_to_corner(const float u, const float v,
|
||||
float *r_u, float *r_v)
|
||||
{
|
||||
int corner;
|
||||
if (u <= 0.5f && v <= 0.5f) {
|
||||
corner = 0;
|
||||
*r_u = 2.0f * u;
|
||||
*r_v = 2.0f * v;
|
||||
}
|
||||
else if (u > 0.5f && v <= 0.5f) {
|
||||
corner = 1;
|
||||
*r_u = 2.0f * v;
|
||||
*r_v = 2.0f * (1.0f - u);
|
||||
}
|
||||
else if (u > 0.5f && v > 0.5f) {
|
||||
corner = 2;
|
||||
*r_u = 2.0f * (1.0f - u);
|
||||
*r_v = 2.0f * (1.0f - v);
|
||||
}
|
||||
else if (u <= 0.5f && v >= 0.5f) {
|
||||
corner = 3;
|
||||
*r_u = 2.0f * (1.0f - v);
|
||||
*r_v = 2.0f * u;
|
||||
}
|
||||
else {
|
||||
BLI_assert(!"Unexpected corner configuration");
|
||||
}
|
||||
return corner;
|
||||
}
|
||||
|
||||
static int mask_get_grid_and_coord(
|
||||
SubdivCCGMask *mask_evaluator,
|
||||
const int ptex_face_index, const float u, const float v,
|
||||
const GridPaintMask **r_mask_grid,
|
||||
float *grid_u, float *grid_v)
|
||||
{
|
||||
GridPaintMaskData *data = mask_evaluator->user_data;
|
||||
const PolyCornerIndex *poly_corner =
|
||||
&data->ptex_poly_corner[ptex_face_index];
|
||||
const MPoly *poly = &data->mpoly[poly_corner->poly_index];
|
||||
const int start_grid_index = poly->loopstart + poly_corner->corner;
|
||||
int corner = 0;
|
||||
if (poly->totloop == 4) {
|
||||
float corner_u, corner_v;
|
||||
corner = rotate_quad_to_corner(u, v, &corner_u, &corner_v);
|
||||
*r_mask_grid =
|
||||
&data->grid_paint_mask[start_grid_index + corner];
|
||||
ptex_uv_to_grid_uv(corner_u, corner_v, grid_u, grid_v);
|
||||
}
|
||||
else {
|
||||
*r_mask_grid =
|
||||
&data->grid_paint_mask[start_grid_index];
|
||||
ptex_uv_to_grid_uv(u, v, grid_u, grid_v);
|
||||
}
|
||||
return corner;
|
||||
}
|
||||
|
||||
BLI_INLINE float read_mask_grid(const GridPaintMask *mask_grid,
|
||||
const float grid_u, const float grid_v)
|
||||
{
|
||||
if (mask_grid->data == NULL) {
|
||||
return 0;
|
||||
}
|
||||
const int grid_size = (1 << (mask_grid->level - 1)) + 1;
|
||||
const int x = (grid_u * (grid_size - 1) + 0.5f);
|
||||
const int y = (grid_v * (grid_size - 1) + 0.5f);
|
||||
return mask_grid->data[y * grid_size + x];
|
||||
}
|
||||
|
||||
static float eval_mask(SubdivCCGMask *mask_evaluator,
|
||||
const int ptex_face_index,
|
||||
const float u, const float v)
|
||||
{
|
||||
const GridPaintMask *mask_grid;
|
||||
float grid_u, grid_v;
|
||||
mask_get_grid_and_coord(mask_evaluator,
|
||||
ptex_face_index, u, v,
|
||||
&mask_grid,
|
||||
&grid_u, &grid_v);
|
||||
return read_mask_grid(mask_grid, grid_u, grid_v);
|
||||
}
|
||||
|
||||
static void free_mask_data(SubdivCCGMask *mask_evaluator)
|
||||
{
|
||||
GridPaintMaskData *data = mask_evaluator->user_data;
|
||||
MEM_freeN(data->ptex_poly_corner);
|
||||
MEM_freeN(data);
|
||||
}
|
||||
|
||||
/* TODO(sergey): This seems to be generally used information, which almost
|
||||
* worth adding to a subdiv itself, with possible cache of the value.
|
||||
*/
|
||||
static int count_num_ptex_faces(const Mesh *mesh)
|
||||
{
|
||||
int num_ptex_faces = 0;
|
||||
const MPoly *mpoly = mesh->mpoly;
|
||||
for (int poly_index = 0; poly_index < mesh->totpoly; poly_index++) {
|
||||
const MPoly *poly = &mpoly[poly_index];
|
||||
num_ptex_faces += (poly->totloop == 4) ? 1 : poly->totloop;
|
||||
}
|
||||
return num_ptex_faces;
|
||||
}
|
||||
|
||||
static void displacement_data_init_mapping(SubdivCCGMask *mask_evaluator,
|
||||
const Mesh *mesh)
|
||||
{
|
||||
GridPaintMaskData *data = mask_evaluator->user_data;
|
||||
const MPoly *mpoly = mesh->mpoly;
|
||||
const int num_ptex_faces = count_num_ptex_faces(mesh);
|
||||
/* Allocate memory. */
|
||||
data->ptex_poly_corner = MEM_malloc_arrayN(num_ptex_faces,
|
||||
sizeof(*data->ptex_poly_corner),
|
||||
"ptex poly corner");
|
||||
/* Fill in offsets. */
|
||||
int ptex_face_index = 0;
|
||||
PolyCornerIndex *ptex_poly_corner = data->ptex_poly_corner;
|
||||
for (int poly_index = 0; poly_index < mesh->totpoly; poly_index++) {
|
||||
const MPoly *poly = &mpoly[poly_index];
|
||||
if (poly->totloop == 4) {
|
||||
ptex_poly_corner[ptex_face_index].poly_index = poly_index;
|
||||
ptex_poly_corner[ptex_face_index].corner = 0;
|
||||
ptex_face_index++;
|
||||
}
|
||||
else {
|
||||
for (int corner = 0; corner < poly->totloop; corner++) {
|
||||
ptex_poly_corner[ptex_face_index].poly_index = poly_index;
|
||||
ptex_poly_corner[ptex_face_index].corner = corner;
|
||||
ptex_face_index++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void displacement_init_data(SubdivCCGMask *mask_evaluator,
|
||||
const Mesh *mesh)
|
||||
{
|
||||
GridPaintMaskData *data = mask_evaluator->user_data;
|
||||
data->mpoly = mesh->mpoly;
|
||||
data->grid_paint_mask =
|
||||
CustomData_get_layer(&mesh->ldata, CD_GRID_PAINT_MASK);
|
||||
displacement_data_init_mapping(mask_evaluator, mesh);
|
||||
}
|
||||
|
||||
static void displacement_init_functions(SubdivCCGMask *mask_evaluator)
|
||||
{
|
||||
mask_evaluator->eval_mask = eval_mask;
|
||||
mask_evaluator->free = free_mask_data;
|
||||
}
|
||||
|
||||
bool BKE_subdiv_ccg_mask_init_from_paint(
|
||||
SubdivCCGMask *mask_evaluator,
|
||||
const struct Mesh *mesh)
|
||||
{
|
||||
GridPaintMask *grid_paint_mask =
|
||||
CustomData_get_layer(&mesh->ldata, CD_GRID_PAINT_MASK);
|
||||
if (grid_paint_mask == NULL) {
|
||||
return false;
|
||||
}
|
||||
/* Allocate all required memory. */
|
||||
mask_evaluator->user_data =MEM_callocN(sizeof(GridPaintMaskData),
|
||||
"mask from grid data");
|
||||
displacement_init_data(mask_evaluator, mesh);
|
||||
displacement_init_functions(mask_evaluator);
|
||||
return true;
|
||||
}
|
|
@ -420,7 +420,7 @@ void BKE_subdiv_displacement_attach_from_multires(
|
|||
const Mesh *mesh,
|
||||
const MultiresModifierData *mmd)
|
||||
{
|
||||
/* Make sure we dont' have previously assigned displacement. */
|
||||
/* Make sure we don't have previously assigned displacement. */
|
||||
BKE_subdiv_displacement_detach(subdiv);
|
||||
/* Allocate all required memory. */
|
||||
SubdivDisplacement *displacement = MEM_callocN(sizeof(SubdivDisplacement),
|
||||
|
|
Loading…
Reference in New Issue