Shader summed_noise_color

Click on the filename to display or download the file.

summed_noise_color.mi
declare shader 
    color "summed_noise_color" ( 
	scalar "point_scale" default 1, 
	scalar "octave_scaling" default 2, 
	scalar "summing_weight" default 2, 
	integer "number_of_octaves" default 5, 
	scalar "red_exponent" default 1, 
	scalar "green_exponent" default 1, 
	scalar "blue_exponent" default 1 ) 
    version 1 
    apply material, texture 
end declare 

summed_noise_color.c
#include "shader.h" 
#include "miaux.h" 
 
struct summed_noise_color {  
    miScalar point_scale; 
    miScalar octave_scaling; 
    miScalar summing_weight; 
    miInteger number_of_octaves; 
    miScalar red_exponent; 
    miScalar green_exponent; 
    miScalar blue_exponent; 
}; 
 
DLLEXPORT 
int summed_noise_color_version(void) { return(1); } 
 
DLLEXPORT 
miBoolean summed_noise_color (  
    miColor *result, miState *state, struct summed_noise_color *params ) 
{ 
    miScalar noise_sum; 
    miScalar red_exponent = *mi_eval_scalar(&params->red_exponent); 
    miScalar green_exponent = *mi_eval_scalar(&params->green_exponent); 
    miScalar blue_exponent = *mi_eval_scalar(&params->blue_exponent); 
    miVector object_point; 
    mi_point_to_object(state, &object_point, &state->point); 
    mi_vector_mul(&object_point, *mi_eval_scalar(&params->point_scale)); 
     
    noise_sum =  
        miaux_summed_noise(&object_point, 
                           *mi_eval_scalar(&params->summing_weight), 
                           *mi_eval_scalar(&params->octave_scaling), 
                           *mi_eval_integer(&params->number_of_octaves)); 
    result->r =  
        red_exponent == 1 ? noise_sum : pow(noise_sum, red_exponent); 
    result->g =  
        green_exponent == 1 ? noise_sum : pow(noise_sum, green_exponent); 
    result->b =  
        blue_exponent == 1 ? noise_sum : pow(noise_sum, blue_exponent); 
 
    return miTRUE; 
} 

summed_noise_color_util.c
double miaux_summed_noise (  
    miVector *point, 
    double summing_weight, double octave_scaling, int octave_count) 
{ 
    int i; 
    double noise_value, 
	noise_sum = 0.0, noise_scale = 1.0, maximum_noise_sum = 0.0; 
    miVector scaled_point; 
    miaux_set_vector(&scaled_point, point->x, point->y, point->z); 
 
    for (i = 0; i < octave_count; i++) { 
	noise_value = mi_unoise_3d(&scaled_point); 
	noise_sum += noise_value / noise_scale; 
	maximum_noise_sum += 1.0 / noise_scale; 
	noise_scale *= summing_weight; 
	miaux_scale_vector(&scaled_point, octave_scaling); 
    } 
    return noise_sum/maximum_noise_sum; 
} 
 
void miaux_set_vector(miVector *v, double x, double y, double z) 
{ 
    v->x = x; 
    v->y = y; 
    v->z = z; 
} 
 
void miaux_scale_vector(miVector *result, miScalar scale) 
{ 
    result->x *= scale; 
    result->y *= scale; 
    result->z *= scale; 
} 

22 April 2008 23:39:57