sandey/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

edits to internal renderer - no functional changes.

Browse Source 
- move some larger vars into a nested scope.
- replace memset with zero initializer.
- rempace VECCOPY macros with copy_v3v3
- change function args to give the float array length.
This commit is contained in:
Campbell Barton 2011-09-24 14:34:24 +00:00
parent e63c124e2b
commit cb6255fdf8
10 changed files with 178 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
source/blender/render/intern/include/rendercore.h
View File

@ -76,12 +76,12 @@ typedef struct PixStrMain
void calc_view_vector(float *view, float x, float y);
float mistfactor(float zcor, float *co); /* dist and height, return alpha */
float mistfactor(float zcor, const float co[3]); /* dist and height, return alpha */
void renderspothalo(struct ShadeInput *shi, float *col, float alpha);
void renderspothalo(struct ShadeInput *shi, float col[4], float alpha);
void add_halo_flare(Render *re);
void calc_renderco_zbuf(float co[3], float *view, int z);
void calc_renderco_zbuf(float co[3], const float view[3], int z);
void calc_renderco_ortho(float co[3], float x, float y, int z);
int count_mask(unsigned short mask);
@ -103,9 +103,9 @@ extern void freeraytree(Render *re);
extern void makeraytree(Render *re);
struct RayObject* makeraytree_object(Render *re, ObjectInstanceRen *obi);
extern void ray_shadow(ShadeInput *, LampRen *, float *);
extern void ray_trace(ShadeInput *, ShadeResult *);
extern void ray_ao(ShadeInput *, float *, float *);
extern void ray_shadow(ShadeInput *shi, LampRen *lar, float shadfac[4]);
extern void ray_trace(ShadeInput *shi, ShadeResult *);
extern void ray_ao(ShadeInput *shi, float ao[3], float env[3]);
extern void init_jitter_plane(LampRen *lar);
extern void init_ao_sphere(struct World *wrld);
extern void init_render_qmcsampler(Render *re);

4
source/blender/render/intern/include/shading.h
View File

@ -96,8 +96,8 @@ void ambient_occlusion(struct ShadeInput *shi);
void environment_lighting_apply(struct ShadeInput *shi, struct ShadeResult *shr);
ListBase *get_lights(struct ShadeInput *shi);
float lamp_get_visibility(struct LampRen *lar, const float co[3], float *lv, float *dist);
void lamp_get_shadow(struct LampRen *lar, ShadeInput *shi, float inp, float *shadfac, int do_real);
float lamp_get_visibility(struct LampRen *lar, const float co[3], float lv[3], float *dist);
void lamp_get_shadow(struct LampRen *lar, ShadeInput *shi, float inp, float shadfac[4], int do_real);
float fresnel_fac(float *view, float *vn, float fresnel, float fac);

10
source/blender/render/intern/source/convertblender.c
View File

@ -5304,11 +5304,13 @@ static void calculate_speedvector(const float vectors[2], int step, float winsq,
static float *calculate_strandsurface_speedvectors(Render *re, ObjectInstanceRen *obi, StrandSurface *mesh)
{
float winsq= (float)re->winx*(float)re->winy, winroot= sqrt(winsq), (*winspeed)[4]; /* int's can wrap on large images */
float ho[4], prevho[4], nextho[4], winmat[4][4], vec[2];
int a;
if(mesh->co && mesh->prevco && mesh->nextco) {
float winsq= (float)re->winx*(float)re->winy; /* int's can wrap on large images */
float winroot= sqrt(winsq);
float (*winspeed)[4];
float ho[4], prevho[4], nextho[4], winmat[4][4], vec[2];
int a;
if(obi->flag & R_TRANSFORMED)
mul_m4_m4m4(winmat, obi->mat, re->winmat);
else

6
source/blender/render/intern/source/envmap.c
View File

@ -689,9 +689,9 @@ int envmaptex(Tex *tex, float *texvec, float *dxt, float *dyt, int osatex, TexRe
env->ima= tex->ima;
if(env->ima && env->ima->ok) {
if(env->cube[1]==NULL) {
ImBuf *ibuf= BKE_image_get_ibuf(env->ima, NULL);
if(ibuf)
envmap_split_ima(env, ibuf);
ImBuf *ibuf_ima= BKE_image_get_ibuf(env->ima, NULL);
if(ibuf_ima)
envmap_split_ima(env, ibuf_ima);
else
env->ok= 0;
}

241
source/blender/render/intern/source/rayshade.c
View File

@ -334,7 +334,6 @@ static void makeraytree_single(Render *re)
for(obi=re->instancetable.first; obi; obi=obi->next)
if(is_raytraceable(re, obi))
{
int v;
ObjectRen *obr = obi->obr;
obs++;
@ -344,6 +343,7 @@ static void makeraytree_single(Render *re)
}
else
{
int v;
for(v=0;v<obr->totvlak;v++)
{
VlakRen *vlr = obr->vlaknodes[v>>8].vlak + (v&255);
@ -539,7 +539,7 @@ void shade_ray(Isect *is, ShadeInput *shi, ShadeResult *shr)
VlakRen *vlr= (VlakRen*)is->hit.face;
/* set up view vector */
VECCOPY(shi->view, is->dir);
copy_v3_v3(shi->view, is->dir);
/* render co */
shi->co[0]= is->start[0]+is->dist*(shi->view[0]);
@ -594,16 +594,16 @@ void shade_ray(Isect *is, ShadeInput *shi, ShadeResult *shr)
}
/* raytrace likes to separate the spec color */
VECSUB(shr->diff, shr->combined, shr->spec);
sub_v3_v3v3(shr->diff, shr->combined, shr->spec);
}
}
static int refraction(float *refract, float *n, float *view, float index)
static int refraction(float refract[3], const float n[3], const float view[3], float index)
{
float dot, fac;
VECCOPY(refract, view);
copy_v3_v3(refract, view);
dot= view[0]*n[0] + view[1]*n[1] + view[2]*n[2];
@ -626,26 +626,26 @@ static int refraction(float *refract, float *n, float *view, float index)
return 1;
}
static void reflection_simple(float ref[3], float n[3], const float view[3])
{
const float f1= -2.0f * dot_v3v3(n, view);
madd_v3_v3v3fl(ref, view, n, f1);
}
/* orn = original face normal */
static void reflection(float *ref, float *n, float *view, float *orn)
static void reflection(float ref[3], float n[3], const float view[3], const float orn[3])
{
float f1;
f1= -2.0f*(n[0]*view[0]+ n[1]*view[1]+ n[2]*view[2]);
ref[0]= (view[0]+f1*n[0]);
ref[1]= (view[1]+f1*n[1]);
ref[2]= (view[2]+f1*n[2]);
if(orn) {
/* test phong normals, then we should prevent vector going to the back */
f1= ref[0]*orn[0]+ ref[1]*orn[1]+ ref[2]*orn[2];
if(f1>0.0f) {
f1+= .01f;
ref[0]-= f1*orn[0];
ref[1]-= f1*orn[1];
ref[2]-= f1*orn[2];
}
reflection_simple(ref, n, view);
/* test phong normals, then we should prevent vector going to the back */
f1= dot_v3v3(ref, orn);
if(f1>0.0f) {
f1+= 0.01f;
ref[0]-= f1*orn[0];
ref[1]-= f1*orn[1];
ref[2]-= f1*orn[2];
}
}
@ -672,8 +672,7 @@ static void color_combine(float *result, float fac1, float fac2, float *col1, fl
static float shade_by_transmission(Isect *is, ShadeInput *shi, ShadeResult *shr)
{
float dx, dy, dz, d, p;
float d;
if (0 == (shi->mat->mode & MA_TRANSP))
return -1;
@ -681,10 +680,12 @@ static float shade_by_transmission(Isect *is, ShadeInput *shi, ShadeResult *shr)
d= 1.0f;
}
else {
float p;
/* shi.co[] calculated by shade_ray() */
dx= shi->co[0] - is->start[0];
dy= shi->co[1] - is->start[1];
dz= shi->co[2] - is->start[2];
const float dx= shi->co[0] - is->start[0];
const float dy= shi->co[1] - is->start[1];
const float dz= shi->co[2] - is->start[2];
d= sqrt(dx*dx+dy*dy+dz*dz);
if (d > shi->mat->tx_limit)
d= shi->mat->tx_limit;
@ -701,13 +702,13 @@ static float shade_by_transmission(Isect *is, ShadeInput *shi, ShadeResult *shr)
return d;
}
static void ray_fadeout_endcolor(float *col, ShadeInput *origshi, ShadeInput *shi, ShadeResult *shr, Isect *isec, float *vec)
static void ray_fadeout_endcolor(float col[3], ShadeInput *origshi, ShadeInput *shi, ShadeResult *shr, Isect *isec, const float vec[3])
{
/* un-intersected rays get either rendered material color or sky color */
if (origshi->mat->fadeto_mir == MA_RAYMIR_FADETOMAT) {
VECCOPY(col, shr->combined);
copy_v3_v3(col, shr->combined);
} else if (origshi->mat->fadeto_mir == MA_RAYMIR_FADETOSKY) {
VECCOPY(shi->view, vec);
copy_v3_v3(shi->view, vec);
normalize_v3(shi->view);
shadeSkyView(col, isec->start, shi->view, NULL, shi->thread);
@ -715,7 +716,7 @@ static void ray_fadeout_endcolor(float *col, ShadeInput *origshi, ShadeInput *sh
}
}
static void ray_fadeout(Isect *is, ShadeInput *shi, float *col, float *blendcol, float dist_mir)
static void ray_fadeout(Isect *is, ShadeInput *shi, float col[3], const float blendcol[3], float dist_mir)
{
/* if fading out, linear blend against fade color */
float blendfac;
@ -729,14 +730,14 @@ static void ray_fadeout(Isect *is, ShadeInput *shi, float *col, float *blendcol,
/* the main recursive tracer itself
* note: 'col' must be initialized */
static void traceray(ShadeInput *origshi, ShadeResult *origshr, short depth, float *start, float *dir, float *col, ObjectInstanceRen *obi, VlakRen *vlr, int traflag)
static void traceray(ShadeInput *origshi, ShadeResult *origshr, short depth, const float start[3], const float dir[3], float col[4], ObjectInstanceRen *obi, VlakRen *vlr, int traflag)
{
ShadeInput shi= {0};
Isect isec;
float dist_mir = origshi->mat->dist_mir;
VECCOPY(isec.start, start);
VECCOPY(isec.dir, dir );
copy_v3_v3(isec.start, start);
copy_v3_v3(isec.dir, dir );
isec.dist = dist_mir > 0 ? dist_mir : RE_RAYTRACE_MAXDIST;
isec.mode= RE_RAY_MIRROR;
isec.check = RE_CHECK_VLR_RENDER;
@ -752,8 +753,8 @@ static void traceray(ShadeInput *origshi, ShadeResult *origshr, short depth, flo
float d= 1.0f;
/* for as long we don't have proper dx/dy transform for rays we copy over original */
VECCOPY(shi.dxco, origshi->dxco);
VECCOPY(shi.dyco, origshi->dyco);
copy_v3_v3(shi.dxco, origshi->dxco);
copy_v3_v3(shi.dyco, origshi->dyco);
shi.mask= origshi->mask;
shi.osatex= origshi->osatex;
@ -845,7 +846,7 @@ static void traceray(ShadeInput *origshi, ShadeResult *origshr, short depth, flo
float mircol[4];
float ref[3];
reflection(ref, shi.vn, shi.view, NULL);
reflection_simple(ref, shi.vn, shi.view);
traceray(origshi, origshr, depth-1, shi.co, ref, mircol, shi.obi, shi.vlr, 0);
f1= 1.0f-f;
@ -896,7 +897,7 @@ static void traceray(ShadeInput *origshi, ShadeResult *origshr, short depth, flo
/* calc distributed planar energy */
static void DP_energy(float *table, float *vec, int tot, float xsize, float ysize)
static void DP_energy(float *table, float vec[2], int tot, float xsize, float ysize)
{
int x, y, a;
float *fp, force[3], result[3];
@ -950,7 +951,7 @@ static void jitter_plane_offset(float *jitter1, float *jitter2, int tot, float s
void init_jitter_plane(LampRen *lar)
{
float *fp;
int x, iter=12, tot= lar->ray_totsamp;
int x, tot= lar->ray_totsamp;
/* test if already initialized */
if(lar->jitter) return;
@ -962,7 +963,8 @@ void init_jitter_plane(LampRen *lar)
/* if 1 sample, we leave table to be zero's */
if(tot>1) {
int iter=12;
/* set per-lamp fixed seed */
BLI_srandom(tot);
@ -1125,7 +1127,7 @@ static void QMC_getSample(double *s, QMCSampler *qsa, int thread, int num)
}
/* phong weighted disc using 'blur' for exponent, centred on 0,0 */
static void QMC_samplePhong(float *vec, QMCSampler *qsa, int thread, int num, float blur)
static void QMC_samplePhong(float vec[3], QMCSampler *qsa, int thread, int num, float blur)
{
double s[2];
float phi, pz, sqr;
@ -1142,7 +1144,7 @@ static void QMC_samplePhong(float *vec, QMCSampler *qsa, int thread, int num, fl
}
/* rect of edge lengths sizex, sizey, centred on 0.0,0.0 i.e. ranging from -sizex/2 to +sizey/2 */
static void QMC_sampleRect(float *vec, QMCSampler *qsa, int thread, int num, float sizex, float sizey)
static void QMC_sampleRect(float vec[3], QMCSampler *qsa, int thread, int num, float sizex, float sizey)
{
double s[2];
@ -1154,7 +1156,7 @@ static void QMC_sampleRect(float *vec, QMCSampler *qsa, int thread, int num, flo
}
/* disc of radius 'radius', centred on 0,0 */
static void QMC_sampleDisc(float *vec, QMCSampler *qsa, int thread, int num, float radius)
static void QMC_sampleDisc(float vec[3], QMCSampler *qsa, int thread, int num, float radius)
{
double s[2];
float phi, sqr;
@ -1170,7 +1172,7 @@ static void QMC_sampleDisc(float *vec, QMCSampler *qsa, int thread, int num, flo
}
/* uniform hemisphere sampling */
static void QMC_sampleHemi(float *vec, QMCSampler *qsa, int thread, int num)
static void QMC_sampleHemi(float vec[3], QMCSampler *qsa, int thread, int num)
{
double s[2];
float phi, sqr;
@ -1187,7 +1189,7 @@ static void QMC_sampleHemi(float *vec, QMCSampler *qsa, int thread, int num)
#if 0 /* currently not used */
/* cosine weighted hemisphere sampling */
static void QMC_sampleHemiCosine(float *vec, QMCSampler *qsa, int thread, int num)
static void QMC_sampleHemiCosine(float vec[3], QMCSampler *qsa, int thread, int num)
{
double s[2];
float phi, sqr;
@ -1238,10 +1240,9 @@ static void release_thread_qmcsampler(Render *UNUSED(re), int UNUSED(thread), QM
void free_render_qmcsampler(Render *re)
{
QMCSampler *qsa, *next;
int a;
if(re->qmcsamplers) {
QMCSampler *qsa, *next;
int a;
for(a=0; a<BLENDER_MAX_THREADS; a++) {
for(qsa=re->qmcsamplers[a].first; qsa; qsa=next) {
next= qsa->next;
@ -1256,7 +1257,7 @@ void free_render_qmcsampler(Render *re)
}
}
static int adaptive_sample_variance(int samples, float *col, float *colsq, float thresh)
static int adaptive_sample_variance(int samples, const float col[3], const float colsq[3], float thresh)
{
float var[3], mean[3];
@ -1306,7 +1307,7 @@ static float get_avg_speed(ShadeInput *shi)
/* ***************** main calls ************** */
static void trace_refract(float *col, ShadeInput *shi, ShadeResult *shr)
static void trace_refract(float col[4], ShadeInput *shi, ShadeResult *shr)
{
QMCSampler *qsa=NULL;
int samp_type;
@ -1345,7 +1346,7 @@ static void trace_refract(float *col, ShadeInput *shi, ShadeResult *shr)
if((shi->vlr->flag & R_SMOOTH))
reflection(v_refract, shi->vn, shi->view, shi->facenor);
else
reflection(v_refract, shi->vn, shi->view, NULL);
reflection_simple(v_refract, shi->vn, shi->view);
/* can't blur total external reflection */
max_samples = 1;
@ -1366,7 +1367,7 @@ static void trace_refract(float *col, ShadeInput *shi, ShadeResult *shr)
normalize_v3(v_refract_new);
} else {
/* no blurriness, use the original normal */
VECCOPY(v_refract_new, v_refract);
copy_v3_v3(v_refract_new, v_refract);
}
sampcol[0]= sampcol[1]= sampcol[2]= sampcol[3]= 0.0f;
@ -1406,7 +1407,7 @@ static void trace_refract(float *col, ShadeInput *shi, ShadeResult *shr)
release_thread_qmcsampler(&R, shi->thread, qsa);
}
static void trace_reflect(float *col, ShadeInput *shi, ShadeResult *shr, float fresnelfac)
static void trace_reflect(float col[3], ShadeInput *shi, ShadeResult *shr, float fresnelfac)
{
QMCSampler *qsa=NULL;
int samp_type;
@ -1445,7 +1446,7 @@ static void trace_reflect(float *col, ShadeInput *shi, ShadeResult *shr, float f
* if tangent shading enabled */
if (shi->mat->mode & (MA_TANGENT_V)) {
cross_v3_v3v3(orthx, shi->vn, shi->tang); // bitangent
VECCOPY(orthy, shi->tang);
copy_v3_v3(orthy, shi->tang);
mul_v3_fl(orthx, samp3d[0]);
mul_v3_fl(orthy, samp3d[1]*aniso);
} else {
@ -1460,13 +1461,13 @@ static void trace_reflect(float *col, ShadeInput *shi, ShadeResult *shr, float f
normalize_v3(v_nor_new);
} else {
/* no blurriness, use the original normal */
VECCOPY(v_nor_new, shi->vn);
copy_v3_v3(v_nor_new, shi->vn);
}
if((shi->vlr->flag & R_SMOOTH))
reflection(v_reflect, v_nor_new, shi->view, shi->facenor);
else
reflection(v_reflect, v_nor_new, shi->view, NULL);
reflection_simple(v_reflect, v_nor_new, shi->view);
sampcol[0]= sampcol[1]= sampcol[2]= sampcol[3]= 0.0f;
@ -1517,7 +1518,7 @@ static void trace_reflect(float *col, ShadeInput *shi, ShadeResult *shr, float f
/* extern call from render loop */
void ray_trace(ShadeInput *shi, ShadeResult *shr)
{
float i, f, f1, fr, fg, fb;
float f1, fr, fg, fb;
float mircol[4], tracol[4];
float diff[3];
int do_tra, do_mir;
@ -1527,12 +1528,12 @@ void ray_trace(ShadeInput *shi, ShadeResult *shr)
/* raytrace mirror amd refract like to separate the spec color */
if(shi->combinedflag & SCE_PASS_SPEC)
VECSUB(diff, shr->combined, shr->spec) /* no ; */
sub_v3_v3v3(diff, shr->combined, shr->spec);
else
VECCOPY(diff, shr->combined);
copy_v3_v3(diff, shr->combined);
if(do_tra) {
float olddiff[3];
float olddiff[3], f;
trace_refract(tracol, shi, shr);
@ -1542,24 +1543,23 @@ void ray_trace(ShadeInput *shi, ShadeResult *shr)
fb= 1.0f+ shi->mat->filter*(shi->b-1.0f);
/* for refract pass */
VECCOPY(olddiff, diff);
copy_v3_v3(olddiff, diff);
diff[0]= f*diff[0] + f1*fr*tracol[0];
diff[1]= f*diff[1] + f1*fg*tracol[1];
diff[2]= f*diff[2] + f1*fb*tracol[2];
if(shi->passflag & SCE_PASS_REFRACT)
VECSUB(shr->refr, diff, olddiff);
sub_v3_v3v3(shr->refr, diff, olddiff);
if(!(shi->combinedflag & SCE_PASS_REFRACT))
VECSUB(diff, diff, shr->refr);
sub_v3_v3v3(diff, diff, shr->refr);
shr->alpha= MIN2(1.0f, tracol[3]);
}
if(do_mir) {
i= shi->ray_mirror*fresnel_fac(shi->view, shi->vn, shi->mat->fresnel_mir_i, shi->mat->fresnel_mir);
const float i= shi->ray_mirror*fresnel_fac(shi->view, shi->vn, shi->mat->fresnel_mir_i, shi->mat->fresnel_mir);
if(i!=0.0f) {
trace_reflect(mircol, shi, shr, i);
@ -1597,12 +1597,12 @@ void ray_trace(ShadeInput *shi, ShadeResult *shr)
if(shi->combinedflag & SCE_PASS_SPEC)
VECADD(shr->combined, diff, shr->spec) /* no ; */
else
VECCOPY(shr->combined, diff);
copy_v3_v3(shr->combined, diff);
}
/* color 'shadfac' passes through 'col' with alpha and filter */
/* filter is only applied on alpha defined transparent part */
static void addAlphaLight(float *shadfac, float *col, float alpha, float filter)
static void addAlphaLight(float shadfac[4], const float col[3], float alpha, float filter)
{
float fr, fg, fb;
@ -1621,19 +1621,20 @@ static void ray_trace_shadow_tra(Isect *is, ShadeInput *origshi, int depth, int
{
/* ray to lamp, find first face that intersects, check alpha properties,
if it has col[3]>0.0f continue. so exit when alpha is full */
ShadeInput shi;
ShadeResult shr;
float initial_dist = is->dist;
const float initial_dist = is->dist;
if(RE_rayobject_raycast(R.raytree, is)) {
float d= 1.0f;
/* we got a face */
/* Warning, This is not that nice, and possibly a bit slow for every ray,
however some variables were not initialized properly in, unless using shade_input_initialize(...), we need to do a memset */
memset(&shi, 0, sizeof(ShadeInput));
/* Warning regarding initializing to zero's, This is not that nice,
* and possibly a bit slow for every ray, however some variables were
* not initialized properly in, unless using
* shade_input_initialize(...), we need to zero them. */
ShadeInput shi= {NULL};
/* end warning! - Campbell */
ShadeResult shr;
/* we got a face */
shi.depth= origshi->depth + 1; /* only used to indicate tracing */
shi.mask= origshi->mask;
shi.thread= origshi->thread;
@ -1647,9 +1648,9 @@ static void ray_trace_shadow_tra(Isect *is, ShadeInput *origshi, int depth, int
shade_ray(is, &shi, &shr);
if (shi.mat->material_type == MA_TYPE_SURFACE) {
if (traflag & RAY_TRA)
d= shade_by_transmission(is, &shi, &shr);
const float d= (traflag & RAY_TRA) ?
shade_by_transmission(is, &shi, &shr) :
1.0f;
/* mix colors based on shadfac (rgb + amount of light factor) */
addAlphaLight(col, shr.diff, shr.alpha, d*shi.mat->filter);
} else if (shi.mat->material_type == MA_TYPE_VOLUME) {
@ -1665,7 +1666,7 @@ static void ray_trace_shadow_tra(Isect *is, ShadeInput *origshi, int depth, int
if(depth>0 && col[3]>0.0f) {
/* adapt isect struct */
VECCOPY(is->start, shi.co);
copy_v3_v3(is->start, shi.co);
is->dist = initial_dist-is->dist;
is->orig.ob = shi.obi;
is->orig.face = shi.vlr;
@ -1702,7 +1703,7 @@ static int UNUSED_FUNCTION(ray_trace_shadow_rad)(ShadeInput *ship, ShadeResult *
isec.orig.face = ship->vlr;
isec.hint = 0;
VECCOPY(isec.start, ship->co);
copy_v3_v3(isec.start, ship->co);
RE_RC_INIT(isec, shi);
@ -1710,14 +1711,14 @@ static int UNUSED_FUNCTION(ray_trace_shadow_rad)(ShadeInput *ship, ShadeResult *
counter+=3;
counter %= 768;
VECCOPY(vec, hashvectf+counter);
copy_v3_v3(vec, hashvectf+counter);
if(ship->vn[0]*vec[0]+ship->vn[1]*vec[1]+ship->vn[2]*vec[2]>0.0f) {
vec[0]-= vec[0];
vec[1]-= vec[1];
vec[2]-= vec[2];
}
VECCOPY(isec.dir, vec );
copy_v3_v3(isec.dir, vec );
isec.dist = RE_RAYTRACE_MAXDIST;
if(RE_rayobject_raycast(R.raytree, &isec)) {
@ -1751,7 +1752,7 @@ static int UNUSED_FUNCTION(ray_trace_shadow_rad)(ShadeInput *ship, ShadeResult *
}
/* aolight: function to create random unit sphere vectors for total random sampling */
static void RandomSpherical(float *v)
static void RandomSpherical(float v[3])
{
float r;
v[2] = 2.f*BLI_frand()-1.f;
@ -1765,7 +1766,7 @@ static void RandomSpherical(float *v)
}
/* calc distributed spherical energy */
static void DS_energy(float *sphere, int tot, float *vec)
static void DS_energy(float *sphere, int tot, float vec[3])
{
float *fp, fac, force[3], res[3];
int a;
@ -1863,13 +1864,15 @@ static float *sphere_sampler(int type, int resol, int thread, int xs, int ys, in
}
else {
float *sphere;
float cosfi, sinfi, cost, sint;
float ang, *vec1;
int a;
float *vec1;
// returns table if xs and ys were equal to last call, and not resetting
sphere= (reset)? NULL: threadsafe_table_sphere(1, thread, xs, ys, tot);
if(sphere==NULL) {
float cosfi, sinfi, cost, sint;
float ang;
int a;
sphere= threadsafe_table_sphere(0, thread, xs, ys, tot);
// random rotation
@ -1890,7 +1893,7 @@ static float *sphere_sampler(int type, int resol, int thread, int xs, int ys, in
}
}
static void ray_ao_qmc(ShadeInput *shi, float *ao, float *env)
static void ray_ao_qmc(ShadeInput *shi, float ao[3], float env[3])
{
Isect isec;
RayHint point_hint;
@ -1924,7 +1927,7 @@ static void ray_ao_qmc(ShadeInput *shi, float *ao, float *env)
isec.mode= (R.wrld.aomode & WO_AODIST)?RE_RAY_SHADOW_TRA:RE_RAY_SHADOW;
isec.lay= -1;
VECCOPY(isec.start, shi->co);
copy_v3_v3(isec.start, shi->co);
RE_rayobject_hint_bb( R.raytree, &point_hint, isec.start, isec.start );
isec.hint = &point_hint;
@ -1943,10 +1946,10 @@ static void ray_ao_qmc(ShadeInput *shi, float *ao, float *env)
}
if(shi->vlr->flag & R_SMOOTH) {
VECCOPY(nrm, shi->vn);
copy_v3_v3(nrm, shi->vn);
}
else {
VECCOPY(nrm, shi->facenor);
copy_v3_v3(nrm, shi->facenor);
}
ortho_basis_v3v3_v3( up, side,nrm);
@ -1990,7 +1993,7 @@ static void ray_ao_qmc(ShadeInput *shi, float *ao, float *env)
}
else if(envcolor!=WO_AOPLAIN) {
float skycol[4];
float skyfac, view[3];
float view[3];
view[0]= -dir[0];
view[1]= -dir[1];
@ -1998,7 +2001,7 @@ static void ray_ao_qmc(ShadeInput *shi, float *ao, float *env)
normalize_v3(view);
if(envcolor==WO_AOSKYCOL) {
skyfac= 0.5f*(1.0f+view[0]*R.grvec[0]+ view[1]*R.grvec[1]+ view[2]*R.grvec[2]);
const float skyfac= 0.5f*(1.0f+view[0]*R.grvec[0]+ view[1]*R.grvec[1]+ view[2]*R.grvec[2]);
env[0]+= (1.0f-skyfac)*R.wrld.horr + skyfac*R.wrld.zenr;
env[1]+= (1.0f-skyfac)*R.wrld.horg + skyfac*R.wrld.zeng;
env[2]+= (1.0f-skyfac)*R.wrld.horb + skyfac*R.wrld.zenb;
@ -2039,7 +2042,7 @@ static void ray_ao_qmc(ShadeInput *shi, float *ao, float *env)
}
/* extern call from shade_lamp_loop, ambient occlusion calculus */
static void ray_ao_spheresamp(ShadeInput *shi, float *ao, float *env)
static void ray_ao_spheresamp(ShadeInput *shi, float ao[3], float env[3])
{
Isect isec;
RayHint point_hint;
@ -2063,7 +2066,7 @@ static void ray_ao_spheresamp(ShadeInput *shi, float *ao, float *env)
isec.mode= (R.wrld.aomode & WO_AODIST)?RE_RAY_SHADOW_TRA:RE_RAY_SHADOW;
isec.lay= -1;
VECCOPY(isec.start, shi->co);
copy_v3_v3(isec.start, shi->co);
RE_rayobject_hint_bb( R.raytree, &point_hint, isec.start, isec.start );
isec.hint = &point_hint;
@ -2128,7 +2131,7 @@ static void ray_ao_spheresamp(ShadeInput *shi, float *ao, float *env)
}
else if(envcolor!=WO_AOPLAIN) {
float skycol[4];
float fac, view[3];
float view[3];
view[0]= -vec[0];
view[1]= -vec[1];
@ -2136,7 +2139,7 @@ static void ray_ao_spheresamp(ShadeInput *shi, float *ao, float *env)
normalize_v3(view);
if(envcolor==WO_AOSKYCOL) {
fac= 0.5f*(1.0f+view[0]*R.grvec[0]+ view[1]*R.grvec[1]+ view[2]*R.grvec[2]);
const float fac= 0.5f*(1.0f+view[0]*R.grvec[0]+ view[1]*R.grvec[1]+ view[2]*R.grvec[2]);
env[0]+= (1.0f-fac)*R.wrld.horr + fac*R.wrld.zenr;
env[1]+= (1.0f-fac)*R.wrld.horg + fac*R.wrld.zeng;
env[2]+= (1.0f-fac)*R.wrld.horb + fac*R.wrld.zenb;
@ -2167,7 +2170,7 @@ static void ray_ao_spheresamp(ShadeInput *shi, float *ao, float *env)
copy_v3_v3(env, ao);
}
void ray_ao(ShadeInput *shi, float *ao, float *env)
void ray_ao(ShadeInput *shi, float ao[3], float env[3])
{
/* Unfortunately, the unusual way that the sphere sampler calculates roughly twice as many
* samples as are actually traced, and skips them based on bias and OSA settings makes it very difficult
@ -2214,12 +2217,12 @@ static void ray_shadow_jittered_coords(ShadeInput *shi, int max, float jitco[RE_
*totjitco= tot;
}
else {
VECCOPY(jitco[0], shi->co);
copy_v3_v3(jitco[0], shi->co);
*totjitco= 1;
}
}
static void ray_shadow_qmc(ShadeInput *shi, LampRen *lar, float *lampco, float *shadfac, Isect *isec)
static void ray_shadow_qmc(ShadeInput *shi, LampRen *lar, const float lampco[3], float shadfac[4], Isect *isec)
{
QMCSampler *qsa=NULL;
int samples=0;
@ -2276,7 +2279,7 @@ static void ray_shadow_qmc(ShadeInput *shi, LampRen *lar, float *lampco, float *
isec->hint = &bb_hint;
isec->check = RE_CHECK_VLR_RENDER;
isec->skip = RE_SKIP_VLR_NEIGHBOUR;
VECCOPY(vec, lampco);
copy_v3_v3(vec, lampco);
while (samples < max_samples) {
@ -2294,9 +2297,7 @@ static void ray_shadow_qmc(ShadeInput *shi, LampRen *lar, float *lampco, float *
float ru[3], rv[3], v[3], s[3];
/* calc tangent plane vectors */
v[0] = co[0] - lampco[0];
v[1] = co[1] - lampco[1];
v[2] = co[2] - lampco[2];
sub_v3_v3v3(v, co, lampco);
normalize_v3(v);
ortho_basis_v3v3_v3( ru, rv,v);
@ -2308,7 +2309,7 @@ static void ray_shadow_qmc(ShadeInput *shi, LampRen *lar, float *lampco, float *
s[1] = samp3d[0]*ru[1] + samp3d[1]*rv[1];
s[2] = samp3d[0]*ru[2] + samp3d[1]*rv[2];
VECCOPY(samp3d, s);
copy_v3_v3(samp3d, s);
}
else {
/* sampling, returns quasi-random vector in [sizex,sizey]^2 plane */
@ -2321,7 +2322,7 @@ static void ray_shadow_qmc(ShadeInput *shi, LampRen *lar, float *lampco, float *
end[1] = vec[1]+samp3d[1];
end[2] = vec[2]+samp3d[2];
} else {
VECCOPY(end, vec);
copy_v3_v3(end, vec);
}
if(shi->strand) {
@ -2329,7 +2330,7 @@ static void ray_shadow_qmc(ShadeInput *shi, LampRen *lar, float *lampco, float *
float jitbias= 0.5f*(len_v3(shi->dxco) + len_v3(shi->dyco));
float v[3];
VECSUB(v, co, end);
sub_v3_v3v3(v, co, end);
normalize_v3(v);
co[0] -= jitbias*v[0];
@ -2337,7 +2338,7 @@ static void ray_shadow_qmc(ShadeInput *shi, LampRen *lar, float *lampco, float *
co[2] -= jitbias*v[2];
}
VECCOPY(isec->start, co);
copy_v3_v3(isec->start, co);
isec->dir[0] = end[0]-isec->start[0];
isec->dir[1] = end[1]-isec->start[1];
isec->dir[2] = end[2]-isec->start[2];
@ -2393,7 +2394,7 @@ static void ray_shadow_qmc(ShadeInput *shi, LampRen *lar, float *lampco, float *
release_thread_qmcsampler(&R, shi->thread, qsa);
}
static void ray_shadow_jitter(ShadeInput *shi, LampRen *lar, float *lampco, float *shadfac, Isect *isec)
static void ray_shadow_jitter(ShadeInput *shi, LampRen *lar, const float lampco[3], float shadfac[4], Isect *isec)
{
/* area soft shadow */
float *jitlamp;
@ -2416,7 +2417,7 @@ static void ray_shadow_jitter(ShadeInput *shi, LampRen *lar, float *lampco, floa
if(a==4) mask |= (mask>>4)|(mask>>8);
else if(a==9) mask |= (mask>>9);
VECCOPY(isec->start, shi->co);
copy_v3_v3(isec->start, shi->co);
isec->orig.ob = shi->obi;
isec->orig.face = shi->vlr;
RE_rayobject_hint_bb( R.raytree, &point_hint, isec->start, isec->start );
@ -2477,7 +2478,7 @@ static void ray_shadow_jitter(ShadeInput *shi, LampRen *lar, float *lampco, floa
}
}
/* extern call from shade_lamp_loop */
void ray_shadow(ShadeInput *shi, LampRen *lar, float *shadfac)
void ray_shadow(ShadeInput *shi, LampRen *lar, float shadfac[4])
{
Isect isec;
float lampco[3];
@ -2520,7 +2521,7 @@ void ray_shadow(ShadeInput *shi, LampRen *lar, float *shadfac)
lampco[2]= shi->co[2] - R.maxdist*lar->vec[2];
}
else {
VECCOPY(lampco, lar->co);
copy_v3_v3(lampco, lar->co);
}
if (ELEM(lar->ray_samp_method, LA_SAMP_HALTON, LA_SAMP_HAMMERSLEY)) {
@ -2536,8 +2537,8 @@ void ray_shadow(ShadeInput *shi, LampRen *lar, float *shadfac)
shadfac[3]= 1.0f; // 1.0=full light
/* set up isec.dir */
VECCOPY(isec.start, shi->co);
VECSUB(isec.dir, lampco, isec.start);
copy_v3_v3(isec.start, shi->co);
sub_v3_v3v3(isec.dir, lampco, isec.start);
isec.dist = normalize_v3(isec.dir);
if(isec.mode==RE_RAY_SHADOW_TRA) {
@ -2545,7 +2546,7 @@ void ray_shadow(ShadeInput *shi, LampRen *lar, float *shadfac)
float col[4] = {1.0f, 1.0f, 1.0f, 1.0f};
ray_trace_shadow_tra(&isec, shi, DEPTH_SHADOW_TRA, 0, col);
QUATCOPY(shadfac, col);
copy_v4_v4(shadfac, col);
}
else if(RE_rayobject_raycast(R.raytree, &isec))
shadfac[3]= 0.0f;
@ -2584,15 +2585,15 @@ static void ray_translucent(ShadeInput *shi, LampRen *lar, float *distfac, float
lampco[2]= shi->co[2] - RE_RAYTRACE_MAXDIST*lar->vec[2];
}
else {
VECCOPY(lampco, lar->co);
copy_v3_v3(lampco, lar->co);
}
isec.orig.ob = shi->obi;
isec.orig.face = shi->vlr;
/* set up isec.dir */
VECCOPY(isec.start, shi->co);
VECCOPY(isec.end, lampco);
copy_v3_v3(isec.start, shi->co);
copy_v3_v3(isec.end, lampco);
if(RE_rayobject_raycast(R.raytree, &isec)) {
/* we got a face */

2
source/blender/render/intern/source/rendercore.c
View File

@ -142,7 +142,7 @@ void calc_renderco_ortho(float co[3], float x, float y, int z)
co[2]= R.winmat[3][2]/( R.winmat[2][3]*zco - R.winmat[2][2] );
}
void calc_renderco_zbuf(float co[3], float *view, int z)
void calc_renderco_zbuf(float co[3], const float view[3], int z)
{
float fac, zco;

6
source/blender/render/intern/source/shadeinput.c
View File

@ -1355,16 +1355,14 @@ void shade_sample_initialize(ShadeSample *ssamp, RenderPart *pa, RenderLayer *rl
/* Do AO or (future) GI */
void shade_samples_do_AO(ShadeSample *ssamp)
{
ShadeInput *shi;
int sample;
if(!(R.r.mode & R_SHADOW))
return;
if(!(R.r.mode & R_RAYTRACE) && !(R.wrld.ao_gather_method == WO_AOGATHER_APPROX))
return;
if(R.wrld.mode & (WO_AMB_OCC|WO_ENV_LIGHT|WO_INDIRECT_LIGHT)) {
shi= &ssamp->shi[0];
ShadeInput *shi= &ssamp->shi[0];
int sample;
if(((shi->passflag & SCE_PASS_COMBINED) && (shi->combinedflag & (SCE_PASS_AO|SCE_PASS_ENVIRONMENT|SCE_PASS_INDIRECT)))
|| (shi->passflag & (SCE_PASS_AO|SCE_PASS_ENVIRONMENT|SCE_PASS_INDIRECT)))

50
source/blender/render/intern/source/shadeoutput.c
View File

@ -119,7 +119,7 @@ static void fogcolor(float *colf, float *rco, float *view)
#endif
/* zcor is distance, co the 3d coordinate in eye space, return alpha */
float mistfactor(float zcor, float *co)
float mistfactor(float zcor, float const co[3])
{
float fac, hi;
@ -162,8 +162,7 @@ static void spothalo(struct LampRen *lar, ShadeInput *shi, float *intens)
double t0, t1 = 0.0f, t2= 0.0f, t3;
float p1[3], p2[3], ladist, maxz = 0.0f, maxy = 0.0f, haint;
int snijp, doclip=1, use_yco=0;
int ok1=0, ok2=0;
*intens= 0.0f;
haint= lar->haint;
@ -243,6 +242,8 @@ static void spothalo(struct LampRen *lar, ShadeInput *shi, float *intens)
}
}
if(snijp==2) {
int ok1=0, ok2=0;
/* sort */
if(t1>t2) {
a= t1; t1= t2; t2= a;
@ -345,7 +346,7 @@ static void spothalo(struct LampRen *lar, ShadeInput *shi, float *intens)
}
}
void renderspothalo(ShadeInput *shi, float *col, float alpha)
void renderspothalo(ShadeInput *shi, float col[4], float alpha)
{
ListBase *lights;
GroupObject *go;
@ -891,12 +892,11 @@ void shade_color(ShadeInput *shi, ShadeResult *shr)
static void ramp_diffuse_result(float *diff, ShadeInput *shi)
{
Material *ma= shi->mat;
float col[4], fac=0;
float col[4];
if(ma->ramp_col) {
if(ma->rampin_col==MA_RAMP_IN_RESULT) {
fac= 0.3f*diff[0] + 0.58f*diff[1] + 0.12f*diff[2];
float fac= 0.3f*diff[0] + 0.58f*diff[1] + 0.12f*diff[2];
do_colorband(ma->ramp_col, fac, col);
/* blending method */
@ -911,8 +911,7 @@ static void ramp_diffuse_result(float *diff, ShadeInput *shi)
static void add_to_diffuse(float *diff, ShadeInput *shi, float is, float r, float g, float b)
{
Material *ma= shi->mat;
float col[4], colt[3], fac=0;
if(ma->ramp_col && (ma->mode & MA_RAMP_COL)) {
/* MA_RAMP_IN_RESULT is exceptional */
@ -923,6 +922,9 @@ static void add_to_diffuse(float *diff, ShadeInput *shi, float is, float r, floa
diff[2] += b * shi->b;
}
else {
float colt[3], col[4];
float fac;
/* input */
switch(ma->rampin_col) {
case MA_RAMP_IN_ENERGY:
@ -934,6 +936,9 @@ static void add_to_diffuse(float *diff, ShadeInput *shi, float is, float r, floa
case MA_RAMP_IN_NOR:
fac= shi->view[0]*shi->vn[0] + shi->view[1]*shi->vn[1] + shi->view[2]*shi->vn[2];
break;
default:
fac= 0.0f;
break;
}
do_colorband(ma->ramp_col, fac, col);
@ -962,11 +967,11 @@ static void add_to_diffuse(float *diff, ShadeInput *shi, float is, float r, floa
static void ramp_spec_result(float *specr, float *specg, float *specb, ShadeInput *shi)
{
Material *ma= shi->mat;
float col[4];
float fac;
if(ma->ramp_spec && (ma->rampin_spec==MA_RAMP_IN_RESULT)) {
fac= 0.3f*(*specr) + 0.58f*(*specg) + 0.12f*(*specb);
float col[4];
float fac= 0.3f*(*specr) + 0.58f*(*specg) + 0.12f*(*specb);
do_colorband(ma->ramp_spec, fac, col);
/* blending method */
@ -978,19 +983,19 @@ static void ramp_spec_result(float *specr, float *specg, float *specb, ShadeInpu
}
/* is = dot product shade, t = spec energy */
static void do_specular_ramp(ShadeInput *shi, float is, float t, float *spec)
static void do_specular_ramp(ShadeInput *shi, float is, float t, float spec[3])
{
Material *ma= shi->mat;
float col[4];
float fac=0.0f;
spec[0]= shi->specr;
spec[1]= shi->specg;
spec[2]= shi->specb;
/* MA_RAMP_IN_RESULT is exception */
if(ma->ramp_spec && (ma->rampin_spec!=MA_RAMP_IN_RESULT)) {
float fac;
float col[4];
/* input */
switch(ma->rampin_spec) {
case MA_RAMP_IN_ENERGY:
@ -1002,6 +1007,9 @@ static void do_specular_ramp(ShadeInput *shi, float is, float t, float *spec)
case MA_RAMP_IN_NOR:
fac= shi->view[0]*shi->vn[0] + shi->view[1]*shi->vn[1] + shi->view[2]*shi->vn[2];
break;
default:
fac= 0.0f;
break;
}
do_colorband(ma->ramp_spec, fac, col);
@ -1086,7 +1094,7 @@ static void indirect_lighting_apply(ShadeInput *shi, ShadeResult *shr)
}
/* result written in shadfac */
void lamp_get_shadow(LampRen *lar, ShadeInput *shi, float inp, float *shadfac, int do_real)
void lamp_get_shadow(LampRen *lar, ShadeInput *shi, float inp, float shadfac[4], int do_real)
{
LampShadowSubSample *lss= &(lar->shadsamp[shi->thread].s[shi->sample]);
@ -1115,7 +1123,7 @@ void lamp_get_shadow(LampRen *lar, ShadeInput *shi, float inp, float *shadfac, i
}
/* lampdistance and spot angle, writes in lv and dist */
float lamp_get_visibility(LampRen *lar, float *co, float *lv, float *dist)
float lamp_get_visibility(LampRen *lar, const float co[3], float lv[3], float *dist)
{
if(lar->type==LA_SUN || lar->type==LA_HEMI) {
*dist= 1.0f;
@ -1621,7 +1629,7 @@ static void shade_lamp_loop_only_shadow(ShadeInput *shi, ShadeResult *shr)
}
/* let's map negative light as if it mirrors positive light, otherwise negative values disappear */
static void wrld_exposure_correct(float *diff)
static void wrld_exposure_correct(float diff[3])
{
diff[0]= R.wrld.linfac*(1.0f-exp( diff[0]*R.wrld.logfac) );

4
source/blender/render/intern/source/strand.c
View File

@ -92,7 +92,7 @@ void strand_eval_point(StrandSegment *sseg, StrandPoint *spoint)
Material *ma;
StrandBuffer *strandbuf;
float *simplify;
float p[4][3], data[4], cross[3], crosslen, w, dx, dy, t;
float p[4][3], data[4], cross[3], w, dx, dy, t;
int type;
strandbuf= sseg->buffer;
@ -164,7 +164,7 @@ void strand_eval_point(StrandSegment *sseg, StrandPoint *spoint)
if(w > 0.0f) {
if(strandbuf->flag & R_STRAND_B_UNITS) {
crosslen= len_v3(cross);
const float crosslen= len_v3(cross);
w= 2.0f*crosslen*strandbuf->minwidth/w;
if(spoint->width < w) {

9
source/blender/render/intern/source/zbuf.c
View File

@ -1747,13 +1747,14 @@ static void zbuf_project_cache_clear(ZbufProjectCache *cache, int size)
static int zbuf_shadow_project(ZbufProjectCache *cache, int index, float winmat[][4], float *co, float *ho)
{
int clipflag, cindex= index & 255;
int cindex= index & 255;
if(cache[cindex].index == index) {
QUATCOPY(ho, cache[cindex].ho);
return cache[cindex].clip;
}
else {
int clipflag;
projectvert(co, winmat, ho);
clipflag= testclip(ho);
@ -1775,14 +1776,16 @@ static void zbuffer_part_bounds(int winx, int winy, RenderPart *pa, float *bound
static int zbuf_part_project(ZbufProjectCache *cache, int index, float winmat[][4], float *bounds, float *co, float *ho)
{
float vec[3], wco;
int clipflag= 0, cindex= index & 255;
float vec[3];
int cindex= index & 255;
if(cache[cindex].index == index) {
QUATCOPY(ho, cache[cindex].ho);
return cache[cindex].clip;
}
else {
float wco;
int clipflag= 0;
VECCOPY(vec, co)
projectvert(co, winmat, ho);