Exemple #1
0
void do_refractions(miColor *result,miState *state,miColor *refraction, miScalar factor){
	miVector *refraction_direction = (miVector *) malloc(sizeof(miVector *));
	miColor *refr =  (miColor *) malloc(sizeof(miColor *));
	miBoolean found = miFALSE;
	
	refr->r = refraction->r;
	refr->g = refraction->g;
	refr->b = refraction->b;
	
	//printf("refr:%d refraction:%d\n",&refr->r,&refraction->r);
	
	if (factor > 0){
		//miScalar *ior = mi_eval_scalar(&state->ior);
		miScalar f =1 - factor;
		result->r *= f;
		result->b *= f;
		result->g *= f;
		result->a = f;

		/*if(state->ior == 1.0 || state->ior==0.0  || state->ior_in==1.0 || state->ior_in==0.0){
			mi_trace_transparent(refr, state);
			printf(" %f %f %f\n",state->dir.x,state->dir.y,state->dir.z);
			found = miTRUE;
		}else{*/
			if(mi_refraction_dir(refraction_direction,state,state->ior_in,state->ior)){
				if( mi_trace_refraction(refr,state,refraction_direction)){
					//printf("Here2\n");
					found = miTRUE;
				}
				
			}else{
				if( mi_trace_environment(refr,state,refraction_direction)){
					//printf("Here3\n");
					found = miTRUE;
				}
			}
		//}
		if (found == miTRUE){
			result->r += factor * refr->r;
			result->g += factor * refr->g;
			result->b += factor * refr->b;
			result->a += factor * refr->a;
		}
		//printf("\e[34mDirection X: %f\tY: %f\tZ: %f\e[0m\n",refraction_direction->x,refraction_direction->y,refraction_direction->z);
		//printf("\e[32mDirection X: %f\tY: %f\tZ: %f\e[0m\n",refraction_direction->x,refraction_direction->y,refraction_direction->z);
		//mi_mem_release(refraction_direction);
		delete refraction_direction;
		delete refr;
		
	}
	
	return;
	
}
Exemple #2
0
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(&paras->refract);
	if (refract == 0.0)
		*result = *mi_eval_color(&paras->input);
	else {
		ior = *mi_eval_scalar(&paras->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(&paras->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(&paras->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);
}