struct MDeformVert *dvert_prev;
} wpaint;
- //struct {
- //ToDo: identify sculpt-only fields
- //} sculpt;
+ /* TODO: identify sculpt-only fields */
+ // struct { ... } sculpt;
} mode;
int mode_type;
copy_v3_v3(bbd->goal_nor, efd.nor);
}
}
- else if (rule->type == eBoidRuleType_Avoid && bpa->data.mode == eBoidMode_Climbing &&
- priority > 2.0f * gabr->fear_factor) {
+ else if ((rule->type == eBoidRuleType_Avoid) &&
+ (bpa->data.mode == eBoidMode_Climbing) &&
+ (priority > 2.0f * gabr->fear_factor))
+ {
/* detach from surface and try to fly away from danger */
negate_v3_v3(efd.vec_to_point, bpa->gravity);
}
/* jump to go faster */
if (jump == 0 && val.jump_speed > val.max_speed && bbd->wanted_speed > val.max_speed) {
-
+ /* pass */
}
if (jump) {
/* if soft-distance is enabled, start fading once owner is dist+softdist from the target */
else if (data->flag & LIMITDIST_USESOFT) {
if (dist <= (data->dist + data->soft)) {
-
+ /* pass */
}
}
}
}
switch (dtdata_type) {
- /* Vertex data */
+ /* Vertex data */
case DT_TYPE_MDEFORMVERT:
*r_advanced_mixing = true;
*r_threshold = true;
case DT_TYPE_BWEIGHT_VERT:
ret = true;
break;
- /* Edge data */
+ /* Edge data */
case DT_TYPE_SHARP_EDGE:
*r_threshold = true;
ret = true;
*r_threshold = true;
ret = true;
break;
- /* Loop/Poly data */
+ /* Loop/Poly data */
case DT_TYPE_UV:
ret = true;
break;
falloff=0.0f;
else {
switch (eff->pd->falloff) {
- case PFIELD_FALL_SPHERE:
- falloff*= falloff_func_dist(eff->pd, efd->distance);
- break;
-
- case PFIELD_FALL_TUBE:
- falloff*= falloff_func_dist(eff->pd, ABS(fac));
- if (falloff == 0.0f)
+ case PFIELD_FALL_SPHERE:
+ falloff*= falloff_func_dist(eff->pd, efd->distance);
break;
- madd_v3_v3v3fl(temp, efd->vec_to_point2, efd->nor, -fac);
- r_fac= len_v3(temp);
- falloff*= falloff_func_rad(eff->pd, r_fac);
- break;
- case PFIELD_FALL_CONE:
- falloff*= falloff_func_dist(eff->pd, ABS(fac));
- if (falloff == 0.0f)
+ case PFIELD_FALL_TUBE:
+ falloff*= falloff_func_dist(eff->pd, ABS(fac));
+ if (falloff == 0.0f)
+ break;
+
+ madd_v3_v3v3fl(temp, efd->vec_to_point2, efd->nor, -fac);
+ r_fac= len_v3(temp);
+ falloff*= falloff_func_rad(eff->pd, r_fac);
break;
+ case PFIELD_FALL_CONE:
+ falloff*= falloff_func_dist(eff->pd, ABS(fac));
+ if (falloff == 0.0f)
+ break;
- r_fac= RAD2DEGF(saacos(fac/len_v3(efd->vec_to_point)));
- falloff*= falloff_func_rad(eff->pd, r_fac);
+ r_fac= RAD2DEGF(saacos(fac/len_v3(efd->vec_to_point)));
+ falloff*= falloff_func_rad(eff->pd, r_fac);
- break;
+ break;
}
}
psys_get_texture(sim, pa, &ptex, PAMAP_INIT, 0.f);
switch (part->type) {
- case PART_EMITTER:
- if (ptex.exist < psys_frand(psys, p+125))
- pa->flag |= PARS_UNEXIST;
- pa->time = part->sta + (part->end - part->sta)*ptex.time;
- break;
- case PART_HAIR:
- if (ptex.exist < psys_frand(psys, p+125))
- pa->flag |= PARS_UNEXIST;
- pa->time = 0.f;
- break;
- case PART_FLUID:
- break;
+ case PART_EMITTER:
+ if (ptex.exist < psys_frand(psys, p + 125)) {
+ pa->flag |= PARS_UNEXIST;
+ }
+ pa->time = part->sta + (part->end - part->sta)*ptex.time;
+ break;
+ case PART_HAIR:
+ if (ptex.exist < psys_frand(psys, p + 125)) {
+ pa->flag |= PARS_UNEXIST;
+ }
+ pa->time = 0.f;
+ break;
+ case PART_FLUID:
+ break;
}
}
pa->dietime = pa->time + pa->lifetime;
- if (sim->psys->pointcache && sim->psys->pointcache->flag & PTCACHE_BAKED &&
- sim->psys->pointcache->mem_cache.first) {
+ if ((sim->psys->pointcache) &&
+ (sim->psys->pointcache->flag & PTCACHE_BAKED) &&
+ (sim->psys->pointcache->mem_cache.first))
+ {
float dietime = psys_get_dietime_from_cache(sim->psys->pointcache, p);
pa->dietime = MIN2(pa->dietime, dietime);
}
/* Note that we could avoid copying sphdata for each thread here (it's only read here),
* but doubt this would gain us anything except confusion... */
{
- ParallelRangeSettings settings;
- BLI_parallel_range_settings_defaults(&settings);
- settings.use_threading = (psys->totpart > 100);
- settings.userdata_chunk = &sphdata;
- settings.userdata_chunk_size = sizeof(sphdata);
+ ParallelRangeSettings settings;
+ BLI_parallel_range_settings_defaults(&settings);
+ settings.use_threading = (psys->totpart > 100);
+ settings.userdata_chunk = &sphdata;
+ settings.userdata_chunk_size = sizeof(sphdata);
BLI_task_parallel_range(
0, psys->totpart,
&task_data,
/* do global forces & effectors */
{
- ParallelRangeSettings settings;
- BLI_parallel_range_settings_defaults(&settings);
- settings.use_threading = (psys->totpart > 100);
- settings.userdata_chunk = &sphdata;
- settings.userdata_chunk_size = sizeof(sphdata);
+ ParallelRangeSettings settings;
+ BLI_parallel_range_settings_defaults(&settings);
+ settings.use_threading = (psys->totpart > 100);
+ settings.userdata_chunk = &sphdata;
+ settings.userdata_chunk_size = sizeof(sphdata);
BLI_task_parallel_range(
0, psys->totpart,
&task_data,
PTCacheExtra *extra = NULL;
if (psys->part->phystype == PART_PHYS_FLUID &&
- psys->part->fluid && psys->part->fluid->flag & SPH_VISCOELASTIC_SPRINGS &&
- psys->tot_fluidsprings && psys->fluid_springs) {
-
+ psys->part->fluid && psys->part->fluid->flag & SPH_VISCOELASTIC_SPRINGS &&
+ psys->tot_fluidsprings && psys->fluid_springs)
+ {
extra = MEM_callocN(sizeof(PTCacheExtra), "Point cache: fluid extra data");
extra->type = BPHYS_EXTRA_FLUID_SPRINGS;
/* check if resolution has changed */
if (sds->res[0] != ch_res[0] ||
- sds->res[1] != ch_res[1] ||
- sds->res[2] != ch_res[2]) {
+ sds->res[1] != ch_res[1] ||
+ sds->res[2] != ch_res[2])
+ {
if (sds->flags & MOD_SMOKE_ADAPTIVE_DOMAIN)
reallocate = 1;
else
{
int i;
for (i=0; i<BPHYS_TOT_DATA; i++) {
- /* note, durian file 03.4b_comp crashes if to[i] is not tested
- * its NULL, not sure if this should be fixed elsewhere but for now its needed */
+ /* note, durian file 03.4b_comp crashes if to[i] is not tested
+ * its NULL, not sure if this should be fixed elsewhere but for now its needed */
if (from[i] && to[i])
memcpy(to[i], from[i], ptcache_data_size[i]);
}
/* initialize with first input if in range */
if (x >= em1.min[0] && x < em1.max[0] &&
- y >= em1.min[1] && y < em1.max[1] &&
- z >= em1.min[2] && z < em1.max[2]) {
+ y >= em1.min[1] && y < em1.max[1] &&
+ z >= em1.min[2] && z < em1.max[2])
+ {
int index_in = smoke_get_index(x - em1.min[0], em1.res[0], y - em1.min[1], em1.res[1], z - em1.min[2]);
/* values */
/* apply second input if in range */
if (x >= em2->min[0] && x < em2->max[0] &&
- y >= em2->min[1] && y < em2->max[1] &&
- z >= em2->min[2] && z < em2->max[2]) {
+ y >= em2->min[1] && y < em2->max[1] &&
+ z >= em2->min[2] && z < em2->max[2])
+ {
int index_in = smoke_get_index(x - em2->min[0], em2->res[0], y - em2->min[1], em2->res[1], z - em2->min[2]);
/* values */
/* initialize with first input if in range */
if (x >= em1.hmin[0] && x < em1.hmax[0] &&
- y >= em1.hmin[1] && y < em1.hmax[1] &&
- z >= em1.hmin[2] && z < em1.hmax[2]) {
+ y >= em1.hmin[1] && y < em1.hmax[1] &&
+ z >= em1.hmin[2] && z < em1.hmax[2])
+ {
int index_in = smoke_get_index(x - em1.hmin[0], em1.hres[0], y - em1.hmin[1], em1.hres[1], z - em1.hmin[2]);
/* values */
output->influence_high[index_out] = em1.influence_high[index_in];
/* apply second input if in range */
if (x >= em2->hmin[0] && x < em2->hmax[0] &&
- y >= em2->hmin[1] && y < em2->hmax[1] &&
- z >= em2->hmin[2] && z < em2->hmax[2]) {
+ y >= em2->hmin[1] && y < em2->hmax[1] &&
+ z >= em2->hmin[2] && z < em2->hmax[2])
+ {
int index_in = smoke_get_index(x - em2->hmin[0], em2->hres[0], y - em2->hmin[1], em2->hres[1], z - em2->hmin[2]);
/* values */
notthis = bs->v2;
}
else {
- if (v0 == bs->v2) {
- bpo = sb->bpoint+bs->v1;
- notthis = bs->v1;
- }
- else {printf("oops we should not get here - add_2nd_order_springs");}
+ if (v0 == bs->v2) {
+ bpo = sb->bpoint+bs->v1;
+ notthis = bs->v1;
+ }
+ else {
+ printf("oops we should not get here - add_2nd_order_springs");
+ }
}
if (bpo) {/* so now we have a 2nd order humpdidump */
for (c=bpo->nofsprings;c>0;c--) {
/* intitialize */
if (sb) {
- /* check conditions for various options */
- /* +++ could be done on object level to squeeze out the last bits of it */
- do_selfcollision=((ob->softflag & OB_SB_EDGES) && (sb->bspring)&& (ob->softflag & OB_SB_SELF));
- do_springcollision=do_deflector && (ob->softflag & OB_SB_EDGES) &&(ob->softflag & OB_SB_EDGECOLL);
- do_aero=((sb->aeroedge)&& (ob->softflag & OB_SB_EDGES));
- /* --- could be done on object level to squeeze out the last bits of it */
+ /* check conditions for various options */
+ /* +++ could be done on object level to squeeze out the last bits of it */
+ do_selfcollision=((ob->softflag & OB_SB_EDGES) && (sb->bspring)&& (ob->softflag & OB_SB_SELF));
+ do_springcollision=do_deflector && (ob->softflag & OB_SB_EDGES) &&(ob->softflag & OB_SB_EDGECOLL);
+ do_aero=((sb->aeroedge)&& (ob->softflag & OB_SB_EDGES));
+ /* --- could be done on object level to squeeze out the last bits of it */
}
else {
printf("Error expected a SB here\n");
l = len_v3v3(bp1->pos, bp2->pos);
r = bs->len/l;
if (( r > 1.05f) || (r < 0.95f)) {
- bs->len = ((100.0f - b) * bs->len + b*l)/100.0f;
+ bs->len = ((100.0f - b) * bs->len + b*l)/100.0f;
}
}
}
sb= ob->soft;
if (me && sb) {
- /* using bp->origS as a container for spring calcualtions here
- * will be overwritten sbObjectStep() to receive
- * actual modifier stack positions
- */
+ /* using bp->origS as a container for spring calcualtions here
+ * will be overwritten sbObjectStep() to receive
+ * actual modifier stack positions
+ */
if (me->totvert) {
bp= ob->soft->bpoint;
for (a=0; a<me->totvert; a++, bp++) {
SB_estimate_transform(ob, NULL, NULL, NULL);
}
switch (ob->type) {
- case OB_MESH:
- if (ob->softflag & OB_SB_FACECOLL) mesh_faces_to_scratch(ob);
- break;
- case OB_LATTICE:
- break;
- case OB_CURVE:
- case OB_SURF:
- break;
- default:
- break;
+ case OB_MESH:
+ if (ob->softflag & OB_SB_FACECOLL) mesh_faces_to_scratch(ob);
+ break;
+ case OB_LATTICE:
+ break;
+ case OB_CURVE:
+ case OB_SURF:
+ break;
+ default:
+ break;
}
}
}
}
{
- /* Warn the user if he is using ["Text"] properties for Font objects */
+ /* Warn the user if he is using ["Text"] properties for Font objects */
Object *ob;
bProperty *prop;
"bmesh_to_mesh",
/* slots_in */
{
- /* pointer to a mesh structure to fill in */
+ /* pointer to a mesh structure to fill in */
{"mesh", BMO_OP_SLOT_PTR, {(int)BMO_OP_SLOT_SUBTYPE_PTR_MESH}},
/* pointer to an object structure */
{"object", BMO_OP_SLOT_PTR, {(int)BMO_OP_SLOT_SUBTYPE_PTR_OBJECT}},
"mesh_to_bmesh",
/* slots_in */
{
- /* pointer to a Mesh structure */
+ /* pointer to a Mesh structure */
{"mesh", BMO_OP_SLOT_PTR, {(int)BMO_OP_SLOT_SUBTYPE_PTR_MESH}},
/* pointer to an Object structure */
{"object", BMO_OP_SLOT_PTR, {(int)BMO_OP_SLOT_SUBTYPE_PTR_OBJECT}},
#if 0
else if (BM_elem_index_get(l->prev->v) == -1) {
if (BM_elem_index_get(l->next->next->v) == -1) {
+ /* pass */
}
}
#endif
}
case COLLADAFW::Transformation::MATRIX:
- /*{
- COLLADAFW::Matrix *mat = (COLLADAFW::Matrix*)transform;
- COLLADABU::Math::Matrix4 mat4 = mat->getMatrix();
- switch (binding->animationClass) {
- case COLLADAFW::AnimationList::TRANSFORM:
-
- }
- }*/
+#if 0
+ {
+ COLLADAFW::Matrix *mat = (COLLADAFW::Matrix*)transform;
+ COLLADABU::Math::Matrix4 mat4 = mat->getMatrix();
+ switch (binding->animationClass) {
+ case COLLADAFW::AnimationList::TRANSFORM:
+
+ }
+ }
+#endif
unused_fcurve(curves);
break;
case COLLADAFW::Transformation::SKEW:
openLibrary();
std::set<Image *>::iterator uv_images_iter;
for (uv_images_iter = uv_images.begin();
- uv_images_iter != uv_images.end();
- uv_images_iter++) {
+ uv_images_iter != uv_images.end();
+ uv_images_iter++)
+ {
Image *ima = *uv_images_iter;
std::string key(id_name(ima));
{
std::set<Image *>::iterator uv_images_iter;
for (uv_images_iter = uv_images.begin();
- uv_images_iter != uv_images.end();
- uv_images_iter++) {
+ uv_images_iter != uv_images.end();
+ uv_images_iter++)
+ {
Image *ima = *uv_images_iter;
std::string imageid(id_name(ima));
std::set<Image *> uv_images = bc_getUVImages(ob, all_uv_layers);
std::set<Image *>::iterator uv_images_iter;
for (uv_images_iter = uv_images.begin();
- uv_images_iter != uv_images.end();
- uv_images_iter++) {
+ uv_images_iter != uv_images.end();
+ uv_images_iter++)
+ {
Image *ima = *uv_images_iter;
std::string matid(id_name(ima));
matid = get_material_id_from_id(matid);
openLibrary();
std::set<Image *>::iterator uv_images_iter;
for (uv_images_iter = uv_images.begin();
- uv_images_iter != uv_images.end();
- uv_images_iter++) {
+ uv_images_iter != uv_images.end();
+ uv_images_iter++)
+ {
Image *ima = *uv_images_iter;
std::string matid(id_name(ima));
}
if (collada_meshtype == COLLADAFW::MeshPrimitive::POLYLIST ||
- collada_meshtype == COLLADAFW::MeshPrimitive::POLYGONS ||
- collada_meshtype == COLLADAFW::MeshPrimitive::TRIANGLES) {
+ collada_meshtype == COLLADAFW::MeshPrimitive::POLYGONS ||
+ collada_meshtype == COLLADAFW::MeshPrimitive::TRIANGLES)
+ {
COLLADAFW::Polygons *mpvc = (COLLADAFW::Polygons *)mp;
unsigned int start_index = 0;
IDProperty *property = bc_get_IDProperty(bone, key);
if (property) {
switch (property->type) {
- case IDP_INT:
- result = (float)(IDP_Int(property));
- break;
- case IDP_FLOAT:
- result = (float)(IDP_Float(property));
- break;
- case IDP_DOUBLE:
- result = (float)(IDP_Double(property));
- break;
- default:
- result = def;
+ case IDP_INT:
+ result = (float)(IDP_Int(property));
+ break;
+ case IDP_FLOAT:
+ result = (float)(IDP_Float(property));
+ break;
+ case IDP_DOUBLE:
+ result = (float)(IDP_Double(property));
+ break;
+ default:
+ result = def;
}
}
return result;
}
}
return UVImages;
-}
\ No newline at end of file
+}
const RenderData *rd = this->m_rd;
if (rd->mode & R_BORDER && rd->mode & R_CROP) {
- /*!
- When using cropped render result, need to re-position area of interest,
- so it'll natch bounds of render border within frame. By default, canvas
- will be centered between full frame and cropped frame, so we use such
- scheme to map cropped coordinates to full-frame coordinates
-
- ^ Y
- | Width
- +------------------------------------------------+
- | |
- | |
- | Centered canvas, we map coordinate from it |
- | +------------------+ |
- | | | | H
- | | | | e
- | +------------------+ . Center | | i
- | | | | | | g
- | | | | | | h
- | |....dx.... +------|-----------+ | t
- | | . dy | |
- | +------------------+ |
- | Render border, we map coordinates to it |
- | | X
- +------------------------------------------------+---->
- Full frame
+ /**
+ * When using cropped render result, need to re-position area of interest,
+ * so it'll natch bounds of render border within frame. By default, canvas
+ * will be centered between full frame and cropped frame, so we use such
+ * scheme to map cropped coordinates to full-frame coordinates
+ *
+ * ^ Y
+ * | Width
+ * +------------------------------------------------+
+ * | |
+ * | |
+ * | Centered canvas, we map coordinate from it |
+ * | +------------------+ |
+ * | | | | H
+ * | | | | e
+ * | +------------------+ . Center | | i
+ * | | | | | | g
+ * | | | | | | h
+ * | |....dx.... +------|-----------+ | t
+ * | | . dy | |
+ * | +------------------+ |
+ * | Render border, we map coordinates to it |
+ * | | X
+ * +------------------------------------------------+---->
+ * Full frame
*/
int full_width = rd->xsch * rd->size / 100;
/* if we haven't found one yet, look in control bones */
if (ctrl->tail_mode == TL_NONE) {
+ /* pass */
}
}
}
/**
* Include next version bump.
- *
- * (keep this block even if it becomes empty).
*/
{
-
+ /* (keep this block even if it becomes empty). */
}
if (U.pixelsize == 0.0f)
/* check if we're close enough and calculate 'lambda' */
if (kcd->is_angle_snapping) {
- /* if snapping, check we're in bounds */
+ /* if snapping, check we're in bounds */
float sco_snap[2];
isect_line_line_v2_point(kfe->v1->sco, kfe->v2->sco, kcd->prev.mval, kcd->curr.mval, sco_snap);
lambda = line_point_factor_v2(sco_snap, kfe->v1->sco, kfe->v2->sco);
static void select_action_apply(PTCacheEditPoint *point, PTCacheEditKey *key, int action)
{
switch (action) {
- case SEL_SELECT:
- if ((key->flag & PEK_SELECT) == 0) {
- key->flag |= PEK_SELECT;
- point->flag |= PEP_EDIT_RECALC;
- }
- break;
- case SEL_DESELECT:
- if (key->flag & PEK_SELECT) {
- key->flag &= ~PEK_SELECT;
- point->flag |= PEP_EDIT_RECALC;
- }
- break;
- case SEL_INVERT:
- if ((key->flag & PEK_SELECT) == 0) {
- key->flag |= PEK_SELECT;
- point->flag |= PEP_EDIT_RECALC;
- }
- else {
- key->flag &= ~PEK_SELECT;
- point->flag |= PEP_EDIT_RECALC;
- }
- break;
+ case SEL_SELECT:
+ if ((key->flag & PEK_SELECT) == 0) {
+ key->flag |= PEK_SELECT;
+ point->flag |= PEP_EDIT_RECALC;
+ }
+ break;
+ case SEL_DESELECT:
+ if (key->flag & PEK_SELECT) {
+ key->flag &= ~PEK_SELECT;
+ point->flag |= PEP_EDIT_RECALC;
+ }
+ break;
+ case SEL_INVERT:
+ if ((key->flag & PEK_SELECT) == 0) {
+ key->flag |= PEK_SELECT;
+ point->flag |= PEP_EDIT_RECALC;
+ }
+ else {
+ key->flag &= ~PEK_SELECT;
+ point->flag |= PEP_EDIT_RECALC;
+ }
+ break;
}
}
sAreaSplitData *sd = (sAreaSplitData *)op->customdata;
if (sd->previewmode) {
+ /* pass */
}
else {
if (screen_area_join(C, CTX_wm_screen(C), sd->sarea, sd->narea)) {
#if 0
/* context changes */
switch (wmn->category) {
-
+ /* pass */
}
#endif
}
//Scene *scene = CTX_data_scene(C);
#if 0
switch (event) {
-
+ /* pass */
}
#endif
/* default for now */
/* NOTE: sequencer mask editing isnt finished, the draw code is working but editing not,
* for now just disable drawing since the strip frame will likely be offset */
- //if (sc->mode == SC_MODE_MASKEDIT) {
+ // if (sc->mode == SC_MODE_MASKEDIT)
if (0 && sseq->mainb == SEQ_DRAW_IMG_IMBUF) {
Mask *mask = BKE_sequencer_mask_get(scene);
project_plane_normalized_v3_v3v3(v_proj[1], sv->co_orig_3d, v_proj_axis);
}
- // BM_ITER_ELEM (l, &liter, sv->v, BM_LOOPS_OF_VERT) {
+ // BM_ITER_ELEM (l, &liter, sv->v, BM_LOOPS_OF_VERT)
BM_iter_init(&liter, bm, BM_LOOPS_OF_VERT, sv->v);
l_num = liter.count;
loop_weights = do_loop_weight ? BLI_array_alloca(loop_weights, l_num) : NULL;
{
// Make sure the masks are correct.
if ((rmask & gmask) ||
- (rmask & bmask) ||
- (rmask & amask) ||
- (gmask & bmask) ||
- (gmask & amask) ||
- (bmask & amask)) {
+ (rmask & bmask) ||
+ (rmask & amask) ||
+ (gmask & bmask) ||
+ (gmask & amask) ||
+ (bmask & amask))
+ {
printf("DDS: bad RGBA masks, pixel format not set\n");
return;
}
}
else
{
- return (header.caps.caps2 & DDSCAPS2_VOLUME) != 0;
+ return (header.caps.caps2 & DDSCAPS2_VOLUME) != 0;
}
}
RNA_enum_items_add_value(&item, &totitem, prop_texture_coordinates_items, TEXCO_ORCO);
if (ma->material_type == MA_TYPE_VOLUME) {
-
+ /* pass */
}
else if (ELEM(ma->material_type, MA_TYPE_SURFACE, MA_TYPE_HALO, MA_TYPE_WIRE)) {
RNA_enum_items_add_value(&item, &totitem, prop_texture_coordinates_items, TEXCO_UV);
/* input */
switch (ma->rampin_col) {
- case MA_RAMP_IN_ENERGY:
- fac = IMB_colormanagement_get_luminance(rgb);
- break;
- case MA_RAMP_IN_SHADER:
- fac = is;
- break;
- case MA_RAMP_IN_NOR:
- fac = dot_v3v3(shi->view, shi->vn);
- break;
- default:
- fac = 0.0f;
- break;
+ case MA_RAMP_IN_ENERGY:
+ fac = IMB_colormanagement_get_luminance(rgb);
+ break;
+ case MA_RAMP_IN_SHADER:
+ fac = is;
+ break;
+ case MA_RAMP_IN_NOR:
+ fac = dot_v3v3(shi->view, shi->vn);
+ break;
+ default:
+ fac = 0.0f;
+ break;
}
BKE_colorband_evaluate(ma->ramp_col, fac, col);
projects / blender.git / commitdiff