static void build_rot_matrix(
miVector *old_dir,
miVector *new_dir,
miMatrix rot_transform)
{
miVector rot_axis;
mi_vector_prod(&rot_axis, old_dir, new_dir);
mi_vector_normalize(&rot_axis);
float cos_theta = mi_vector_dot(old_dir, new_dir);
float theta = (float) acos(cos_theta);
mi_matrix_rotate_axis(rot_transform, &rot_axis, theta);
}
miBoolean Facade_tex_coord(miState *state, miScalar size,
miBoolean cylindrical,
miVector *tex_point)
{
miVector facing, facade_center, observer_center;
miVector intersection;
miVector fx, fy, fz;
/* first - determine the center of the facade,
the center of the observer,
and the direction of the facade */
{
mi_point_from_object(state, &facade_center, &zero);
observer_center = state->org;
mi_vector_sub(&facing, &observer_center, &facade_center);
if (cylindrical)
{
miVector fix;
mi_vector_to_object(state, &fix, &facing);
fix.y = 0;
mi_vector_from_object(state, &facing, &fix);
}
mi_vector_normalize(&facing);
}
/* second - compute the intersection of the ray and the facade */
{
miScalar l;
l = lume_plane_ray_intersection(&intersection,
&facade_center, &facing,
&state->point, &state->dir);
if (l <= 0) /* no intersection */
return miFALSE;
}
/* third - build a coordinate system for the texture */
{
miVector object_up;
fz = facing;
mi_vector_from_object(state, &object_up, &up);
mi_vector_prod(&fx, &object_up, &fz);
mi_vector_normalize(&fx);
mi_vector_prod(&fy, &fz, &fx);
mi_vector_normalize(&fy);
}
/* forth - convert the intersection to the texture coordinate system */
{
mi_vector_sub(&intersection, &intersection, &facade_center);
tex_point->x = mi_vector_dot(&intersection, &fx);
tex_point->y = mi_vector_dot(&intersection, &fy);
tex_point->z = mi_vector_dot(&intersection, &fz);
mi_vector_div(tex_point, size);
tex_point->x += 0.5;
tex_point->y += 0.5;
}
return miTRUE;
}
extern "C" DLLEXPORT miBoolean physical_light(
miColor *result,
miState *state,
struct physical_light *parms)
{
struct physical_light p, *paras = &p; /* mi_eval'ed parameters */
miTag light = 0;
miColor visibility = {1.0, 1.0, 1.0};
miVector normal, u, v, axis, spotdir, dir;
miScalar cosine, r=state->dist, r2, f, d, area, radius;
miScalar exponent, spread;
miScalar maxcolor;
int type, areatype;
p.color = *mi_eval_color (&parms->color);
p.cone = *mi_eval_scalar(&parms->cone);
p.threshold = *mi_eval_scalar(&parms->threshold);
p.cos_exp = *mi_eval_scalar(&parms->cos_exp);
miASSERT(paras->color.r >= 0.0 && paras->color.g >= 0.0 &&
paras->color.b >= 0.0); /* no 'light suckers', please */
mi_query(miQ_INST_ITEM, state, state->light_instance, &light);
mi_query(miQ_LIGHT_TYPE, state, light, &type);
mi_query(miQ_LIGHT_AREA, state, light, &areatype);
if (state->type == miRAY_LIGHT) {
/*
* compute irradiance from this light source at the surface of
* object
*/
mi_query(miQ_LIGHT_EXPONENT, state, light, &exponent);
r2 = exponent == 0 || exponent == 2 ? r*r : pow(r, exponent);
switch(areatype) {
case miLIGHT_NONE: /* point, spot or directional*/
/*
* distance attenuation: 4 Pi r^2 is the area of a
* sphere around the point. Same normalization as for
* spherical light
*/
f = type==miLIGHT_DIRECTION ? 1 : 1 / (4 * M_PI * r2);
break;
case miLIGHT_RECTANGLE: /* rectangular area light */
mi_query(miQ_LIGHT_AREA_R_EDGE_U, state, light, &u);
mi_query(miQ_LIGHT_AREA_R_EDGE_V, state, light, &v);
mi_vector_prod(&normal, &u, &v);
mi_vector_normalize(&normal);
mi_vector_to_light(state, &dir, &state->dir);
mi_vector_normalize(&dir);
/*
* Compute area-to-point form factor (except cos at
* the receiver). <cosine> is cos at sender. Returning
* 2 means "no color and stop sampling".
*/
cosine = mi_vector_dot(&normal, &dir);
if (cosine <= 0)
return((miBoolean)2);
if (paras->cos_exp != 0 && paras->cos_exp != 1)
cosine = pow(cosine, paras->cos_exp);
/*
* cos term and distance attenuation. No area term
* since "color" of the light is energy, not radiance.
*/
f = cosine / (M_PI * r2);
break;
case miLIGHT_DISC: /* disc area light */
mi_query(miQ_LIGHT_AREA_D_NORMAL, state,light,&normal);
mi_vector_to_light(state, &dir, &state->dir);
mi_vector_normalize(&dir);
cosine = mi_vector_dot(&normal, &dir);
if (cosine <= 0)
return((miBoolean)2);
if (paras->cos_exp != 0 && paras->cos_exp != 1)
cosine = pow(cosine, paras->cos_exp);
f = cosine / (M_PI * r2);
break;
case miLIGHT_SPHERE: /* spherical area light */
case miLIGHT_CYLINDER: /* cylindrical area light */
f = 1 / (4 * M_PI * r2);
break;
case miLIGHT_OBJECT:
/* two sided */
/*
* this is legal for object lights only: state->child
* is set according to the intersection with the light
* geometry itself
*/
cosine = -state->child->dot_nd;
if (cosine <= 0)
return(miFALSE);
if (paras->cos_exp != 0 && paras->cos_exp != 1)
cosine = pow(cosine, paras->cos_exp);
f = cosine / (4 * M_PI * r2);
break;
default:
mi_error("physical_light: unknown light source type");
}
if (type == miLIGHT_SPOT) { /* spot light source */
mi_query(miQ_LIGHT_DIRECTION, state, light, &spotdir);
miASSERT(fabs(mi_vector_norm(&spotdir) - 1.) < miEPS);
mi_vector_to_light(state, &dir, &state->dir);
mi_vector_normalize(&dir);
d = mi_vector_dot(&dir, &spotdir);
if (d <= 0)
return(miFALSE);
mi_query(miQ_LIGHT_SPREAD, state, light, &spread);
if (d < spread)
return(miFALSE);
if (d < paras->cone)
f *= 1 - (d - paras->cone) /
(spread - paras->cone);
}
/*
* Return false without checking occlusion (shadow ray) if
* color is very dark. (This introduces bias which could be
* avoided if probabilities were used to decide whether to
* carry on or return here.)
*/
maxcolor = mi_MAX3(paras->color.r, paras->color.g,
paras->color.b);
if (f * maxcolor < paras->threshold)
return(miFALSE);
/*
* Check for occlusion by an opaque object and compute
* visibility
*/
if (!mi_trace_shadow(&visibility, state) || BLACK(visibility))
return(miFALSE);
/*
* Compute result. Visibility is always (1 1 1) here for
* dgs_material() so the multiplication by visibility could be
* avoided. But for base light shaders visibility can be less.
*/
result->r = f * paras->color.r * visibility.r;
result->g = f * paras->color.g * visibility.g;
result->b = f * paras->color.b * visibility.b;
} else { /* Visible area light source: return radiance*/
switch (areatype) {
case miLIGHT_RECTANGLE: /* rectangular area light */
mi_query(miQ_LIGHT_AREA_R_EDGE_U, state, light, &u);
mi_query(miQ_LIGHT_AREA_R_EDGE_V, state, light, &v);
mi_vector_prod(&normal, &u, &v);
/* Compute radiance: result = paras->color / area */
mi_normal_to_light(state, &dir, &state->normal);
if (mi_vector_dot(&normal, &dir) > 0) {
area = 4.0 * mi_vector_norm(&normal);
miASSERT(area > 0.0);
result->r = paras->color.r / area;
result->g = paras->color.g / area;
result->b = paras->color.b / area;
} else
*result = black; /* back side is black */
break;
case miLIGHT_DISC: /* disc area light source */
mi_query(miQ_LIGHT_AREA_D_NORMAL, state,light,&normal);
mi_normal_to_light(state, &dir, &state->normal);
if (mi_vector_dot(&normal, &dir) > 0) {
mi_query(miQ_LIGHT_AREA_D_RADIUS, state,
light, &radius);
area = M_PI * radius * radius;
miASSERT(area > 0.0);
result->r = paras->color.r / area;
result->g = paras->color.g / area;
result->b = paras->color.b / area;
} else
*result = black;
break;
case miLIGHT_SPHERE: /* spherical area light */
mi_query(miQ_LIGHT_AREA_S_RADIUS, state,light,&radius);
area = 4.0 * M_PI * radius * radius;
miASSERT(area > 0.0);
result->r = paras->color.r / area;
result->g = paras->color.g / area;
result->b = paras->color.b / area;
break;
case miLIGHT_CYLINDER: /* cylindrical area light */
mi_query(miQ_LIGHT_AREA_C_RADIUS, state,light,&radius);
mi_query(miQ_LIGHT_AREA_C_AXIS, state, light, &axis);
/* area = pi*radius^2 * h = pi*radius^2 * 2 * |axis| */
area = 2 * M_PI * radius * radius *
mi_vector_norm(&axis);
miASSERT(area > 0.0);
result->r = paras->color.r / area;
result->g = paras->color.g / area;
result->b = paras->color.b / area;
break;
case miLIGHT_OBJECT:
mi_query(miQ_INST_AREA, state,
state->light_instance, &area);
result->r = paras->color.r / area;
result->g = paras->color.g / area;
result->b = paras->color.b / area;
break;
case miLIGHT_NONE: /* point, spot or directional*/
miASSERT(0);
break;
default:
mi_error("physical_light: unknown light source type");
}
}
miASSERT(result->r >= 0 && result->g >= 0 && result->b >= 0);
return(miTRUE);
}
