Code cleanup: use bools
This commit is contained in:
parent
03d053da4c
commit
27e86ed832
|
@ -111,7 +111,8 @@ float *BKE_curve_make_orco(struct Scene *scene, struct Object *ob, int *r_numVer
|
|||
float *BKE_curve_surf_make_orco(struct Object *ob);
|
||||
|
||||
void BKE_curve_bevelList_make(struct Object *ob, struct ListBase *nurbs, bool for_render);
|
||||
void BKE_curve_bevel_make(struct Scene *scene, struct Object *ob, struct ListBase *disp, int forRender, int renderResolution);
|
||||
void BKE_curve_bevel_make(struct Scene *scene, struct Object *ob, struct ListBase *disp,
|
||||
const bool for_render, const bool use_render_resolution);
|
||||
|
||||
void BKE_curve_forward_diff_bezier(float q0, float q1, float q2, float q3, float *p, int it, int stride);
|
||||
|
||||
|
|
|
@ -88,9 +88,11 @@ void BKE_displist_count(struct ListBase *lb, int *totvert, int *totface, int *to
|
|||
void BKE_displist_free(struct ListBase *lb);
|
||||
bool BKE_displist_has_faces(struct ListBase *lb);
|
||||
|
||||
void BKE_displist_make_surf(struct Scene *scene, struct Object *ob, struct ListBase *dispbase, struct DerivedMesh **derivedFinal, int forRender, int forOrco, int renderResolution);
|
||||
void BKE_displist_make_curveTypes(struct Scene *scene, struct Object *ob, int forOrco);
|
||||
void BKE_displist_make_curveTypes_forRender(struct Scene *scene, struct Object *ob, struct ListBase *dispbase, struct DerivedMesh **derivedFinal, int forOrco, int renderResolution);
|
||||
void BKE_displist_make_surf(struct Scene *scene, struct Object *ob, struct ListBase *dispbase, struct DerivedMesh **r_dm_final,
|
||||
const bool for_render, const bool for_orco, const bool use_render_resolution);
|
||||
void BKE_displist_make_curveTypes(struct Scene *scene, struct Object *ob, const bool for_orco);
|
||||
void BKE_displist_make_curveTypes_forRender(struct Scene *scene, struct Object *ob, struct ListBase *dispbase, struct DerivedMesh **r_dm_final,
|
||||
const bool for_orco, const bool use_render_resolution);
|
||||
void BKE_displist_make_curveTypes_forOrco(struct Scene *scene, struct Object *ob, struct ListBase *dispbase);
|
||||
void BKE_displist_make_mball(struct EvaluationContext *eval_ctx, struct Scene *scene, struct Object *ob);
|
||||
void BKE_displist_make_mball_forRender(struct EvaluationContext *eval_ctx, struct Scene *scene, struct Object *ob, struct ListBase *dispbase);
|
||||
|
@ -101,7 +103,8 @@ void BKE_displist_fill(struct ListBase *dispbase, struct ListBase *to, const flo
|
|||
float BKE_displist_calc_taper(struct Scene *scene, struct Object *taperobj, int cur, int tot);
|
||||
|
||||
/* add Orco layer to the displist object which has got derived mesh and return orco */
|
||||
float *BKE_displist_make_orco(struct Scene *scene, struct Object *ob, struct DerivedMesh *derivedFinal, int forRender, int renderResolution);
|
||||
float *BKE_displist_make_orco(struct Scene *scene, struct Object *ob, struct DerivedMesh *dm_final,
|
||||
const bool for_render, const bool use_render_resolution);
|
||||
|
||||
void BKE_displist_minmax(struct ListBase *dispbase, float min[3], float max[3]);
|
||||
|
||||
|
|
|
@ -122,7 +122,7 @@ typedef struct ShrinkwrapCalcData {
|
|||
} ShrinkwrapCalcData;
|
||||
|
||||
void shrinkwrapModifier_deform(struct ShrinkwrapModifierData *smd, struct Object *ob, struct DerivedMesh *dm,
|
||||
float (*vertexCos)[3], int numVerts, bool forRender);
|
||||
float (*vertexCos)[3], int numVerts, bool for_render);
|
||||
|
||||
/*
|
||||
* This function casts a ray in the given BVHTree.. but it takes into consideration the space_transform, that is:
|
||||
|
@ -134,9 +134,10 @@ void shrinkwrapModifier_deform(struct ShrinkwrapModifierData *smd, struct Object
|
|||
* Thus it provides an easy way to cast the same ray across several trees
|
||||
* (where each tree was built on its own coords space)
|
||||
*/
|
||||
int BKE_shrinkwrap_project_normal(char options, const float vert[3], const float dir[3],
|
||||
const SpaceTransform *transf, BVHTree *tree, BVHTreeRayHit *hit,
|
||||
BVHTree_RayCastCallback callback, void *userdata);
|
||||
bool BKE_shrinkwrap_project_normal(
|
||||
char options, const float vert[3], const float dir[3],
|
||||
const SpaceTransform *transf, BVHTree *tree, BVHTreeRayHit *hit,
|
||||
BVHTree_RayCastCallback callback, void *userdata);
|
||||
|
||||
/*
|
||||
* NULL initializers to local data
|
||||
|
|
|
@ -1620,7 +1620,8 @@ float *BKE_curve_make_orco(Scene *scene, Object *ob, int *r_numVerts)
|
|||
|
||||
/* ***************** BEVEL ****************** */
|
||||
|
||||
void BKE_curve_bevel_make(Scene *scene, Object *ob, ListBase *disp, int forRender, int renderResolution)
|
||||
void BKE_curve_bevel_make(Scene *scene, Object *ob, ListBase *disp,
|
||||
const bool for_render, const bool use_render_resolution)
|
||||
{
|
||||
DispList *dl, *dlnew;
|
||||
Curve *bevcu, *cu;
|
||||
|
@ -1643,8 +1644,8 @@ void BKE_curve_bevel_make(Scene *scene, Object *ob, ListBase *disp, int forRende
|
|||
facx = cu->bevobj->size[0];
|
||||
facy = cu->bevobj->size[1];
|
||||
|
||||
if (forRender) {
|
||||
BKE_displist_make_curveTypes_forRender(scene, cu->bevobj, &bevdisp, NULL, 0, renderResolution);
|
||||
if (for_render) {
|
||||
BKE_displist_make_curveTypes_forRender(scene, cu->bevobj, &bevdisp, NULL, false, use_render_resolution);
|
||||
dl = bevdisp.first;
|
||||
}
|
||||
else if (cu->bevobj->curve_cache) {
|
||||
|
|
|
@ -302,7 +302,8 @@ bool BKE_displist_surfindex_get(DispList *dl, int a, int *b, int *p1, int *p2, i
|
|||
|
||||
/* ****************** make displists ********************* */
|
||||
|
||||
static void curve_to_displist(Curve *cu, ListBase *nubase, ListBase *dispbase, int forRender, int renderResolution)
|
||||
static void curve_to_displist(Curve *cu, ListBase *nubase, ListBase *dispbase,
|
||||
const bool for_render, const bool use_render_resolution)
|
||||
{
|
||||
Nurb *nu;
|
||||
DispList *dl;
|
||||
|
@ -310,12 +311,12 @@ static void curve_to_displist(Curve *cu, ListBase *nubase, ListBase *dispbase, i
|
|||
BPoint *bp;
|
||||
float *data;
|
||||
int a, len, resolu;
|
||||
const int editmode = (!forRender && (cu->editnurb || cu->editfont));
|
||||
const bool editmode = (!for_render && (cu->editnurb || cu->editfont));
|
||||
|
||||
nu = nubase->first;
|
||||
while (nu) {
|
||||
if (nu->hide == 0 || editmode == 0) {
|
||||
if (renderResolution && cu->resolu_ren != 0)
|
||||
if (nu->hide == 0 || editmode == false) {
|
||||
if (use_render_resolution && cu->resolu_ren != 0)
|
||||
resolu = cu->resolu_ren;
|
||||
else
|
||||
resolu = nu->resolu;
|
||||
|
@ -748,14 +749,15 @@ void BKE_displist_make_mball_forRender(EvaluationContext *eval_ctx, Scene *scene
|
|||
object_deform_mball(ob, dispbase);
|
||||
}
|
||||
|
||||
static ModifierData *curve_get_tessellate_point(Scene *scene, Object *ob, int renderResolution, int editmode)
|
||||
static ModifierData *curve_get_tessellate_point(Scene *scene, Object *ob,
|
||||
const bool use_render_resolution, const bool editmode)
|
||||
{
|
||||
VirtualModifierData virtualModifierData;
|
||||
ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
|
||||
ModifierData *pretessellatePoint;
|
||||
int required_mode;
|
||||
|
||||
if (renderResolution)
|
||||
if (use_render_resolution)
|
||||
required_mode = eModifierMode_Render;
|
||||
else
|
||||
required_mode = eModifierMode_Realtime;
|
||||
|
@ -790,14 +792,14 @@ static ModifierData *curve_get_tessellate_point(Scene *scene, Object *ob, int re
|
|||
}
|
||||
|
||||
static void curve_calc_modifiers_pre(Scene *scene, Object *ob, ListBase *nurb,
|
||||
int forRender, int renderResolution)
|
||||
const bool for_render, const bool use_render_resolution)
|
||||
{
|
||||
VirtualModifierData virtualModifierData;
|
||||
ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
|
||||
ModifierData *pretessellatePoint;
|
||||
Curve *cu = ob->data;
|
||||
int numVerts = 0;
|
||||
const int editmode = (!forRender && (cu->editnurb || cu->editfont));
|
||||
const bool editmode = (!for_render && (cu->editnurb || cu->editfont));
|
||||
ModifierApplyFlag app_flag = 0;
|
||||
float (*deformedVerts)[3] = NULL;
|
||||
float *keyVerts = NULL;
|
||||
|
@ -807,14 +809,14 @@ static void curve_calc_modifiers_pre(Scene *scene, Object *ob, ListBase *nurb,
|
|||
|
||||
if (editmode)
|
||||
app_flag |= MOD_APPLY_USECACHE;
|
||||
if (renderResolution) {
|
||||
if (use_render_resolution) {
|
||||
app_flag |= MOD_APPLY_RENDER;
|
||||
required_mode = eModifierMode_Render;
|
||||
}
|
||||
else
|
||||
required_mode = eModifierMode_Realtime;
|
||||
|
||||
pretessellatePoint = curve_get_tessellate_point(scene, ob, renderResolution, editmode);
|
||||
pretessellatePoint = curve_get_tessellate_point(scene, ob, use_render_resolution, editmode);
|
||||
|
||||
if (editmode)
|
||||
required_mode |= eModifierMode_Editmode;
|
||||
|
@ -900,28 +902,28 @@ static void displist_apply_allverts(ListBase *dispbase, float (*allverts)[3])
|
|||
}
|
||||
|
||||
static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *nurb,
|
||||
ListBase *dispbase, DerivedMesh **derivedFinal,
|
||||
int forRender, int renderResolution)
|
||||
ListBase *dispbase, DerivedMesh **r_dm_final,
|
||||
const bool for_render, const bool use_render_resolution)
|
||||
{
|
||||
VirtualModifierData virtualModifierData;
|
||||
ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
|
||||
ModifierData *pretessellatePoint;
|
||||
Curve *cu = ob->data;
|
||||
int required_mode = 0, totvert = 0;
|
||||
int editmode = (!forRender && (cu->editnurb || cu->editfont));
|
||||
const bool editmode = (!for_render && (cu->editnurb || cu->editfont));
|
||||
DerivedMesh *dm = NULL, *ndm;
|
||||
float (*vertCos)[3] = NULL;
|
||||
int useCache = !forRender;
|
||||
int useCache = !for_render;
|
||||
ModifierApplyFlag app_flag = 0;
|
||||
|
||||
if (renderResolution) {
|
||||
if (use_render_resolution) {
|
||||
app_flag |= MOD_APPLY_RENDER;
|
||||
required_mode = eModifierMode_Render;
|
||||
}
|
||||
else
|
||||
required_mode = eModifierMode_Realtime;
|
||||
|
||||
pretessellatePoint = curve_get_tessellate_point(scene, ob, renderResolution, editmode);
|
||||
pretessellatePoint = curve_get_tessellate_point(scene, ob, use_render_resolution, editmode);
|
||||
|
||||
if (editmode)
|
||||
required_mode |= eModifierMode_Editmode;
|
||||
|
@ -930,8 +932,8 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *nurb,
|
|||
md = pretessellatePoint->next;
|
||||
}
|
||||
|
||||
if (derivedFinal && *derivedFinal) {
|
||||
(*derivedFinal)->release(*derivedFinal);
|
||||
if (r_dm_final && *r_dm_final) {
|
||||
(*r_dm_final)->release(*r_dm_final);
|
||||
}
|
||||
|
||||
for (; md; md = md->next) {
|
||||
|
@ -966,7 +968,7 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *nurb,
|
|||
}
|
||||
}
|
||||
else {
|
||||
if (!derivedFinal) {
|
||||
if (!r_dm_final) {
|
||||
/* makeDisplistCurveTypes could be used for beveling, where derived mesh
|
||||
* is totally unnecessary, so we could stop modifiers applying
|
||||
* when we found constructive modifier but derived mesh is unwanted result
|
||||
|
@ -1033,7 +1035,7 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *nurb,
|
|||
}
|
||||
}
|
||||
|
||||
if (derivedFinal) {
|
||||
if (r_dm_final) {
|
||||
if (dm) {
|
||||
/* see: mesh_calc_modifiers */
|
||||
if (dm->getNumTessFaces(dm) == 0) {
|
||||
|
@ -1049,7 +1051,7 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *nurb,
|
|||
CDDM_calc_normals_mapping_ex(dm, (dm->dirty & DM_DIRTY_NORMALS) ? false : true);
|
||||
}
|
||||
}
|
||||
(*derivedFinal) = dm;
|
||||
(*r_dm_final) = dm;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1125,7 +1127,8 @@ static void add_orco_dm(Object *ob, DerivedMesh *dm, DerivedMesh *orcodm)
|
|||
DM_add_vert_layer(dm, CD_ORCO, CD_ASSIGN, orco);
|
||||
}
|
||||
|
||||
static void curve_calc_orcodm(Scene *scene, Object *ob, DerivedMesh *derivedFinal, int forRender, int renderResolution)
|
||||
static void curve_calc_orcodm(Scene *scene, Object *ob, DerivedMesh *dm_final,
|
||||
const bool for_render, const bool use_render_resolution)
|
||||
{
|
||||
/* this function represents logic of mesh's orcodm calculation
|
||||
* for displist-based objects
|
||||
|
@ -1135,18 +1138,18 @@ static void curve_calc_orcodm(Scene *scene, Object *ob, DerivedMesh *derivedFina
|
|||
ModifierData *pretessellatePoint;
|
||||
Curve *cu = ob->data;
|
||||
int required_mode;
|
||||
int editmode = (!forRender && (cu->editnurb || cu->editfont));
|
||||
const bool editmode = (!for_render && (cu->editnurb || cu->editfont));
|
||||
DerivedMesh *ndm, *orcodm = NULL;
|
||||
ModifierApplyFlag app_flag = MOD_APPLY_ORCO;
|
||||
|
||||
if (renderResolution) {
|
||||
if (use_render_resolution) {
|
||||
app_flag |= MOD_APPLY_RENDER;
|
||||
required_mode = eModifierMode_Render;
|
||||
}
|
||||
else
|
||||
required_mode = eModifierMode_Realtime;
|
||||
|
||||
pretessellatePoint = curve_get_tessellate_point(scene, ob, renderResolution, editmode);
|
||||
pretessellatePoint = curve_get_tessellate_point(scene, ob, use_render_resolution, editmode);
|
||||
|
||||
if (editmode)
|
||||
required_mode |= eModifierMode_Editmode;
|
||||
|
@ -1186,13 +1189,14 @@ static void curve_calc_orcodm(Scene *scene, Object *ob, DerivedMesh *derivedFina
|
|||
}
|
||||
|
||||
/* add an orco layer if needed */
|
||||
add_orco_dm(ob, derivedFinal, orcodm);
|
||||
add_orco_dm(ob, dm_final, orcodm);
|
||||
|
||||
orcodm->release(orcodm);
|
||||
}
|
||||
|
||||
void BKE_displist_make_surf(Scene *scene, Object *ob, ListBase *dispbase,
|
||||
DerivedMesh **derivedFinal, int forRender, int forOrco, int renderResolution)
|
||||
DerivedMesh **r_dm_final,
|
||||
const bool for_render, const bool for_orco, const bool use_render_resolution)
|
||||
{
|
||||
ListBase nubase = {NULL, NULL};
|
||||
Nurb *nu;
|
||||
|
@ -1201,21 +1205,21 @@ void BKE_displist_make_surf(Scene *scene, Object *ob, ListBase *dispbase,
|
|||
float *data;
|
||||
int len;
|
||||
|
||||
if (!forRender && cu->editnurb) {
|
||||
if (!for_render && cu->editnurb) {
|
||||
BKE_nurbList_duplicate(&nubase, BKE_curve_editNurbs_get(cu));
|
||||
}
|
||||
else {
|
||||
BKE_nurbList_duplicate(&nubase, &cu->nurb);
|
||||
}
|
||||
|
||||
if (!forOrco)
|
||||
curve_calc_modifiers_pre(scene, ob, &nubase, forRender, renderResolution);
|
||||
if (!for_orco)
|
||||
curve_calc_modifiers_pre(scene, ob, &nubase, for_render, use_render_resolution);
|
||||
|
||||
for (nu = nubase.first; nu; nu = nu->next) {
|
||||
if (forRender || nu->hide == 0) {
|
||||
if (for_render || nu->hide == 0) {
|
||||
int resolu = nu->resolu, resolv = nu->resolv;
|
||||
|
||||
if (renderResolution) {
|
||||
if (use_render_resolution) {
|
||||
if (cu->resolu_ren)
|
||||
resolu = cu->resolu_ren;
|
||||
if (cu->resolv_ren)
|
||||
|
@ -1274,9 +1278,9 @@ void BKE_displist_make_surf(Scene *scene, Object *ob, ListBase *dispbase,
|
|||
}
|
||||
}
|
||||
|
||||
if (!forOrco) {
|
||||
curve_calc_modifiers_post(scene, ob, &nubase, dispbase, derivedFinal,
|
||||
forRender, renderResolution);
|
||||
if (!for_orco) {
|
||||
curve_calc_modifiers_post(scene, ob, &nubase, dispbase, r_dm_final,
|
||||
for_render, use_render_resolution);
|
||||
}
|
||||
|
||||
BKE_nurbList_free(&nubase);
|
||||
|
@ -1361,7 +1365,8 @@ static void fillBevelCap(Nurb *nu, DispList *dlb, float *prev_fp, ListBase *disp
|
|||
}
|
||||
|
||||
static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispbase,
|
||||
DerivedMesh **derivedFinal, int forRender, int forOrco, int renderResolution)
|
||||
DerivedMesh **r_dm_final,
|
||||
const bool for_render, const bool for_orco, const bool use_render_resolution)
|
||||
{
|
||||
Curve *cu = ob->data;
|
||||
|
||||
|
@ -1369,7 +1374,7 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
|
|||
if (!ELEM3(ob->type, OB_SURF, OB_CURVE, OB_FONT)) return;
|
||||
|
||||
if (ob->type == OB_SURF) {
|
||||
BKE_displist_make_surf(scene, ob, dispbase, derivedFinal, forRender, forOrco, renderResolution);
|
||||
BKE_displist_make_surf(scene, ob, dispbase, r_dm_final, for_render, for_orco, use_render_resolution);
|
||||
}
|
||||
else if (ELEM(ob->type, OB_CURVE, OB_FONT)) {
|
||||
ListBase dlbev;
|
||||
|
@ -1381,7 +1386,7 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
|
|||
* If the calculation happens for orco, we should never free data which
|
||||
* was needed before and only not needed for orco calculation.
|
||||
*/
|
||||
if (!forOrco) {
|
||||
if (!for_orco) {
|
||||
if (ob->curve_cache->path) free_path(ob->curve_cache->path);
|
||||
ob->curve_cache->path = NULL;
|
||||
}
|
||||
|
@ -1393,17 +1398,17 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
|
|||
BKE_nurbList_duplicate(&nubase, BKE_curve_nurbs_get(cu));
|
||||
}
|
||||
|
||||
if (!forOrco)
|
||||
curve_calc_modifiers_pre(scene, ob, &nubase, forRender, renderResolution);
|
||||
if (!for_orco)
|
||||
curve_calc_modifiers_pre(scene, ob, &nubase, for_render, use_render_resolution);
|
||||
|
||||
BKE_curve_bevelList_make(ob, &nubase, forRender != FALSE);
|
||||
BKE_curve_bevelList_make(ob, &nubase, for_render != FALSE);
|
||||
|
||||
/* If curve has no bevel will return nothing */
|
||||
BKE_curve_bevel_make(scene, ob, &dlbev, forRender, renderResolution);
|
||||
BKE_curve_bevel_make(scene, ob, &dlbev, for_render, use_render_resolution);
|
||||
|
||||
/* no bevel or extrude, and no width correction? */
|
||||
if (!dlbev.first && cu->width == 1.0f) {
|
||||
curve_to_displist(cu, &nubase, dispbase, forRender, renderResolution);
|
||||
curve_to_displist(cu, &nubase, dispbase, for_render, use_render_resolution);
|
||||
}
|
||||
else {
|
||||
float widfac = cu->width - 1.0f;
|
||||
|
@ -1578,7 +1583,7 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
|
|||
curve_to_filledpoly(cu, &nubase, dispbase);
|
||||
}
|
||||
|
||||
if (!forOrco) {
|
||||
if (!for_orco) {
|
||||
if ((cu->flag & CU_PATH) ||
|
||||
DAG_get_eval_flags_for_object(scene, ob) & DAG_EVAL_NEED_CURVE_PATH)
|
||||
{
|
||||
|
@ -1586,8 +1591,8 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
|
|||
}
|
||||
}
|
||||
|
||||
if (!forOrco)
|
||||
curve_calc_modifiers_post(scene, ob, &nubase, dispbase, derivedFinal, forRender, renderResolution);
|
||||
if (!for_orco)
|
||||
curve_calc_modifiers_post(scene, ob, &nubase, dispbase, r_dm_final, for_render, use_render_resolution);
|
||||
|
||||
if (cu->flag & CU_DEFORM_FILL && !ob->derivedFinal) {
|
||||
curve_to_filledpoly(cu, &nubase, dispbase);
|
||||
|
@ -1597,7 +1602,7 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
|
|||
}
|
||||
}
|
||||
|
||||
void BKE_displist_make_curveTypes(Scene *scene, Object *ob, int forOrco)
|
||||
void BKE_displist_make_curveTypes(Scene *scene, Object *ob, bool for_orco)
|
||||
{
|
||||
ListBase *dispbase;
|
||||
|
||||
|
@ -1615,19 +1620,19 @@ void BKE_displist_make_curveTypes(Scene *scene, Object *ob, int forOrco)
|
|||
|
||||
dispbase = &(ob->curve_cache->disp);
|
||||
|
||||
do_makeDispListCurveTypes(scene, ob, dispbase, &ob->derivedFinal, 0, forOrco, 0);
|
||||
do_makeDispListCurveTypes(scene, ob, dispbase, &ob->derivedFinal, 0, for_orco, 0);
|
||||
|
||||
boundbox_displist_object(ob);
|
||||
}
|
||||
|
||||
void BKE_displist_make_curveTypes_forRender(Scene *scene, Object *ob, ListBase *dispbase,
|
||||
DerivedMesh **derivedFinal, int forOrco, int renderResolution)
|
||||
DerivedMesh **r_dm_final, const bool for_orco, const bool use_render_resolution)
|
||||
{
|
||||
if (ob->curve_cache == NULL) {
|
||||
ob->curve_cache = MEM_callocN(sizeof(CurveCache), "CurveCache for MBall");
|
||||
}
|
||||
|
||||
do_makeDispListCurveTypes(scene, ob, dispbase, derivedFinal, 1, forOrco, renderResolution);
|
||||
do_makeDispListCurveTypes(scene, ob, dispbase, r_dm_final, true, for_orco, use_render_resolution);
|
||||
}
|
||||
|
||||
void BKE_displist_make_curveTypes_forOrco(struct Scene *scene, struct Object *ob, struct ListBase *dispbase)
|
||||
|
@ -1640,18 +1645,20 @@ void BKE_displist_make_curveTypes_forOrco(struct Scene *scene, struct Object *ob
|
|||
}
|
||||
|
||||
/* add Orco layer to the displist object which has got derived mesh and return orco */
|
||||
float *BKE_displist_make_orco(Scene *scene, Object *ob, DerivedMesh *derivedFinal, int forRender, int renderResolution)
|
||||
float *BKE_displist_make_orco(Scene *scene, Object *ob, DerivedMesh *dm_final,
|
||||
const bool for_render,
|
||||
const bool use_render_resolution)
|
||||
{
|
||||
float *orco;
|
||||
|
||||
if (derivedFinal == NULL)
|
||||
derivedFinal = ob->derivedFinal;
|
||||
if (dm_final == NULL)
|
||||
dm_final = ob->derivedFinal;
|
||||
|
||||
if (!derivedFinal->getVertDataArray(derivedFinal, CD_ORCO)) {
|
||||
curve_calc_orcodm(scene, ob, derivedFinal, forRender, renderResolution);
|
||||
if (!dm_final->getVertDataArray(dm_final, CD_ORCO)) {
|
||||
curve_calc_orcodm(scene, ob, dm_final, for_render, use_render_resolution);
|
||||
}
|
||||
|
||||
orco = derivedFinal->getVertDataArray(derivedFinal, CD_ORCO);
|
||||
orco = dm_final->getVertDataArray(dm_final, CD_ORCO);
|
||||
|
||||
if (orco) {
|
||||
orco = MEM_dupallocN(orco);
|
||||
|
|
|
@ -294,7 +294,7 @@ static void maskrasterize_spline_differentiate_point_outset(float (*diff_feather
|
|||
/* normalize_v2(d_prev); */ /* precalc */
|
||||
normalize_v2(d_next);
|
||||
|
||||
if ((do_test == FALSE) ||
|
||||
if ((do_test == false) ||
|
||||
(len_squared_v2v2(diff_feather_points[k], diff_points[k]) < ofs_squared))
|
||||
{
|
||||
|
||||
|
@ -347,18 +347,18 @@ static bool layer_bucket_isect_test(
|
|||
const float *v3 = cos[face[2]];
|
||||
|
||||
if (isect_point_tri_v2(cent, v1, v2, v3)) {
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
if ((dist_squared_to_line_segment_v2(cent, v1, v2) < bucket_max_rad_squared) ||
|
||||
(dist_squared_to_line_segment_v2(cent, v2, v3) < bucket_max_rad_squared) ||
|
||||
(dist_squared_to_line_segment_v2(cent, v3, v1) < bucket_max_rad_squared))
|
||||
{
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
// printf("skip tri\n");
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -370,10 +370,10 @@ static bool layer_bucket_isect_test(
|
|||
const float *v4 = cos[face[3]];
|
||||
|
||||
if (isect_point_tri_v2(cent, v1, v2, v3)) {
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
else if (isect_point_tri_v2(cent, v1, v3, v4)) {
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
if ((dist_squared_to_line_segment_v2(cent, v1, v2) < bucket_max_rad_squared) ||
|
||||
|
@ -381,11 +381,11 @@ static bool layer_bucket_isect_test(
|
|||
(dist_squared_to_line_segment_v2(cent, v3, v4) < bucket_max_rad_squared) ||
|
||||
(dist_squared_to_line_segment_v2(cent, v4, v1) < bucket_max_rad_squared))
|
||||
{
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
// printf("skip quad\n");
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -632,7 +632,7 @@ void BKE_maskrasterize_handle_init(MaskRasterHandle *mr_handle, struct Mask *mas
|
|||
|
||||
if (do_feather) {
|
||||
diff_feather_points = BKE_mask_spline_feather_differentiated_points_with_resolution(
|
||||
spline, &tot_diff_feather_points, resol, FALSE);
|
||||
spline, &tot_diff_feather_points, resol, false);
|
||||
BLI_assert(diff_feather_points);
|
||||
}
|
||||
else {
|
||||
|
@ -680,20 +680,20 @@ void BKE_maskrasterize_handle_init(MaskRasterHandle *mr_handle, struct Mask *mas
|
|||
}
|
||||
|
||||
/* fake aa, using small feather */
|
||||
if (do_mask_aa == TRUE) {
|
||||
if (do_feather == FALSE) {
|
||||
if (do_mask_aa == true) {
|
||||
if (do_feather == false) {
|
||||
tot_diff_feather_points = tot_diff_point;
|
||||
diff_feather_points = MEM_mallocN(sizeof(*diff_feather_points) *
|
||||
(size_t)tot_diff_feather_points,
|
||||
__func__);
|
||||
/* add single pixel feather */
|
||||
maskrasterize_spline_differentiate_point_outset(diff_feather_points, diff_points,
|
||||
tot_diff_point, pixel_size, FALSE);
|
||||
tot_diff_point, pixel_size, false);
|
||||
}
|
||||
else {
|
||||
/* ensure single pixel feather, on any zero feather areas */
|
||||
maskrasterize_spline_differentiate_point_outset(diff_feather_points, diff_points,
|
||||
tot_diff_point, pixel_size, TRUE);
|
||||
tot_diff_point, pixel_size, true);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -92,7 +92,7 @@ void BKE_mesh_calc_normals_mapping(MVert *mverts, int numVerts,
|
|||
{
|
||||
BKE_mesh_calc_normals_mapping_ex(mverts, numVerts, mloop, mpolys,
|
||||
numLoops, numPolys, r_polyNors, mfaces, numFaces,
|
||||
origIndexFace, r_faceNors, FALSE);
|
||||
origIndexFace, r_faceNors, false);
|
||||
}
|
||||
/* extended version of 'BKE_mesh_calc_normals_poly' with option not to calc vertex normals */
|
||||
void BKE_mesh_calc_normals_mapping_ex(
|
||||
|
@ -108,14 +108,14 @@ void BKE_mesh_calc_normals_mapping_ex(
|
|||
MPoly *mp;
|
||||
|
||||
if (numPolys == 0) {
|
||||
if (only_face_normals == FALSE) {
|
||||
if (only_face_normals == false) {
|
||||
mesh_calc_normals_vert_fallback(mverts, numVerts);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/* if we are not calculating verts and no verts were passes then we have nothing to do */
|
||||
if ((only_face_normals == TRUE) && (r_polyNors == NULL) && (r_faceNors == NULL)) {
|
||||
if ((only_face_normals == true) && (r_polyNors == NULL) && (r_faceNors == NULL)) {
|
||||
printf("%s: called with nothing to do\n", __func__);
|
||||
return;
|
||||
}
|
||||
|
@ -124,7 +124,7 @@ void BKE_mesh_calc_normals_mapping_ex(
|
|||
/* if (!fnors) fnors = MEM_callocN(sizeof(float[3]) * numFaces, "face nors mesh.c"); */ /* NO NEED TO ALLOC YET */
|
||||
|
||||
|
||||
if (only_face_normals == FALSE) {
|
||||
if (only_face_normals == false) {
|
||||
/* vertex normals are optional, they require some extra calculations,
|
||||
* so make them optional */
|
||||
BKE_mesh_calc_normals_poly(mverts, numVerts, mloop, mpolys, numLoops, numPolys, pnors, false);
|
||||
|
@ -1990,13 +1990,13 @@ void BKE_mesh_flush_select_from_verts_ex(const MVert *mvert, const int UNUSED(to
|
|||
i = totpoly;
|
||||
for (mp = mpoly; i--; mp++) {
|
||||
if ((mp->flag & ME_HIDE) == 0) {
|
||||
int ok = TRUE;
|
||||
bool ok = true;
|
||||
const MLoop *ml;
|
||||
int j;
|
||||
j = mp->totloop;
|
||||
for (ml = &mloop[mp->loopstart]; j--; ml++) {
|
||||
if ((mvert[ml->v].flag & SELECT) == 0) {
|
||||
ok = FALSE;
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -173,12 +173,12 @@ bool modifier_isPreview(ModifierData *md)
|
|||
ModifierTypeInfo *mti = modifierType_getInfo(md->type);
|
||||
|
||||
if (!(mti->flags & eModifierTypeFlag_UsesPreview))
|
||||
return FALSE;
|
||||
return false;
|
||||
|
||||
if (md->mode & eModifierMode_Realtime)
|
||||
return TRUE;
|
||||
return true;
|
||||
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
ModifierData *modifiers_findByType(Object *ob, ModifierType type)
|
||||
|
|
|
@ -203,10 +203,11 @@ static void shrinkwrap_calc_nearest_vertex(ShrinkwrapCalcData *calc)
|
|||
* MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE (front faces hits are ignored)
|
||||
* MOD_SHRINKWRAP_CULL_TARGET_BACKFACE (back faces hits are ignored)
|
||||
*/
|
||||
int BKE_shrinkwrap_project_normal(char options, const float vert[3],
|
||||
const float dir[3], const SpaceTransform *transf,
|
||||
BVHTree *tree, BVHTreeRayHit *hit,
|
||||
BVHTree_RayCastCallback callback, void *userdata)
|
||||
bool BKE_shrinkwrap_project_normal(
|
||||
char options, const float vert[3],
|
||||
const float dir[3], const SpaceTransform *transf,
|
||||
BVHTree *tree, BVHTreeRayHit *hit,
|
||||
BVHTree_RayCastCallback callback, void *userdata)
|
||||
{
|
||||
/* don't use this because this dist value could be incompatible
|
||||
* this value used by the callback for comparing prev/new dist values.
|
||||
|
@ -255,7 +256,7 @@ int BKE_shrinkwrap_project_normal(char options, const float vert[3],
|
|||
if (((options & MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE) && dot <= 0.0f) ||
|
||||
((options & MOD_SHRINKWRAP_CULL_TARGET_BACKFACE) && dot >= 0.0f))
|
||||
{
|
||||
return FALSE; /* Ignore hit */
|
||||
return false; /* Ignore hit */
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -270,13 +271,13 @@ int BKE_shrinkwrap_project_normal(char options, const float vert[3],
|
|||
BLI_assert(hit_tmp.dist <= hit->dist);
|
||||
|
||||
memcpy(hit, &hit_tmp, sizeof(hit_tmp));
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
static void shrinkwrap_calc_normal_projection(ShrinkwrapCalcData *calc, bool forRender)
|
||||
static void shrinkwrap_calc_normal_projection(ShrinkwrapCalcData *calc, bool for_render)
|
||||
{
|
||||
int i;
|
||||
|
||||
|
@ -323,7 +324,7 @@ static void shrinkwrap_calc_normal_projection(ShrinkwrapCalcData *calc, bool for
|
|||
}
|
||||
|
||||
if (calc->smd->auxTarget) {
|
||||
auxMesh = object_get_derived_final(calc->smd->auxTarget, forRender);
|
||||
auxMesh = object_get_derived_final(calc->smd->auxTarget, for_render);
|
||||
if (!auxMesh)
|
||||
return;
|
||||
SPACE_TRANSFORM_SETUP(&local2aux, calc->ob, calc->smd->auxTarget);
|
||||
|
@ -504,7 +505,7 @@ static void shrinkwrap_calc_nearest_surface_point(ShrinkwrapCalcData *calc)
|
|||
|
||||
/* Main shrinkwrap function */
|
||||
void shrinkwrapModifier_deform(ShrinkwrapModifierData *smd, Object *ob, DerivedMesh *dm,
|
||||
float (*vertexCos)[3], int numVerts, bool forRender)
|
||||
float (*vertexCos)[3], int numVerts, bool for_render)
|
||||
{
|
||||
|
||||
DerivedMesh *ss_mesh = NULL;
|
||||
|
@ -532,7 +533,7 @@ void shrinkwrapModifier_deform(ShrinkwrapModifierData *smd, Object *ob, DerivedM
|
|||
|
||||
|
||||
if (smd->target) {
|
||||
calc.target = object_get_derived_final(smd->target, forRender);
|
||||
calc.target = object_get_derived_final(smd->target, for_render);
|
||||
|
||||
/* TODO there might be several "bugs" on non-uniform scales matrixs
|
||||
* because it will no longer be nearest surface, not sphere projection
|
||||
|
@ -583,7 +584,7 @@ void shrinkwrapModifier_deform(ShrinkwrapModifierData *smd, Object *ob, DerivedM
|
|||
break;
|
||||
|
||||
case MOD_SHRINKWRAP_PROJECT:
|
||||
TIMEIT_BENCH(shrinkwrap_calc_normal_projection(&calc, forRender), deform_project);
|
||||
TIMEIT_BENCH(shrinkwrap_calc_normal_projection(&calc, for_render), deform_project);
|
||||
break;
|
||||
|
||||
case MOD_SHRINKWRAP_NEAREST_VERTEX:
|
||||
|
|
|
@ -51,6 +51,6 @@ void BLI_quadric_mul(Quadric *a, const float scalar);
|
|||
|
||||
/* solve */
|
||||
float BLI_quadric_evaluate(const Quadric *q, const float v[3]);
|
||||
int BLI_quadric_optimize(const Quadric *q, float v[3], const float epsilon);
|
||||
bool BLI_quadric_optimize(const Quadric *q, float v[3], const float epsilon);
|
||||
|
||||
#endif /* __BLI_QUADRIC_H__ */
|
||||
|
|
|
@ -109,7 +109,7 @@ float BLI_quadric_evaluate(const Quadric *q, const float v[3])
|
|||
q->d2);
|
||||
}
|
||||
|
||||
int BLI_quadric_optimize(const Quadric *q, float v[3], const float epsilon)
|
||||
bool BLI_quadric_optimize(const Quadric *q, float v[3], const float epsilon)
|
||||
{
|
||||
float m[3][3];
|
||||
|
||||
|
@ -120,9 +120,9 @@ int BLI_quadric_optimize(const Quadric *q, float v[3], const float epsilon)
|
|||
mul_m3_v3(m, v);
|
||||
negate_v3(v);
|
||||
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -295,7 +295,8 @@ Mesh *rna_Main_meshes_new_from_object(
|
|||
Mesh *tmpmesh;
|
||||
Curve *tmpcu = NULL, *copycu;
|
||||
Object *tmpobj = NULL;
|
||||
int render = settings == eModifierMode_Render, i;
|
||||
const bool use_render_resolution = (settings == eModifierMode_Render);
|
||||
int i;
|
||||
int cage = !apply_modifiers;
|
||||
|
||||
/* perform the mesh extraction based on type */
|
||||
|
@ -327,7 +328,7 @@ Mesh *rna_Main_meshes_new_from_object(
|
|||
copycu->editnurb = tmpcu->editnurb;
|
||||
|
||||
/* get updated display list, and convert to a mesh */
|
||||
BKE_displist_make_curveTypes_forRender(sce, tmpobj, &dispbase, &derivedFinal, FALSE, render);
|
||||
BKE_displist_make_curveTypes_forRender(sce, tmpobj, &dispbase, &derivedFinal, false, use_render_resolution);
|
||||
|
||||
copycu->editfont = NULL;
|
||||
copycu->editnurb = NULL;
|
||||
|
@ -370,14 +371,14 @@ Mesh *rna_Main_meshes_new_from_object(
|
|||
/* BKE_mesh_add gives us a user count we don't need */
|
||||
tmpmesh->id.us--;
|
||||
|
||||
if (render) {
|
||||
if (use_render_resolution) {
|
||||
ListBase disp = {NULL, NULL};
|
||||
/* TODO(sergey): This is gonna to work for until EvaluationContext
|
||||
* only contains for_render flag. As soon as CoW is
|
||||
* implemented, this is to be rethinked.
|
||||
*/
|
||||
EvaluationContext eval_ctx = {0};
|
||||
eval_ctx.for_render = render;
|
||||
eval_ctx.for_render = use_render_resolution;
|
||||
BKE_displist_make_mball_forRender(&eval_ctx, sce, ob, &disp);
|
||||
BKE_mesh_from_metaball(&disp, tmpmesh);
|
||||
BKE_displist_free(&disp);
|
||||
|
@ -413,7 +414,7 @@ Mesh *rna_Main_meshes_new_from_object(
|
|||
mask |= CD_MASK_ORCO;
|
||||
|
||||
/* Write the display mesh into the dummy mesh */
|
||||
if (render)
|
||||
if (use_render_resolution)
|
||||
dm = mesh_create_derived_render(sce, ob, mask);
|
||||
else
|
||||
dm = mesh_create_derived_view(sce, ob, mask);
|
||||
|
|
|
@ -385,7 +385,7 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
|
|||
if (cu) {
|
||||
#ifdef CYCLIC_DEPENDENCY_WORKAROUND
|
||||
if (amd->curve_ob->curve_cache == NULL) {
|
||||
BKE_displist_make_curveTypes(scene, amd->curve_ob, FALSE);
|
||||
BKE_displist_make_curveTypes(scene, amd->curve_ob, false);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
@ -528,7 +528,7 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
|
|||
|
||||
/* start capping */
|
||||
if (start_cap || end_cap) {
|
||||
BM_mesh_elem_hflag_enable_all(bm, BM_VERT, BM_ELEM_TAG, FALSE);
|
||||
BM_mesh_elem_hflag_enable_all(bm, BM_VERT, BM_ELEM_TAG, false);
|
||||
|
||||
if (start_cap) {
|
||||
float startoffset[4][4];
|
||||
|
|
|
@ -150,7 +150,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
|
|||
Object *oba = mmd->ob_arm;
|
||||
bPoseChannel *pchan;
|
||||
bDeformGroup *def;
|
||||
char *bone_select_array;
|
||||
bool *bone_select_array;
|
||||
int bone_select_tot = 0;
|
||||
const int defbase_tot = BLI_countlist(&ob->defbase);
|
||||
|
||||
|
@ -167,11 +167,11 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
|
|||
for (i = 0, def = ob->defbase.first; def; def = def->next, i++) {
|
||||
pchan = BKE_pose_channel_find_name(oba->pose, def->name);
|
||||
if (pchan && pchan->bone && (pchan->bone->flag & BONE_SELECTED)) {
|
||||
bone_select_array[i] = TRUE;
|
||||
bone_select_array[i] = true;
|
||||
bone_select_tot++;
|
||||
}
|
||||
else {
|
||||
bone_select_array[i] = FALSE;
|
||||
bone_select_array[i] = false;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -194,7 +194,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
|
|||
if (dw->def_nr < defbase_tot) {
|
||||
if (bone_select_array[dw->def_nr]) {
|
||||
if (dw->weight != 0.0f) {
|
||||
found = TRUE;
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -263,12 +263,12 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
|
|||
for (i = 0; i < maxPolys; i++) {
|
||||
MPoly *mp = &mpoly[i];
|
||||
MLoop *ml = mloop + mp->loopstart;
|
||||
int ok = TRUE;
|
||||
bool ok = true;
|
||||
int j;
|
||||
|
||||
for (j = 0; j < mp->totloop; j++, ml++) {
|
||||
if (!BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(ml->v))) {
|
||||
ok = FALSE;
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -80,11 +80,11 @@ static bool isDisabled(ModifierData *md, int useRenderParams)
|
|||
ModifierData *ob_md;
|
||||
|
||||
if (!pimd->ob)
|
||||
return TRUE;
|
||||
return true;
|
||||
|
||||
psys = BLI_findlink(&pimd->ob->particlesystem, pimd->psys - 1);
|
||||
if (psys == NULL)
|
||||
return TRUE;
|
||||
return true;
|
||||
|
||||
/* If the psys modifier is disabled we cannot use its data.
|
||||
* First look up the psys modifier from the object, then check if it is enabled.
|
||||
|
@ -99,14 +99,14 @@ static bool isDisabled(ModifierData *md, int useRenderParams)
|
|||
else required_mode = eModifierMode_Realtime;
|
||||
|
||||
if (!modifier_isEnabled(md->scene, ob_md, required_mode))
|
||||
return TRUE;
|
||||
return true;
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -111,9 +111,9 @@ typedef struct Frame {
|
|||
} merge[4];
|
||||
|
||||
/* For hull frames, whether each vertex is detached or not */
|
||||
int inside_hull[4];
|
||||
bool inside_hull[4];
|
||||
/* Whether any part of the frame (corner or edge) is detached */
|
||||
int detached;
|
||||
bool detached;
|
||||
} Frame;
|
||||
|
||||
#define MAX_SKIN_NODE_FRAMES 2
|
||||
|
@ -174,34 +174,35 @@ static bool is_quad_symmetric(BMVert *quad[4],
|
|||
}
|
||||
|
||||
/* Returns true if the quad crosses the plane of symmetry, false otherwise */
|
||||
static int quad_crosses_symmetry_plane(BMVert *quad[4],
|
||||
const SkinModifierData *smd)
|
||||
static bool quad_crosses_symmetry_plane(BMVert *quad[4],
|
||||
const SkinModifierData *smd)
|
||||
{
|
||||
int axis;
|
||||
|
||||
for (axis = 0; axis < 3; axis++) {
|
||||
if (smd->symmetry_axes & (1 << axis)) {
|
||||
int i, left = FALSE, right = FALSE;
|
||||
bool left = false, right = false;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 4; i++) {
|
||||
if (quad[i]->co[axis] < 0.0f)
|
||||
left = TRUE;
|
||||
left = true;
|
||||
else if (quad[i]->co[axis] > 0.0f)
|
||||
right = TRUE;
|
||||
right = true;
|
||||
|
||||
if (left && right)
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Returns true if the frame is filled by precisely two faces (and
|
||||
* outputs those faces to fill_faces), otherwise returns false. */
|
||||
static int skin_frame_find_contained_faces(const Frame *frame,
|
||||
BMFace *fill_faces[2])
|
||||
static bool skin_frame_find_contained_faces(const Frame *frame,
|
||||
BMFace *fill_faces[2])
|
||||
{
|
||||
BMEdge *diag;
|
||||
|
||||
|
@ -213,11 +214,11 @@ static int skin_frame_find_contained_faces(const Frame *frame,
|
|||
if (diag)
|
||||
return BM_edge_face_pair(diag, &fill_faces[0], &fill_faces[1]);
|
||||
else
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Returns TRUE if hull is successfully built, FALSE otherwise */
|
||||
static int build_hull(SkinOutput *so, Frame **frames, int totframe)
|
||||
/* Returns true if hull is successfully built, FALSE otherwise */
|
||||
static bool build_hull(SkinOutput *so, Frame **frames, int totframe)
|
||||
{
|
||||
BMesh *bm = so->bm;
|
||||
BMOperator op;
|
||||
|
@ -228,7 +229,7 @@ static int build_hull(SkinOutput *so, Frame **frames, int totframe)
|
|||
BMEdge *e;
|
||||
int i, j;
|
||||
|
||||
BM_mesh_elem_hflag_disable_all(bm, BM_VERT, BM_ELEM_TAG, FALSE);
|
||||
BM_mesh_elem_hflag_disable_all(bm, BM_VERT, BM_ELEM_TAG, false);
|
||||
|
||||
for (i = 0; i < totframe; i++) {
|
||||
for (j = 0; j < 4; j++) {
|
||||
|
@ -246,7 +247,7 @@ static int build_hull(SkinOutput *so, Frame **frames, int totframe)
|
|||
|
||||
if (BMO_error_occurred(bm)) {
|
||||
BMO_op_finish(bm, &op);
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Apply face attributes to hull output */
|
||||
|
@ -264,8 +265,8 @@ static int build_hull(SkinOutput *so, Frame **frames, int totframe)
|
|||
if (!frame->detached) {
|
||||
for (j = 0; j < 4; j++) {
|
||||
if (frame->verts[j] == v) {
|
||||
frame->inside_hull[j] = TRUE;
|
||||
frame->detached = TRUE;
|
||||
frame->inside_hull[j] = true;
|
||||
frame->detached = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -283,7 +284,7 @@ static int build_hull(SkinOutput *so, Frame **frames, int totframe)
|
|||
!BM_edge_exists(frame->verts[2], frame->verts[3]) ||
|
||||
!BM_edge_exists(frame->verts[3], frame->verts[0])))
|
||||
{
|
||||
frame->detached = TRUE;
|
||||
frame->detached = true;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -304,7 +305,7 @@ static int build_hull(SkinOutput *so, Frame **frames, int totframe)
|
|||
BM_elem_flag_enable(fill_faces[1], BM_ELEM_TAG);
|
||||
}
|
||||
else
|
||||
frame->detached = TRUE;
|
||||
frame->detached = true;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -326,7 +327,7 @@ static int build_hull(SkinOutput *so, Frame **frames, int totframe)
|
|||
|
||||
BM_mesh_delete_hflag_tagged(bm, BM_ELEM_TAG, BM_EDGE | BM_FACE);
|
||||
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Returns the average frame side length (frames are rectangular, so
|
||||
|
@ -660,7 +661,7 @@ static void build_emats_stack(BLI_Stack *stack, int *visited_e, EMat *emat,
|
|||
return;
|
||||
|
||||
/* Mark edge as visited */
|
||||
visited_e[e] = TRUE;
|
||||
visited_e[e] = true;
|
||||
|
||||
/* Process edge */
|
||||
|
||||
|
@ -1036,7 +1037,7 @@ static int isect_ray_poly(const float ray_start[3],
|
|||
BMVert *v, *v_first = NULL, *v_prev = NULL;
|
||||
BMIter iter;
|
||||
float best_dist = FLT_MAX;
|
||||
int hit = 0;
|
||||
bool hit = false;
|
||||
|
||||
BM_ITER_ELEM (v, &iter, f, BM_VERTS_OF_FACE) {
|
||||
if (!v_first)
|
||||
|
@ -1049,7 +1050,7 @@ static int isect_ray_poly(const float ray_start[3],
|
|||
v_first->co, v_prev->co, v->co,
|
||||
&dist, NULL);
|
||||
if (curhit && dist < best_dist) {
|
||||
hit = TRUE;
|
||||
hit = true;
|
||||
best_dist = dist;
|
||||
}
|
||||
}
|
||||
|
@ -1104,15 +1105,16 @@ static BMFace *collapse_face_corners(BMesh *bm, BMFace *f, int n,
|
|||
/* Find the new face */
|
||||
f = NULL;
|
||||
BM_ITER_ELEM (vf, &iter, v_safe, BM_FACES_OF_VERT) {
|
||||
int wrong_face = FALSE;
|
||||
bool wrong_face = false;
|
||||
|
||||
for (i = 0; i < orig_len; i++) {
|
||||
if (orig_verts[i] == v_merge)
|
||||
if (orig_verts[i] == v_merge) {
|
||||
orig_verts[i] = NULL;
|
||||
}
|
||||
else if (orig_verts[i] &&
|
||||
!BM_vert_in_face(vf, orig_verts[i]))
|
||||
{
|
||||
wrong_face = TRUE;
|
||||
wrong_face = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -1228,7 +1230,7 @@ static void skin_fix_hole_no_good_verts(BMesh *bm, Frame *frame, BMFace *split_f
|
|||
BLI_assert(split_face->len >= 3);
|
||||
|
||||
/* Extrude the split face */
|
||||
BM_mesh_elem_hflag_disable_all(bm, BM_FACE, BM_ELEM_TAG, FALSE);
|
||||
BM_mesh_elem_hflag_disable_all(bm, BM_FACE, BM_ELEM_TAG, false);
|
||||
BM_elem_flag_enable(split_face, BM_ELEM_TAG);
|
||||
BMO_op_initf(bm, &op, (BMO_FLAG_DEFAULTS & ~BMO_FLAG_RESPECT_HIDE),
|
||||
"extrude_discrete_faces faces=%hf", BM_ELEM_TAG);
|
||||
|
@ -1251,7 +1253,7 @@ static void skin_fix_hole_no_good_verts(BMesh *bm, Frame *frame, BMFace *split_f
|
|||
* face is a triangle */
|
||||
longest_edge = BM_face_find_longest_loop(split_face)->e;
|
||||
|
||||
BM_mesh_elem_hflag_disable_all(bm, BM_EDGE, BM_ELEM_TAG, FALSE);
|
||||
BM_mesh_elem_hflag_disable_all(bm, BM_EDGE, BM_ELEM_TAG, false);
|
||||
BM_elem_flag_enable(longest_edge, BM_ELEM_TAG);
|
||||
|
||||
BMO_op_callf(bm, BMO_FLAG_DEFAULTS,
|
||||
|
@ -1378,7 +1380,7 @@ static void hull_merge_triangles(SkinOutput *so, const SkinModifierData *smd)
|
|||
|
||||
heap = BLI_heap_new();
|
||||
|
||||
BM_mesh_elem_hflag_disable_all(so->bm, BM_FACE, BM_ELEM_TAG, FALSE);
|
||||
BM_mesh_elem_hflag_disable_all(so->bm, BM_FACE, BM_ELEM_TAG, false);
|
||||
|
||||
/* Build heap */
|
||||
BM_ITER_MESH (e, &iter, so->bm, BM_EDGES_OF_MESH) {
|
||||
|
@ -1612,7 +1614,7 @@ static void skin_smooth_hulls(BMesh *bm, SkinNode *skin_nodes,
|
|||
return;
|
||||
|
||||
/* Mark all frame vertices */
|
||||
BM_mesh_elem_hflag_disable_all(bm, BM_VERT, BM_ELEM_TAG, FALSE);
|
||||
BM_mesh_elem_hflag_disable_all(bm, BM_VERT, BM_ELEM_TAG, false);
|
||||
for (i = 0; i < totvert; i++) {
|
||||
for (j = 0; j < skin_nodes[i].totframe; j++) {
|
||||
Frame *frame = &skin_nodes[i].frames[j];
|
||||
|
@ -1662,12 +1664,13 @@ static void skin_smooth_hulls(BMesh *bm, SkinNode *skin_nodes,
|
|||
BM_data_layer_free_n(bm, &bm->vdata, CD_SHAPEKEY, skey);
|
||||
}
|
||||
|
||||
/* Returns TRUE if all hulls are successfully built, FALSE otherwise */
|
||||
static int skin_output_branch_hulls(SkinOutput *so, SkinNode *skin_nodes,
|
||||
int totvert, const MeshElemMap *emap,
|
||||
const MEdge *medge)
|
||||
/* Returns TRUE if all hulls are successfully built, false otherwise */
|
||||
static bool skin_output_branch_hulls(SkinOutput *so, SkinNode *skin_nodes,
|
||||
int totvert, const MeshElemMap *emap,
|
||||
const MEdge *medge)
|
||||
{
|
||||
int result = TRUE, v;
|
||||
bool result = true;
|
||||
int v;
|
||||
|
||||
for (v = 0; v < totvert; v++) {
|
||||
SkinNode *sn = &skin_nodes[v];
|
||||
|
@ -1681,7 +1684,7 @@ static int skin_output_branch_hulls(SkinOutput *so, SkinNode *skin_nodes,
|
|||
emap, medge,
|
||||
&tothullframe);
|
||||
if (!build_hull(so, hull_frames, tothullframe))
|
||||
result = FALSE;
|
||||
result = false;
|
||||
|
||||
MEM_freeN(hull_frames);
|
||||
}
|
||||
|
|
|
@ -720,7 +720,7 @@ static DerivedMesh *applyModifier(
|
|||
CustomData_copy_data(&dm->loopData, &result->loopData, k1, (int)(numLoops * 2 + j + 2), 1);
|
||||
CustomData_copy_data(&dm->loopData, &result->loopData, k2, (int)(numLoops * 2 + j + 3), 1);
|
||||
|
||||
if (flip == FALSE) {
|
||||
if (flip == false) {
|
||||
ml[j].v = ed->v1;
|
||||
ml[j++].e = eidx;
|
||||
|
||||
|
|
|
@ -380,7 +380,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
|
|||
/* Update (add to) vgroup.
|
||||
* XXX Depending on the MOD_WVG_SET_xxx option chosen, we might have to add vertices to vgroup.
|
||||
*/
|
||||
weightvg_update_vg(dvert, defgrp_index, dw1, numIdx, indices, org_w, TRUE, -FLT_MAX, FALSE, 0.0f);
|
||||
weightvg_update_vg(dvert, defgrp_index, dw1, numIdx, indices, org_w, true, -FLT_MAX, false, 0.0f);
|
||||
|
||||
/* If weight preview enabled... */
|
||||
#if 0 /* XXX Currently done in mod stack :/ */
|
||||
|
|
|
@ -465,7 +465,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
|
|||
|
||||
if (use_trgt_verts || use_trgt_edges || use_trgt_faces) {
|
||||
DerivedMesh *target_dm = obr->derivedFinal;
|
||||
short free_target_dm = FALSE;
|
||||
bool free_target_dm = false;
|
||||
if (!target_dm) {
|
||||
if (ELEM3(obr->type, OB_CURVE, OB_SURF, OB_FONT))
|
||||
target_dm = CDDM_from_curve(obr);
|
||||
|
@ -476,7 +476,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
|
|||
else
|
||||
target_dm = CDDM_from_mesh(me);
|
||||
}
|
||||
free_target_dm = TRUE;
|
||||
free_target_dm = true;
|
||||
}
|
||||
|
||||
/* We must check that we do have a valid target_dm! */
|
||||
|
@ -521,7 +521,7 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *der
|
|||
wmd->mask_tex_map_obj, wmd->mask_tex_uvlayer_name);
|
||||
|
||||
/* Update vgroup. Note we never add nor remove vertices from vgroup here. */
|
||||
weightvg_update_vg(dvert, defgrp_index, dw, numIdx, indices, org_w, FALSE, 0.0f, FALSE, 0.0f);
|
||||
weightvg_update_vg(dvert, defgrp_index, dw, numIdx, indices, org_w, false, 0.0f, false, 0.0f);
|
||||
|
||||
/* If weight preview enabled... */
|
||||
#if 0 /* XXX Currently done in mod stack :/ */
|
||||
|
|
|
@ -2629,7 +2629,7 @@ static void init_render_surf(Render *re, ObjectRen *obr, int timeoffset)
|
|||
if (need_orco) {
|
||||
orco = get_object_orco(re, ob);
|
||||
if (!orco) {
|
||||
orco= BKE_displist_make_orco(re->scene, ob, dm, 1, 1);
|
||||
orco= BKE_displist_make_orco(re->scene, ob, dm, true, true);
|
||||
if (orco) {
|
||||
set_object_orco(re, ob, orco);
|
||||
}
|
||||
|
@ -2680,7 +2680,7 @@ static void init_render_curve(Render *re, ObjectRen *obr, int timeoffset)
|
|||
if (ob->type==OB_FONT && cu->str==NULL) return;
|
||||
else if (ob->type==OB_CURVE && cu->nurb.first==NULL) return;
|
||||
|
||||
BKE_displist_make_curveTypes_forRender(re->scene, ob, &disp, &dm, 0, 1);
|
||||
BKE_displist_make_curveTypes_forRender(re->scene, ob, &disp, &dm, false, true);
|
||||
dl= disp.first;
|
||||
if (dl==NULL) return;
|
||||
|
||||
|
@ -2707,7 +2707,7 @@ static void init_render_curve(Render *re, ObjectRen *obr, int timeoffset)
|
|||
if (need_orco) {
|
||||
orco = get_object_orco(re, ob);
|
||||
if (!orco) {
|
||||
orco = BKE_displist_make_orco(re->scene, ob, dm, 1, 1);
|
||||
orco = BKE_displist_make_orco(re->scene, ob, dm, true, true);
|
||||
if (orco) {
|
||||
set_object_orco(re, ob, orco);
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue