Shader hair_color_texture

Click on the filename to display or download the file.

hair_color_texture.mi
declare shader 
    color "hair_color_texture" () 
    apply material 
    version 1 
end declare 

hair_color_texture.c
#include "shader.h" 
#include "miaux.h" 
 
DLLEXPORT 
int hair_color_texture_version(void) { return 1; } 
 
DLLEXPORT 
miBoolean hair_color_texture ( 
    miColor *result, miState *state, void *params  ) 
{ 
    miColor hair_color, opacity, background; 
    miaux_copy_color(&hair_color, (miColor*)&state->tex_list[0]); 
 
    if (state->type == miRAY_SHADOW) { 
        miScalar transparency = 1.0 - hair_color.a; 
        result->r *= miaux_shadow_breakpoint(hair_color.r, transparency, 0.5); 
        result->g *= miaux_shadow_breakpoint(hair_color.g, transparency, 0.5); 
        result->b *= miaux_shadow_breakpoint(hair_color.b, transparency, 0.5); 
        return miaux_all_channels_equal(result, 0.0) ? miFALSE : miTRUE; 
    } 
    miaux_copy_color(result, &hair_color); 
    miaux_set_channels(&opacity, result->a); 
    mi_opacity_set(state, &opacity); 
    if (result->a < 1.0) { 
        mi_trace_transparent(&background, state); 
        miaux_blend_channels(result, &background, &opacity); 
    } 
    return miTRUE; 
} 

hair_color_texture_util.c
void miaux_copy_color(miColor *result, miColor *color) 
{ 
    result->r = color->r; 
    result->g = color->g; 
    result->b = color->b; 
    result->a = color->a; 
} 
 
double miaux_shadow_breakpoint ( 
    double color, double transparency, double breakpoint ) 
{ 
    if (transparency < breakpoint) 
	return miaux_fit(transparency, 0, breakpoint, 0, color); 
    else 
	return miaux_fit(transparency, breakpoint, 1, color, 1); 
} 
 
double miaux_fit( 
    double v, double oldmin, double oldmax, double newmin, double newmax)     
{ 
    return newmin + ((v - oldmin) / (oldmax - oldmin)) * (newmax - newmin); 
} 
 
miBoolean miaux_all_channels_equal(miColor *c, miScalar v) 
{ 
    if (c->r == v && c->g == v && c->b == v && c->a == v) 
	return miTRUE; 
    else 
	return miFALSE; 
} 
 
void miaux_set_channels(miColor *c, miScalar new_value) 
{ 
    c->r = c->g = c->b = c->a = new_value; 
} 
 
void miaux_blend_channels(miColor *result, 
			  miColor *blend_color, miColor *blend_fraction) 
{ 
    result->r = miaux_blend(result->r, blend_color->r, blend_fraction->r); 
    result->g = miaux_blend(result->g, blend_color->g, blend_fraction->g); 
    result->b = miaux_blend(result->b, blend_color->b, blend_fraction->b); 
} 
 
double miaux_blend(miScalar a, miScalar b, miScalar factor) 
{ 
    return a * factor + b * (1.0 - factor); 
} 

22 April 2008 23:40:41