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); }