static void strand_shade_point(Render *re, ShadeSample *ssamp, StrandSegment *sseg, StrandVert *svert, StrandPoint *spoint)
{
ShadeInput *shi= ssamp->shi;
ShadeResult *shr= ssamp->shr;
VlakRen vlr;
int seed;
memset(&vlr, 0, sizeof(vlr));
vlr.flag= R_SMOOTH;
if (sseg->buffer->ma->mode & MA_TANGENT_STR)
vlr.flag |= R_TANGENT;
shi->vlr= &vlr;
shi->v1= NULL;
shi->v2= NULL;
shi->v3= NULL;
shi->strand= sseg->strand;
shi->obi= sseg->obi;
shi->obr= sseg->obi->obr;
/* cache for shadow */
shi->samplenr= re->shadowsamplenr[shi->thread]++;
/* all samples */
shi->mask= 0xFFFF;
/* seed RNG for consistent results across tiles */
seed = shi->strand->index + (svert - shi->strand->vert);
BLI_thread_srandom(shi->thread, seed);
shade_input_set_strand(shi, sseg->strand, spoint);
shade_input_set_strand_texco(shi, sseg->strand, sseg->v[1], spoint);
/* init material vars */
shade_input_init_material(shi);
/* shade */
shade_samples_do_AO(ssamp);
shade_input_do_shade(shi, shr);
/* apply simplification */
strand_apply_shaderesult_alpha(shr, spoint->alpha);
/* include lamphalos for strand, since halo layer was added already */
if (re->flag & R_LAMPHALO)
if (shi->layflag & SCE_LAY_HALO)
renderspothalo(shi, shr->combined, shr->combined[3]);
shi->strand= NULL;
}
static void bake_shade(void *handle, Object *ob, ShadeInput *shi, int UNUSED(quad), int x, int y, float UNUSED(u), float UNUSED(v), float *tvn, float *ttang)
{
BakeShade *bs = handle;
ShadeSample *ssamp = &bs->ssamp;
ShadeResult shr;
VlakRen *vlr = shi->vlr;
shade_input_init_material(shi);
if (bs->type == RE_BAKE_AO) {
ambient_occlusion(shi);
if (R.r.bake_flag & R_BAKE_NORMALIZE) {
copy_v3_v3(shr.combined, shi->ao);
}
else {
zero_v3(shr.combined);
environment_lighting_apply(shi, &shr);
}
}
else {
if (bs->type == RE_BAKE_SHADOW) /* Why do shadows set the color anyhow?, ignore material color for baking */
shi->r = shi->g = shi->b = 1.0f;
shade_input_set_shade_texco(shi);
/* only do AO for a full bake (and obviously AO bakes)
* AO for light bakes is a leftover and might not be needed */
if (ELEM3(bs->type, RE_BAKE_ALL, RE_BAKE_AO, RE_BAKE_LIGHT))
shade_samples_do_AO(ssamp);
if (shi->mat->nodetree && shi->mat->use_nodes) {
ntreeShaderExecTree(shi->mat->nodetree, shi, &shr);
shi->mat = vlr->mat; /* shi->mat is being set in nodetree */
}
else
shade_material_loop(shi, &shr);
if (bs->type == RE_BAKE_NORMALS) {
float nor[3];
copy_v3_v3(nor, shi->vn);
if (R.r.bake_normal_space == R_BAKE_SPACE_CAMERA) {
/* pass */
}
else if (R.r.bake_normal_space == R_BAKE_SPACE_TANGENT) {
float mat[3][3], imat[3][3];
/* bitangent */
if (tvn && ttang) {
copy_v3_v3(mat[0], ttang);
cross_v3_v3v3(mat[1], tvn, ttang);
mul_v3_fl(mat[1], ttang[3]);
copy_v3_v3(mat[2], tvn);
}
else {
copy_v3_v3(mat[0], shi->nmaptang);
cross_v3_v3v3(mat[1], shi->nmapnorm, shi->nmaptang);
mul_v3_fl(mat[1], shi->nmaptang[3]);
copy_v3_v3(mat[2], shi->nmapnorm);
}
invert_m3_m3(imat, mat);
mul_m3_v3(imat, nor);
}
else if (R.r.bake_normal_space == R_BAKE_SPACE_OBJECT)
mul_mat3_m4_v3(ob->imat_ren, nor); /* ob->imat_ren includes viewinv! */
else if (R.r.bake_normal_space == R_BAKE_SPACE_WORLD)
mul_mat3_m4_v3(R.viewinv, nor);
normalize_v3(nor); /* in case object has scaling */
/* The invert of the red channel is to make
* the normal map compliant with the outside world.
* It needs to be done because in Blender
* the normal used in the renderer points inward. It is generated
* this way in calc_vertexnormals(). Should this ever change
* this negate must be removed. */
shr.combined[0] = (-nor[0]) / 2.0f + 0.5f;
shr.combined[1] = nor[1] / 2.0f + 0.5f;
shr.combined[2] = nor[2] / 2.0f + 0.5f;
}
else if (bs->type == RE_BAKE_TEXTURE) {
copy_v3_v3(shr.combined, &shi->r);
shr.alpha = shi->alpha;
}
else if (bs->type == RE_BAKE_SHADOW) {
copy_v3_v3(shr.combined, shr.shad);
shr.alpha = shi->alpha;
}
else if (bs->type == RE_BAKE_SPEC_COLOR) {
copy_v3_v3(shr.combined, &shi->specr);
shr.alpha = 1.0f;
}
else if (bs->type == RE_BAKE_SPEC_INTENSITY) {
copy_v3_fl(shr.combined, shi->spec);
shr.alpha = 1.0f;
}
else if (bs->type == RE_BAKE_MIRROR_COLOR) {
copy_v3_v3(shr.combined, &shi->mirr);
shr.alpha = 1.0f;
}
else if (bs->type == RE_BAKE_MIRROR_INTENSITY) {
copy_v3_fl(shr.combined, shi->ray_mirror);
shr.alpha = 1.0f;
}
else if (bs->type == RE_BAKE_ALPHA) {
copy_v3_fl(shr.combined, shi->alpha);
shr.alpha = 1.0f;
}
else if (bs->type == RE_BAKE_EMIT) {
copy_v3_fl(shr.combined, shi->emit);
shr.alpha = 1.0f;
}
else if (bs->type == RE_BAKE_VERTEX_COLORS) {
copy_v3_v3(shr.combined, shi->vcol);
shr.alpha = shi->vcol[3];
}
}
if (bs->rect_float && !bs->vcol) {
float *col = bs->rect_float + 4 * (bs->rectx * y + x);
copy_v3_v3(col, shr.combined);
if (bs->type == RE_BAKE_ALL || bs->type == RE_BAKE_TEXTURE || bs->type == RE_BAKE_VERTEX_COLORS) {
col[3] = shr.alpha;
}
else {
col[3] = 1.0;
}
}
else {
/* Target is char (LDR). */
unsigned char col[4];
if (ELEM(bs->type, RE_BAKE_ALL, RE_BAKE_TEXTURE)) {
float rgb[3];
copy_v3_v3(rgb, shr.combined);
if (R.scene_color_manage) {
/* Vertex colors have no way to specify color space, so they
* default to sRGB. */
if (!bs->vcol)
IMB_colormanagement_scene_linear_to_colorspace_v3(rgb, bs->rect_colorspace);
else
linearrgb_to_srgb_v3_v3(rgb, rgb);
}
rgb_float_to_uchar(col, rgb);
}
else {
rgb_float_to_uchar(col, shr.combined);
}
if (ELEM3(bs->type, RE_BAKE_ALL, RE_BAKE_TEXTURE, RE_BAKE_VERTEX_COLORS)) {
col[3] = FTOCHAR(shr.alpha);
}
else {
col[3] = 255;
}
if (bs->vcol) {
/* Vertex color baking. Vcol has no useful alpha channel (it exists
* but is used only for vertex painting). */
bs->vcol->r = col[0];
bs->vcol->g = col[1];
bs->vcol->b = col[2];
}
else {
unsigned char *imcol = (unsigned char *)(bs->rect + bs->rectx * y + x);
copy_v4_v4_char((char *)imcol, (char *)col);
}
}
if (bs->rect_mask) {
bs->rect_mask[bs->rectx * y + x] = FILTER_MASK_USED;
}
if (bs->do_update) {
*bs->do_update = true;
}
}