miBoolean contour_shader_widthfromcolor(
miContour_endpoint *result,
miStdInfo *info_near,
miStdInfo *info_far,
miState *state,
Widthfromcolor_Parameters *paras)
{
double maxcolor;
miScalar min_width;
/* Contour color given by a parameter */
result->color = *mi_eval_color(¶s->color);
/* The contour gets wider when the material color is dark */
maxcolor = mi_MAX(info_near->color.r, info_near->color.g);
maxcolor = mi_MAX(info_near->color.b, maxcolor);
/* Softimage likes to have rgb colors larger than 1.0 */
if (maxcolor > 1.0)
maxcolor = 1.0;
miASSERT(0.0 <= maxcolor && maxcolor <= 1.0);
min_width = *mi_eval_scalar(¶s->min_width);
result->width = (*mi_eval_scalar(¶s->max_width) - min_width) *
(1.0 - maxcolor) + min_width;
return(miTRUE);
}
miBoolean contour_shader_widthfromlightdir(
miContour_endpoint *result,
miStdInfo *info_near,
miStdInfo *info_far,
miState *state,
Lightdir_Parameters *paras)
{
double d;
miVector dir;
miScalar max_width;
miScalar min_width;
/* Contour color given by a parameter */
result->color = *mi_eval_color(¶s->color);
/* Normalize light direction (just in case user didn't) */
dir = *mi_eval_vector(¶s->light_dir);
mi_vector_normalize(&dir);
/* The contour gets wider the more the normal differs from the light
source direction */
d = mi_vector_dot(&dir, &info_near->normal);
min_width = *mi_eval_scalar(¶s->min_width);
max_width = *mi_eval_scalar(¶s->max_width);
result->width = min_width + 0.5 * (max_width - min_width) * (1.0 - d);
miASSERT(min_width <= result->width && result->width <= max_width);
return(miTRUE);
}
miBoolean contour_shader_curvature(
miContour_endpoint *result,
miStdInfo *info_near,
miStdInfo *info_far,
miState *state,
Widthfromcolor_Parameters *paras)
{
double d;
miScalar min_width;
miScalar max_width;
miASSERT(info_near || info_far);
/* Constant contour color */
result->color = *mi_eval_color(¶s->color);
max_width = *mi_eval_scalar(¶s->max_width);
min_width = *mi_eval_scalar(¶s->min_width);
if ((info_near == NULL) != (info_far == NULL)) {
/* Max contour width if one point hit background */
result->width = max_width;
} else if (fabs(info_near->point.z - info_far->point.z) > 1.0) {
/* Max contour width if large difference in depth */
result->width = max_width;
} else {
/* Otherwise, the contour width depends on the curvature */
d = mi_vector_dot(&info_near->normal, &info_far->normal);
miASSERT(-1.0 <= d && d <= 1.0);
result->width = min_width +
0.5 * (1.0 - d) * (max_width-min_width);
}
miASSERT(min_width <= result->width && result->width <= max_width);
return(miTRUE);
}
DLLEXPORT void domeAFL_FOV_Stereo_init(
miState *state,
struct dsDomeAFL_FOV_Stereo *params,
miBoolean *inst_init_req)
{
if (!params) {
// version output
mi_info(_VER_);
*inst_init_req = miTRUE;
} else {
fov_angle = *mi_eval_scalar(¶ms->FOV_Angle);
viewport_offset = *mi_eval_vector(¶ms->View_Offset);
camera = *mi_eval_integer(¶ms->Camera);
dome_radius = *mi_eval_scalar(¶ms->Dome_Radius);
dome_tilt = *mi_eval_scalar(¶ms->Dome_Tilt);
cameras_separation = *mi_eval_scalar(¶ms->Cameras_Separation);
dome_tilt_compensation = *mi_eval_boolean(¶ms->Dome_Tilt_Compensation);
vertical_mode = *mi_eval_boolean(¶ms->Vertical_Mode);
//mi_info("II-> fov=%f,cam=%i,rad=%f,tilt=%f,sep=%f,comp=%i,vert=%i",fov_angle,camera,dome_radius,dome_tilt,cameras_separation,dome_tilt_compensation,vertical_mode);
// Convert input angles from degrees to radians...
fov_angle = (miScalar)(fov_angle*M_PI/180.0);
dome_tilt = (miScalar)(dome_tilt*M_PI/180.0);
}
}
miBoolean contour_shader_factorcolor(
miContour_endpoint *result,
miStdInfo *info_near,
miStdInfo *info_far,
miState *state,
Factorcolor_Parameters *paras)
{
miScalar f = *mi_eval_scalar(¶s->factor);
miScalar w = *mi_eval_scalar(¶s->width);
miASSERT(info_near->color.r >= 0.0 && info_near->color.g >= 0.0);
miASSERT(info_near->color.b >= 0.0);
miASSERT(f >= 0.0 && w >= 0.0);
/*
* Set contour color to a factor times material color. The opacity
* color->a is set to 1.0, otherwise the material will shine through
* the contour.
*/
result->color.r = f * info_near->color.r;
result->color.g = f * info_near->color.g;
result->color.b = f * info_near->color.b;
result->color.a = 1.0;
/* The contour width is a parameter */
result->width = w;
return(miTRUE);
}
bool checkScreenSpace(miState *state, mrParticleGeoShader_paras *paras, miVector pos, miVector& bottomLeft, miVector& topRight)
{
miScalar minPixelSize = *mi_eval_scalar(¶s->minPixelSize);
miScalar maxPixelSize = *mi_eval_scalar(¶s->maxPixelSize);
int minSizeBehaviour = *mi_eval_integer(¶s->minSizeBehaviour); // 0 = delete, 1 = resize
if(maxPixelSize <= 0.0f )
maxPixelSize = 100000000.0f;
miVector screenBottomLeft = bottomLeft;
miVector screenTopRight = topRight;
mi_point_from_camera(state, &screenBottomLeft, &screenBottomLeft);
mi_point_from_camera(state, &screenTopRight, &screenTopRight);
mi_point_to_raster(state, &screenBottomLeft, &screenBottomLeft);
mi_point_to_raster(state, &screenTopRight, &screenTopRight);
miScalar screenDist = mi_vector_dist(&screenBottomLeft, &screenTopRight);
miScalar dist = mi_vector_dist(&bottomLeft, &topRight);
//mi_info("screenDist %f minPixelSize %f", screenDist, minPixelSize);
// nonsense no check will be done
if(minPixelSize > maxPixelSize)
return true;
float minClip = 0.001f;
if( screenDist < minPixelSize )
{
if( minSizeBehaviour == 0)
return false;
//mi_info("screenDist %f < minPixelSize %f", screenDist, minPixelSize);
float resizeFactor = minPixelSize/screenDist;
float resizeDist = dist * resizeFactor/2.0f;
topRight = pos;
bottomLeft = pos;
topRight.x += resizeDist;
topRight.y += resizeDist;
bottomLeft.x -= resizeDist;
bottomLeft.y -= resizeDist;
return true;
}
if( screenDist > maxPixelSize )
{
float resizeFactor = maxPixelSize/screenDist;
float resizeDist = dist * resizeFactor/2.0f;
topRight = pos;
bottomLeft = pos;
topRight.x += resizeDist;
topRight.y += resizeDist;
bottomLeft.x -= resizeDist;
bottomLeft.y -= resizeDist;
return true;
}
return true;
}
extern "C" DLLEXPORT miBoolean mib_color_interpolate(
miColor *result,
miState *state,
struct mib_color_interpolate *paras)
{
miInteger num = *mi_eval_integer(¶s->num);
miScalar input;
miScalar ominput;
miScalar prev = 0;
miScalar next = 1;
int i;
if (num < 1) {
result->r = result->g = result->b = result->a = 0;
return(miTRUE);
}
if (num == 1) {
*result = *mi_eval_color(¶s->color[0]);
return(miTRUE);
}
if (num > 8)
num = 8;
input = *mi_eval_scalar(¶s->input);
if (input <= 0) {
*result = *mi_eval_color(¶s->color[0]);
return(miTRUE);
}
if (input >= 1) {
*result = *mi_eval_color(¶s->color[num-1]);
return(miTRUE);
}
for (i=0; i < num-2; i++) {
next = *mi_eval_scalar(¶s->weight[i]);
if (input <= next)
break;
prev = next;
next = 1;
}
input = (input - prev) / (next - prev);
ominput = 1 - input;
if (input == 0)
*result = *mi_eval_color(¶s->color[i]);
else if (input == 1)
*result = *mi_eval_color(¶s->color[i+1]);
else {
miColor *pcol = mi_eval_color(¶s->color[i]);
miColor *ncol = mi_eval_color(¶s->color[i+1]);
result->r = ominput * pcol->r + input * ncol->r;
result->g = ominput * pcol->g + input * ncol->g;
result->b = ominput * pcol->b + input * ncol->b;
result->a = ominput * pcol->a + input * ncol->a;
}
return(miTRUE);
}
extern "C" DLLEXPORT miBoolean mib_texture_filter_lookup(
miColor *result,
miState *state,
struct mib_texture_filter_lookup *paras)
{
miTag tex = *mi_eval_tag(¶s->tex);
miVector *coord;
miUint space;
miTag remap;
miVector p[3], t[3];
miMatrix ST;
miTexfilter ell_opt;
miScalar disc_r;
if (!tex) {
result->r = result->g = result->b = result->a = 0;
return(miFALSE);
}
coord = mi_eval_vector(¶s->coord);
space = *mi_eval_integer(¶s->space);
disc_r = *mi_eval_scalar(¶s->disc_r);
if (disc_r <= 0)
disc_r = DISC_R;
if (state->reflection_level == 0 &&
mi_texture_filter_project(p, t, state, disc_r, space) &&
(remap = *mi_eval_tag(¶s->remap))) {
mi_call_shader_x((miColor*)&t[0], miSHADER_TEXTURE,
state, remap, &t[0]);
mi_call_shader_x((miColor*)&t[1], miSHADER_TEXTURE,
state, remap, &t[1]);
mi_call_shader_x((miColor*)&t[2], miSHADER_TEXTURE,
state, remap, &t[2]);
if (mi_texture_filter_transform(ST, p, t)) {
ell_opt.eccmax = *mi_eval_scalar(¶s->eccmax);
ell_opt.max_minor = *mi_eval_scalar(¶s->maxminor);
ell_opt.bilinear = *mi_eval_boolean(¶s->bilinear);
ell_opt.circle_radius = CIRCLE_R;
/*
* when no bump-mapping is used, coord and ST[..]
* are identical. for bump mapping, the projection
* matrix is calculated for the current raster
* position, the ellipse is translated to the
* bump position
*/
ST[2*4+0] = coord->x;
ST[2*4+1] = coord->y;
if (mi_lookup_filter_color_texture(result, state,
tex, &ell_opt, ST))
return(miTRUE);
}
}
/* fallback to standard pyramid or nonfiltered texture lookup */
return(mi_lookup_color_texture(result, state, tex, coord));
}
extern "C" DLLEXPORT miBoolean mib_dielectric(
miColor *result,
miState *state,
struct md *paras)
{
miScalar refract;
miColor inp, absorb;
miVector dir;
miScalar ior;
double dist;
/* check for illegal calls */
if (state->type == miRAY_SHADOW || state->type == miRAY_DISPLACE)
return(miFALSE);
refract = *mi_eval_scalar(¶s->refract);
if (refract == 0.0)
*result = *mi_eval_color(¶s->input);
else {
ior = *mi_eval_scalar(¶s->ior);
if (ior==0.0 || ior==1.0)
mi_trace_transparent(result, state);
else {
if (mi_refraction_dir(&dir, state, 1.0, ior))
mi_trace_refraction(result, state, &dir);
else { /* total internal reflection */
mi_reflection_dir(&dir, state);
mi_trace_reflection(result, state, &dir);
}
}
dist = state->child ? state->child->dist : 0.0;
absorb = *mi_eval_color(¶s->absorb);
if(absorb.r > 0.0f)
result->r *= (miScalar) exp(log(absorb.r) * dist);
if(absorb.g > 0.0f)
result->g *= (miScalar) exp(log(absorb.g) * dist);
if(absorb.b > 0.0f)
result->b *= (miScalar) exp(log(absorb.b) * dist);
if(absorb.a > 0.0f)
result->a *= (miScalar) exp(log(absorb.a) * dist);
if (refract < 1.0f) {
inp = *mi_eval_color(¶s->input);
result->r = result->r * refract + inp.r * (1-refract);
result->g = result->g * refract + inp.g * (1-refract);
result->b = result->b * refract + inp.b * (1-refract);
result->a = result->a * refract + inp.a * (1-refract);
}
}
return(miTRUE);
}
extern "C" DLLEXPORT miBoolean mib_volume(
miColor *result, /* in: color at far end, out */
miState *state,
struct mib_volume *paras)
{
miColor *color; /* fog color */
miScalar max, fade; /* max opcity distance, fade factor */
if (!*mi_eval_boolean(¶s->lightrays) && state->type==miRAY_LIGHT)
return(miTRUE); /* ignore light rays?*/
color = mi_eval_color (¶s->color);
max = *mi_eval_scalar(¶s->max);
if (state->dist <= 0 || /* infinite distance */
state->dist >= max) { /* full-opacity dist */
fade = 1 - color->a;
result->r = fade * result->r + color->r;
result->g = fade * result->g + color->g;
result->b = fade * result->b + color->b;
result->a = fade * result->a + color->a;
return(miTRUE);
}
fade = (float)state->dist / max; /* fade to fog color */
fade = (1 - fade * fade) * color->a;
result->r = fade * result->r + (1-fade) * color->r;
result->g = fade * result->g + (1-fade) * color->g;
result->b = fade * result->b + (1-fade) * color->b;
result->a = fade * result->a + (1-fade) * color->a;
return(miTRUE);
}
miBoolean contour_shader_layerthinner(
miContour_endpoint *result,
miStdInfo *info_near,
miStdInfo *info_far,
miState *state,
Layerthinner_Parameters *paras)
{
/* Constant contour color */
result->color = *mi_eval_color(¶s->color);
/* Width decreases by factor for each refraction_level */
result->width = *mi_eval_scalar(¶s->width) *
pow( (double)(*mi_eval_scalar(¶s->factor)),
(double)info_near->level - 1.0);
return(miTRUE);
}
extern "C" DLLEXPORT miBoolean mib_photon_basic(
miColor *flux,
miState *state,
struct mib_photon_basic *paras)
{
miColor rdiff, *spec, *transp, nflux;
miScalar ior_frac;
miVector dir;
miRay_type type;
miColor tspec, rspec;
rdiff = *mi_eval_color(¶s->diffuse);
spec = mi_eval_color(¶s->specular);
transp = mi_eval_color(¶s->transp);
tspec.r = spec->r * transp->r;
tspec.g = spec->g * transp->g;
tspec.b = spec->b * transp->b;
rspec.r = spec->r * (1.0 - transp->r);
rspec.g = spec->g * (1.0 - transp->g);
rspec.b = spec->b * (1.0 - transp->b);
if (rdiff.r > 0.0 || rdiff.g > 0.0 || rdiff.b > 0.0)
mi_store_photon(flux, state);
type = mi_choose_simple_scatter_type(state, &rdiff, &rspec, 0, &tspec);
switch(type) {
case miPHOTON_REFLECT_SPECULAR:
nflux.r = flux->r * rspec.r;
nflux.g = flux->g * rspec.g;
nflux.b = flux->b * rspec.b;
mi_reflection_dir_specular(&dir, state);
return(mi_photon_reflection_specular(&nflux, state, &dir));
case miPHOTON_REFLECT_DIFFUSE:
nflux.r = flux->r * rdiff.r;
nflux.g = flux->g * rdiff.g;
nflux.b = flux->b * rdiff.b;
mi_reflection_dir_diffuse(&dir, state);
return(mi_photon_reflection_diffuse(&nflux, state, &dir));
case miPHOTON_TRANSMIT_SPECULAR:
nflux.r = flux->r * tspec.r;
nflux.g = flux->g * tspec.g;
nflux.b = flux->b * tspec.b;
ior_frac = *mi_eval_scalar(¶s->ior_frac);
if (ior_frac == 1.0)
return(mi_photon_transparent(&nflux, state));
else if (mi_transmission_dir_specular(&dir, state, 1,ior_frac))
return(mi_photon_transmission_specular(&nflux, state,
&dir));
else
return(miFALSE);
default:
return(miTRUE);
}
}
extern "C" DLLEXPORT miBoolean mib_color_spread(
register miColor *result,
miState *state,
struct mib_color_spread *paras)
{
register int i, n = *mi_eval_integer(¶s->num);
register miScalar r, g, b, a;
register miScalar weight;
miColor *input;
input = mi_eval_color(¶s->input);
r = input->r;
g = input->g;
b = input->b;
a = input->a;
if (n > 8) n = 8;
for (i=0; i < n; i++, result++) {
weight = *mi_eval_scalar(¶s->weight[i]);
switch(*mi_eval_integer(¶s->mode[i])) {
default:
case 0:
result->r = r * weight;
result->g = g * weight;
result->b = b * weight;
result->a = a * weight;
break;
case 1:
result->r =
result->g =
result->b =
result->a = a * weight;
break;
case 2:
result->r =
result->g =
result->b =
result->a = (a + r + g)/3 * weight;
break;
case 3:
result->r =
result->g =
result->b =
result->a = (.299 * r + .587 * g + .114 * b) * weight;
break;
case 4:
result->r =
result->g =
result->b =
result->a = r * weight;
break;
}
}
return(miTRUE);
}
miBoolean contour_shader_framefade(
miContour_endpoint *result,
miStdInfo *info_near,
miStdInfo *info_far,
miState *state,
Framefade_Parameters *paras)
{
int frame = state->camera->frame;
double w1, w2;
int frame1, frame2;
miASSERT(frame >= 0);
frame1 = *mi_eval_integer(¶s->frame1);
frame2 = *mi_eval_integer(¶s->frame2);
miASSERT(frame1 >= 0 && frame2 >= 0);
if (frame <= frame1) { /* before frame1 */
result->color = *mi_eval_color(¶s->color1);
result->width = *mi_eval_scalar(¶s->width1);
} else if (frame2 <= frame) { /* after frame2 */
result->color = *mi_eval_color(¶s->color2);
result->width = *mi_eval_scalar(¶s->width2);
} else { /* between frame1 and frame2 */
/* Weights w1 and w2 depend on frame number */
miColor color1 = *mi_eval_color(¶s->color1);
miColor color2 = *mi_eval_color(¶s->color2);
miASSERT(frame1 < frame2);
w1 = ((double)frame2 - frame) / (frame2 - frame1);
miASSERT(0.0 <= w1 && w1 <= 1.0);
w2 = 1.0 - w1;
/* Mix of color1 and color2 according to weights */
result->color.r = w1 * color1.r + w2 * color2.r;
result->color.g = w1 * color1.g + w2 * color2.g;
result->color.b = w1 * color1.b + w2 * color2.b;
result->color.a = w1 * color1.a + w2 * color2.a;
/* Width depending on weights */
result->width = w1 * *mi_eval_scalar(¶s->width1)
+ w2 * *mi_eval_scalar(¶s->width2);
}
return(miTRUE);
}
extern "C" DLLEXPORT miBoolean mib_lens_stencil(
miColor* result,
miState* state,
mibStencil_t* paras)
{
miScalar f = *mi_eval_scalar(¶s->floor);
miScalar c = *mi_eval_scalar(¶s->ceiling);
miColor fc = *mi_eval_color(¶s->floor_color);
miColor cc = *mi_eval_color(¶s->ceil_color);
miTag st = *mi_eval_tag(¶s->stencil);
miScalar s;
miVector coord;
/* handle default parameter values */
if (c == 0.0f) {
c = 1.0f;
}
if (!st || f >= c) {
return mi_trace_eye(result, state, &state->org, &state->dir);
}
coord.x = state->raster_x / state->camera->x_resolution;
coord.y = state->raster_y / state->camera->y_resolution;
coord.z = 0.0f;
mi_lookup_scalar_texture(&s, state, st, &coord);
s = (s-f)/(c-f);
if (s < 0.0f) {
*result = fc;
} else if ( s > 1.0f) {
*result = cc;
} else {
miColor col = { 0.0, 0.0, 0.0, 1.0};
miScalar sn = 1.0f - s;
(void) mi_trace_eye(&col, state, &state->org, &state->dir);
result->r = s * col.r + sn * fc.r;
result->g = s * col.g + sn * fc.g;
result->b = s * col.b + sn * fc.b;
result->a = col.a;
}
return miTRUE;
}
extern "C" DLLEXPORT miBoolean mib_lens_clamp(
miColor* result,
miState* state,
mibClamp_t* paras)
{
miBoolean res;
miScalar f = *mi_eval_scalar(¶s->floor);
miScalar c = *mi_eval_scalar(¶s->ceiling);
miBoolean b = *mi_eval_boolean(¶s->luminance);
if (c == 0.0f) {
c = 1.0f;
}
if (f == c) {
f = 0.0f;
}
res = mi_trace_eye(result, state, &state->org, &state->dir);
if(b) {
/* clamp based on luminance. */
miScalar lum = mi_luminance(state, result);
if(lum < f) {
*result = *mi_eval_color(¶s->floor_color);
} else if (lum > c) {
*result = *mi_eval_color(¶s->ceil_color);
} else {
lum = (lum - f)/(c - f);
result->r *= lum;
result->g *= lum;
result->b *= lum;
}
} else {
/* clamp based on color components */
result->r = result->r > f ?
(result->r < c ? (result->r-f)/(c-f) : 1) : 0;
result->g = result->g > f ?
(result->g < c ? (result->g-f)/(c-f) : 1) : 0;
result->b = result->b > f ?
(result->b < c ? (result->b-f)/(c-f) : 1) : 0;
}
return res;
}
DLLEXPORT
miBoolean td_scalar_kernel ( miScalar *result, miState *state, struct td_scalar_kernel *params ){
miVector newPoint = *mi_eval_vector( ¶ms->point );
state->point = newPoint;
*result = *mi_eval_scalar( ¶ms->value );
return miTRUE;
}
miBoolean contour_shader_widthfromlight(
miContour_endpoint *result,
miStdInfo *info_near,
miStdInfo *info_far,
miState *state,
Light_Parameters *paras)
{
miVector orgp; /* light source origin */
miVector dirp; /* light source direction */
miVector dir;
double d;
miScalar min_width;
miScalar max_width;
/* Contour color given by a parameter */
result->color = *mi_eval_color(¶s->color);
/* Get light origin or direction */
mi_light_info(*mi_eval_tag(¶s->light), &orgp, &dirp, 0);
/* Now orgp or dirp is different from the null vector */
/* Compute direction from light to point */
if (mi_vector_dot(&orgp, &orgp) > miEPS) { /* point light source */
mi_vector_sub(&dir, &info_near->point, &orgp);
} else { /* directional light source */
miASSERT(mi_vector_dot(&dirp, &dirp) > miEPS);
dir = dirp;
}
mi_vector_normalize(&dir);
/* The contour gets wider the more the normal is pointing in the same
direction as the light source */
d = mi_vector_dot(&dir, &info_near->normal);
min_width = *mi_eval_scalar(¶s->min_width);
max_width = *mi_eval_scalar(¶s->max_width);
result->width = min_width + 0.5 * (max_width - min_width) * (d+1.0);
miASSERT(min_width <= result->width && result->width <= max_width);
return(miTRUE);
}
DLLEXPORT void LatLong_Stereo_init(
miState *state,
struct dsLatLong_Stereo *params,
miBoolean *inst_init_req)
{
if (!params) {
// Version output
mi_info(_VER_);
*inst_init_req = miTRUE;
} else {
fov_vert_angle = *mi_eval_scalar(¶ms->FOV_Vert_Angle);
fov_horiz_angle = *mi_eval_scalar(¶ms->FOV_Horiz_Angle);
camera = *mi_eval_integer(¶ms->Camera);
parallax_distance = *mi_eval_scalar(¶ms->Parallax_Distance);
cameras_separation = *mi_eval_scalar(¶ms->Cameras_Separation);
//mi_info("II-> fovV=%f,fovH=%f,cam=%i,rad=%f,sep=%f",fov_vert_angle,fov_horiz_angle,camera,parallax_distance,cameras_separation);
// Convert input angles from degrees to radians...
fov_vert_angle = (miScalar)(fov_vert_angle*M_PI/180.0);
fov_horiz_angle = (miScalar)(fov_horiz_angle*M_PI/180.0);
}
}
static miBoolean polka_dot(
miColor *result,
miState *state,
struct mtp *paras,
double x,
double y,
double z)
{
*result = sqrt(x*x + y*y + z*z) < *mi_eval_scalar(¶s->radius)
? *mi_eval_color(¶s->fg)
: *mi_eval_color(¶s->bg);
return(miTRUE);
}
extern "C" DLLEXPORT miBoolean mrParticleGeoShader(
miTag *result,
miState *state,
mrParticleGeoShader_paras *paras)
{
mi_info("mrParticleGeoShader: Version %s", VERSION);
int geometryType = *mi_eval_integer(¶s->geometryType);
miScalar minPixelSize = *mi_eval_scalar(¶s->minPixelSize);
miScalar maxPixelSize = *mi_eval_scalar(¶s->maxPixelSize);
int i_m = *mi_eval_integer(¶s->i_particleFiles);
int n_m = *mi_eval_integer(¶s->n_particleFiles);
miTag *particleFiles = mi_eval_tag(paras->particleFiles) + i_m;
for(int i = 0; i < n_m; i++)
{
if (particleFiles[i])
{
std::string fileName = tag_to_string(particleFiles[i]);
std::string correctedFileName = getCorrectFileName(state, paras, fileName);
mi_info("reading cacheFile %s", correctedFileName.c_str());
PartioContainer pc(correctedFileName);
if( geometryType == 0)
{
miTag particleTag = createMeshParticles(state, paras, pc);
if( particleTag != miNULLTAG)
miBoolean done = mi_geoshader_add_result( result, particleTag);
}else{
miTag particleTag = createNativeParticles(state, paras, pc);
if( particleTag != miNULLTAG)
miBoolean done = mi_geoshader_add_result( result, particleTag);
}
}
}
return miTRUE;
}
extern "C" DLLEXPORT miBoolean MYMR_Alluminum(
struct MYMR_Alluminum_o *resultStruct ,
miState *state,
struct MYMR_Alluminum_p *paras)
{
//Param values
miColor *specular = mi_eval_color(¶s->specular);
miScalar specular_exponent = *mi_eval_scalar(¶s->specular_exponent);
miColor *diffuse = mi_eval_color(¶s->diffuse);
miColor *result = mi_eval_color(&resultStruct->result);
//At least it should get the ambient color. I think that somehow ambient should be an ambient light or something....to be studied
*result = *mi_eval_color(¶s->ambient);
//Do lighting shit
//Get all the lights
do_diffuse_and_spec(result,state,diffuse,specular,specular_exponent);
// Do the refraction stuff
miScalar reflection_factor = *mi_eval_scalar(¶s->reflection_factor);
miColor *reflection = mi_eval_color(¶s->reflection);
do_reflections(result,state,reflection,reflection_factor);
// Do the transparency stuff
//miScalar refraction_factor = *mi_eval_scalar(¶s->refraction_factor);
//miColor *refraction = mi_eval_color(¶s->refraction);
//miScalar ior = *mi_eval_scalar(¶s->ior);
//calculate_ior(state,ior);
//printf("in:%f out:%f\n",state->ior,state->ior_in);
//do_refractions(result,state,refraction,refraction_factor);
//printf("\e[33mPost Red: %f\tGreen: %f\tBlue: %f\e[0m\n",result->r,result->g,result->b);
return miTRUE;
}
miBoolean contour_shader_silhouette(
miContour_endpoint *result,
miStdInfo *info_near,
miStdInfo *info_far,
miState *state,
Simple_Parameters *paras)
{
if (info_far) {
result->color.a = 0.0;
result->width = 0.0;
} else {
result->color = *mi_eval_color(¶s->color);
result->width = *mi_eval_scalar(¶s->width);
}
miASSERT(result->color.r >= 0.0 && result->color.g >= 0.0);
miASSERT(result->color.b >= 0.0 && result->width >= 0.0);
return(miTRUE);
}
miBoolean contour_shader_maxcolor(
miContour_endpoint *result,
miStdInfo *info_near,
miStdInfo *info_far,
miState *state,
float *width) /* only one parameter */
{
/* Contour color is max of info_near->color and info_far->color */
if (info_far) {
result->color.r = mi_MAX(info_near->color.r,info_far->color.r);
result->color.g = mi_MAX(info_near->color.g,info_far->color.g);
result->color.b = mi_MAX(info_near->color.b,info_far->color.b);
result->color.a = 1.0;
} else
result->color = info_near->color;
/* Contour width given by a parameter */
result->width = *mi_eval_scalar(width);
return(miTRUE);
}
extern "C" DLLEXPORT miBoolean mib_texture_lookup2(
miColor *result,
miState *state,
struct mib_texture_lookup2 *paras)
{
miTag tex = *mi_eval_tag(¶s->tex);
miVector coord;
miScalar factor = *mi_eval_scalar(¶s->factor);
if (tex )
{
coord.x = state->tex_list[0].x * factor;
coord.y = state->tex_list[0].y * factor;
mi_lookup_color_texture(result, state, tex, &coord);
return(miTRUE);
}
result->r = result->g = result->b = result->a = 0;
return(miFALSE);
}
miBoolean contour_shader_simple(
miContour_endpoint *result,
miStdInfo *info_near,
miStdInfo *info_far,
miState *state,
Simple_Parameters *paras)
{
miASSERT(paras->color.r >= 0.0 && paras->color.g >= 0.0);
miASSERT(paras->color.b >= 0.0 && paras->width >= 0.0);
/*
* Contour color given by a parameter
*/
result->color = *mi_eval_color(¶s->color);
/*
* Contour width given by a parameter
*/
result->width = *mi_eval_scalar(¶s->width);
return(miTRUE);
}
void point_distances3(miState *state,texture_worleynoise3d_t *param,
miVector *pt,
miScalar *f1, miVector *p1,
miScalar *f2, miVector *p2,
miScalar *f3, miVector *p3) {
miScalar cube_dist = CUBE_DIST * (*mi_eval_scalar(¶m->scale));
miVector cube = point_cube3(pt,cube_dist);
worley_context3 *context;
mi_query(miQ_FUNC_TLS_GET, state, miNULLTAG, &context);
miInteger dist_measure = *mi_eval_integer(¶m->distance_measure);
*f3 = FLT_MAX;
*f2 = *f3 - 1;
*f1 = *f2 - 1;
update_cache3(context, &cube, cube_dist);
miVector *cache = context->cacheVals;
for(int i=0; i < CACHE_SIZE; ++i) {
miVector p = cache[i];
miScalar d = distance3(dist_measure, pt, &p);
if(d < *f3) {
if(d < *f2) {
*f3 = *f2; *p3 = *p2;
if(d < *f1) {
*f2 = *f1; *p2 = *p1;
*f1 = d; *p1 = p;
}
else {
*f2 = d; *p2 = p;
}
}
else {
*f3 = d; *p3 = p;
}
}
}
}
extern "C" DLLEXPORT miBoolean mib_ray_marcher(
miColor *result,
miState *state,
struct mrm *p)
{
struct mrm pe;
miScalar scale;
result->r = result->g = result->b = result->a = 0.0;
/*
* copy all parameters to a static structure to
* avoid all the mi_eval_* calls in the code
*/
pe.s = *mi_eval_tag(&p->s);
pe.distance = *mi_eval_scalar(&p->distance);
pe.num = *mi_eval_integer(&p->num);
pe.subdiv = *mi_eval_integer(&p->subdiv);
pe.contrast = *mi_eval_color(&p->contrast);
if (pe.num == 0.0)
if (pe.distance > 0.0)
pe.num = state->dist / pe.distance;
else
pe.num = 4; /* default #samples */
if (pe.num < 2)
pe.num = 2;
/* go! */
raymarch(result, state, &pe);
/* normalize result */
scale = 1.0 / (miScalar)pe.num;
result->r *= scale;
result->g *= scale;
result->b *= scale;
result->a *= scale;
return(miTRUE);
}
miBoolean contour_shader_depthfade(
miContour_endpoint *result,
miStdInfo *info_near,
miStdInfo *info_far,
miState *state,
Depthfade_Parameters *paras)
{
miScalar depth = info_near->point.z;
double near_z, far_z, w_near, w_far;
/* Ensure that near_z and far_z are negative as they should be */
near_z = -fabs(*mi_eval_scalar(¶s->near_z));
far_z = -fabs(*mi_eval_scalar(¶s->far_z));
if (depth > near_z) { /* contour is closer than near_z */
result->color = *mi_eval_color(¶s->near_color);
result->width = *mi_eval_scalar(¶s->near_width);
} else if (depth < far_z) { /* contour is more distant than far_z*/
result->color = *mi_eval_color(¶s->far_color);
result->width = *mi_eval_scalar(¶s->far_width);
} else { /* contour is betwn near_z and far_z */
miColor near_color = *mi_eval_color(¶s->near_color);
miColor far_color = *mi_eval_color(¶s->far_color);
/* Weights w_near and w_far depend on depth */
w_near = (depth - far_z) / (near_z - far_z);
miASSERT(0.0 <= w_near && w_near <= 1.0);
w_far = 1.0 - w_near;
/* Mix of near_color and far_color according to weights */
result->color.r = w_near * near_color.r + w_far * far_color.r;
result->color.g = w_near * near_color.g + w_far * far_color.g;
result->color.b = w_near * near_color.b + w_far * far_color.b;
result->color.a = w_near * near_color.a + w_far * far_color.a;
/* Width depending on weights */
result->width = w_near * *mi_eval_scalar(¶s->near_width)
+ w_far * *mi_eval_scalar(¶s->far_width);
}
return(miTRUE);
}
miScalar worleynoise3d_val(miState *state,texture_worleynoise3d_t *param) {
miScalar f1, f2, f3;
miVector p1, p2, p3;
// ways to get the current point:
// state->tex_list[0]; // yields good results only in the x and y coordinate
// state->point // usable for 3D, but problematic for getting a smooth 2D texture as x,y and z all have to be somehow incorporated in the 2D vector to use
// state->tex // does not yield usable results / seems to be constant
//
// instead, we just take an u and v value explicitly; they would usually be provided by a 2D placement node.
// note: getting current values must always be wrapped in mi_eval... calls!
miVector pt;
miScalar *m = mi_eval_transform(¶m->matrix);
mi_point_transform(&pt,&state->point,m);
point_distances3(state,param,&pt,&f1,&p1,&f2,&p2,&f3,&p3);
miInteger dist_measure = *mi_eval_integer(¶m->distance_measure);
miScalar scale = dist_scale(dist_measure) * (*mi_eval_scalar(¶m->scale)) * (*mi_eval_scalar(¶m->scaleX));
miBoolean jagged = *mi_eval_boolean(¶m->jagged_gap);
miScalar s = 1.0;
{
miScalar gap_size = *mi_eval_scalar(¶m->gap_size);
miVector ptX = pt;
// jagged edges. useful for broken earth crusts
if(jagged) {
miVector seed = pt; mi_vector_mul(&seed,3 / scale);
miScalar jaggingX = (mi_unoise_3d(&seed) - 0.5) * scale * 0.2;
ptX.x += jaggingX; seed.x += 1000;
miScalar jaggingY = (mi_unoise_3d(&seed) - 0.5) * scale * 0.2;
ptX.y += jaggingY; seed.y += 1000;
miScalar jaggingZ = (mi_unoise_3d(&seed) - 0.5) * scale * 0.2;
ptX.z += jaggingZ;
}
miScalar f1X, f2X, f3X;
miVector p1X, p2X, p3X;
point_distances3(state,param,&ptX,&f1X,&p1X,&f2X,&p2X,&f3X,&p3X);
// based on code from "Advanced Renderman"
// this leads to gaps of equal width, in contrast to just simple thresholding of f2 - f1.
miScalar scaleFactor = (distance3(dist_measure, &p1X, &p2X) * scale) / (f1X + f2X);
// FIXME: there may be some adjustment needed for distance measures that are not just dist_linear
if(gap_size * scaleFactor > f2X - f1X) // on left side
s = -1.0;
}
{
f1 /= scale;
f2 /= scale;
f3 /= scale;
}
miScalar dist = 0.0;
{
miInteger dist_mode = *mi_eval_integer(¶m->distance_mode);
switch(dist_mode) {
case DIST_F1: dist = f1; break;
case DIST_F2_M_F1: dist = f2 - f1; break;
case DIST_F1_P_F2: dist = (2 * f1 + f2) / 3; break;
case DIST_F3_M_F2_M_F1: dist = (2 * f3 - f2 - f1) / 2; break;
case DIST_F1_P_F2_P_F3: dist = (0.5 * f1 + 0.33 * f2 + (1 - 0.5 - 0.33) * f3); break;
default: ;
}
}
return s * scaling_function(dist);
}
