Shader threshold_volume

Click on the filename to display or download the file.

threshold_volume.mi
declare shader 
    color "threshold_volume" ( 
	color  "color" default 1 1 1 1, 
	vector "center" default 0 0 0, 
	scalar "radius" default 1, 
	scalar "density_threshold" default 0, 
	scalar "unit_density" default 1, 
	scalar "march_increment" default 0.1 ) 
    version 1 
    apply volume 
end declare 

threshold_volume.c
#include "shader.h" 
#include "miaux.h" 
 
struct threshold_volume { 
    miColor color; 
    miVector center; 
    miScalar radius; 
    miScalar density_threshold; 
    miScalar unit_density; 
    miScalar march_increment; 
}; 
 
DLLEXPORT 
int threshold_volume_version(void) { return 1; } 
 
DLLEXPORT 
miBoolean threshold_volume (  
    miColor *result, miState *state, struct threshold_volume *params  ) 
{ 
    miScalar march_increment = *mi_eval_scalar(&params->march_increment); 
    miColor *color = mi_eval_color(&params->color); 
    miVector *center = mi_eval_vector(&params->center); 
    miScalar radius = *mi_eval_scalar(&params->radius); 
    miScalar unit_density = *mi_eval_scalar(&params->unit_density); 
    miScalar density_threshold = *mi_eval_scalar(&params->density_threshold); 
    miScalar distance, accumulated_density = 0.0; 
    miVector march_point, internal_center; 
    mi_point_from_object(state, &internal_center, center); 
 
    for (distance = 0; distance < state->dist; distance += march_increment) { 
        miaux_march_point(&march_point, state, distance); 
        accumulated_density +=  
            miaux_threshold_density(&march_point, &internal_center, radius,  
                                    unit_density, march_increment); 
        if (accumulated_density > density_threshold) { 
            miaux_copy_color(result, color); 
            break; 
        } 
    } 
    return miTRUE; 
} 

threshold_volume_util.c
void miaux_march_point( 
    miVector *result, miState *state, miScalar distance) 
{ 
    miaux_point_along_vector(result, &state->org, &state->dir, distance); 
} 
 
void miaux_point_along_vector( 
    miVector *result, miVector *point, miVector *direction, miScalar distance) 
{ 
    result->x = point->x + distance * direction->x; 
    result->y = point->y + distance * direction->y; 
    result->z = point->z + distance * direction->z; 
} 
 
miScalar miaux_threshold_density( 
    miVector *point, miVector *center, miScalar radius,  
    miScalar unit_density, miScalar march_increment) 
{ 
    miScalar distance = mi_vector_dist(center, point); 
    if (distance <= radius) 
	return unit_density * march_increment; 
    else 
	return 0.0; 
} 
 
void miaux_copy_color(miColor *result, miColor *color) 
{ 
    result->r = color->r; 
    result->g = color->g; 
    result->b = color->b; 
    result->a = color->a; 
} 

22 April 2008 23:40:52