C++ (Cpp) mi_trace_reflection示例

示例#1

文件： basereflect.cpp 项目： DimondTheCat/xray

extern "C" DLLEXPORT miBoolean mib_reflect(
	miColor		*result,
	miState		*state,
	struct mr	*paras)
{
	miBoolean	ok;
	miBoolean	notrace;
	miColor		*reflect =  mi_eval_color(&paras->reflect);
	miColor		inp;
	miVector	dir;
	miScalar	save_ior;

        /* check for illegal calls */
        if (state->type == miRAY_SHADOW || state->type == miRAY_DISPLACE ) {
		return(miFALSE);
	}

	if (reflect->r == 0.0 && reflect->g == 0.0 &&
	    reflect->b == 0.0 && reflect->a == 0.0) {
		*result = *mi_eval_color(&paras->input);
		return(miTRUE);
	}
	notrace    = *mi_eval_boolean(&paras->notrace);
	save_ior   = state->ior;
	state->ior = state->ior_in;

	mi_reflection_dir(&dir, state);
	ok = miFALSE;
	if (!notrace &&
	    state->reflection_level < state->options->reflection_depth &&
	    state->reflection_level + state->refraction_level <
						state->options->trace_depth)
		ok = mi_trace_reflection(result, state, &dir);

	if (!ok) {
		miTag savevol = state->volume;
		state->volume = 0;
		ok = mi_trace_environment(result, state, &dir) || !notrace;
		state->volume = savevol;
	}

	if (reflect->r != 1.0 || reflect->g != 1.0 ||
	    reflect->b != 1.0 || reflect->a != 1.0) {
		inp = *mi_eval_color(&paras->input);
		result->r = result->r * reflect->r + inp.r * (1 - reflect->r);
		result->g = result->g * reflect->g + inp.g * (1 - reflect->g);
		result->b = result->b * reflect->b + inp.b * (1 - reflect->b);
		result->a = result->a * reflect->a + inp.a * (1 - reflect->a);
	}
	state->ior = save_ior;
	return(ok);
}

示例#2

文件： basedielec.cpp 项目： OpenXRay/xray

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);
}

示例#3

文件： MYMR_Alluminum.cpp 项目： jcrogel/MyMentalRay

void do_reflections(miColor *result,miState *state,miColor *reflection, miScalar factor){
	
	miVector *reflection_direction = (miVector *) malloc(sizeof(miVector *));
	if (factor> 0){
		miScalar f =  1 - factor;
		result->r *= f;
		result->g *= f;
		result->b *= f;
		
		mi_reflection_dir(reflection_direction,state);
		if(mi_trace_reflection(reflection,state,reflection_direction) || 
				mi_trace_environment(reflection,state,reflection_direction)){
			result->r += factor * reflection->r;
			result->g += factor * reflection->g;
			result->b += factor * reflection->b;
		}
	}
	delete reflection_direction;
}