YafXSI.cpp

/*
This file is part of YafXSI.
YafaRay Exporter for Autodesk(c) Softimage(c).

Copyright (C) 2010 2011 2012  Pedro Alcaide, aka povmaniaco

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/
#include "include/yafxsi_values.h"

//--
using namespace XSI;
using namespace MATH;
using namespace yafaray;
using namespace std;
 //--

//--
void yafaray_texture(yafrayInterface_t *yi);
//--
void yafaray_material(yafrayInterface_t *yi);
//--
void yafaray_light(yafrayInterface_t *yi);
//--
int yaf_export();
//--
void yaf_preview();
//--
void yafaray_execute();
//--
void open_image_render();
//--
void yafaray_update_values( CString paramName, Parameter changed, PPGEventContext ctxt );
//--
void yafaray_dynamic_tab_lighting( Parameter changed, PPGEventContext ctxt);
//--
void yafaray_dynamic_tab_vintegrator(Parameter changed, PPGEventContext ctxt);
//--
void yafaray_dynamic_tab_world(Parameter changed, PPGEventContext ctxt);
//--
void yafaray_cam(yafrayInterface_t *yi);
//--
int yafaray_object(yafrayInterface_t *yi);
//--
int yaf_xml();
//--

XSIPLUGINCALLBACK CStatus XSILoadPlugin( PluginRegistrar& in_reg )
{
	in_reg.PutAuthor(L"Pedro Alcaide");
    in_reg.PutName(L"YafaRay Renderer");
    in_reg.PutEmail(L"p.alcaide@hotmail.com");
    in_reg.PutURL(L"http://povmaniaco.blogspot.com");
    in_reg.PutVersion(1,0);
    in_reg.RegisterProperty(L"YafaRay Renderer");
    in_reg.RegisterRenderer( L"YafaRay Integrated Renderer" );
    in_reg.RegisterMenu(siMenuTbRenderRenderID,L"YafaRay Renderer",false,false);
    //RegistrationInsertionPoint - do not remove this line

	return CStatus::OK;
}
//--
XSIPLUGINCALLBACK CStatus XSIUnloadPlugin( const PluginRegistrar& in_reg )
{
    CString strPluginName;
    strPluginName = in_reg.GetName();
    Application().LogMessage(strPluginName + L" has been unloaded.");
    return CStatus::OK; 
}
//--
XSIPLUGINCALLBACK CStatus YafaRayRenderer_Define( CRef& in_ctxt )
{
    //--
    Context ctxt( in_ctxt );
    Parameter oParam;
    prop = ctxt.GetSource();
    int sps = siPersistable;
    int sanim = siAnimatable;
    CValue dft;
    
    //-- preview materials
    prop.AddParameter( L"btype_geo", CValue::siInt4, sps, L"",L"", vtype_geo, 0,4,0,4, oParam);

    //----/ objects hidden /---->
    prop.AddParameter( L"use_hidden_obj",   CValue::siBool,  sps, L"",L"", vIsHiddenObj,      dft,dft,dft,dft, oParam);
    prop.AddParameter( L"bhidden_light",    CValue::siBool,  sps, L"",L"", vIsHiddenLight,    dft,dft,dft,dft, oParam);
    prop.AddParameter( L"use_hidden_cam",   CValue::siBool,  sps, L"",L"", vIsHiddenCam,      dft,dft,dft,dft, oParam);
    prop.AddParameter( L"use_hidden_surf",  CValue::siBool,  sps, L"",L"", vIsHiddenSurfaces, dft,dft,dft,dft, oParam);
    prop.AddParameter( L"smooth_mesh",      CValue::siBool,  sps, L"",L"", vSmooth_mesh,      dft,dft,dft,dft, oParam);

    //----/ image /-------------->
    prop.AddParameter( L"Width",        CValue::siInt4, sps, L"",L"", vXRes, 0l,2048l,0l,1024l, oParam);
    prop.AddParameter( L"Height",       CValue::siInt4, sps, L"",L"", vYRes, 0l,2048l,0l,768l,  oParam);
    prop.AddParameter( L"bsavefile",    CValue::siInt4, sps, L"",L"", vSavefile,  oParam ) ;

    //----/ directlighting settings /-------->
    prop.AddParameter( L"bcaustics",         CValue::siBool,  sps, L"",L"", vUseCaust, dft,dft,dft,dft, oParam);
    prop.AddParameter( L"bDLCphotons",       CValue::siInt4,  sps, L"",L"", vDLCphotons, 1,10000000,10000,500000, oParam);
    prop.AddParameter( L"bDLcaustic_mix",    CValue::siInt4,  sps, L"",L"", vDLCaustic_mix, 1,10000,1,1000, oParam);
    prop.AddParameter( L"bcaustic_depth",    CValue::siInt4,  sps, L"",L"", vDLCaust_depth, 0,50,0,50, oParam);
    prop.AddParameter( L"bDLcaust_radius",   CValue::siFloat, sps, L"",L"", vCaust_radius, 0,100,0,100, oParam);
    
	//----/ AO settings /------>
    prop.AddParameter( L"bUse_AO",		CValue::siBool,  sps, L"",L"", vUse_AO,     dft,dft,dft,dft,    oParam);
	prop.AddParameter( L"AOc_red",      CValue::siFloat, sps, L"",L"", vAOc_red,    0.0,1.0,0.0,1.0,    oParam );
    prop.AddParameter( L"AOc_green",    CValue::siFloat, sps, L"",L"", vAOc_green,  0.0,1.0,0.0,1.0,    oParam );
    prop.AddParameter( L"AOc_blue",     CValue::siFloat, sps, L"",L"", vAOc_blue,   0.0,1.0,0.0,1.0,    oParam );
    prop.AddParameter( L"AOc_alpha",    CValue::siFloat, sps, L"",L"", vAOc_alpha,  0.0,1.0,0.0,1.0,    oParam );
    prop.AddParameter( L"bao_samples",  CValue::siInt4,  sps, L"",L"", vAO_samples,     0,1000,0,1000,  oParam );
    prop.AddParameter( L"bao_distance", CValue::siFloat, sps, L"",L"", vAO_distance,    0,1000,0.0,1000,    oParam);

    
    //----/ photon mappings settings /------------>
    prop.AddParameter( L"bsearch",          CValue::siInt4, sps,  L"",L"", vSearch,         1,10000,1,10000,        oParam);
    prop.AddParameter( L"bdepth",           CValue::siInt4, sps,  L"",L"", vDepth,          0,50,0,50,              oParam);
    prop.AddParameter( L"bdiff_radius",     CValue::siFloat,sps,  L"",L"", vDiff_radius,    0,100,0,100,            oParam);
    prop.AddParameter( L"bdiff_photons",    CValue::siInt4, sps,  L"",L"", vPMDphotons,     1,10000000,1,10000000,  oParam);
    prop.AddParameter( L"bcaust_photons",   CValue::siInt4, sps,  L"",L"", vPMCphotons,     1,10000000,1,10000000,  oParam);
    prop.AddParameter( L"bcaust_radius",    CValue::siFloat,sps,  L"",L"", vCausticRadius,  0,100,0,100,            oParam);
    prop.AddParameter( L"bfinal_gather",    CValue::siBool, sps,  L"",L"", vFinal_gather,   dft,dft,dft,dft,        oParam);
    prop.AddParameter( L"bcaustic_mix",     CValue::siInt4, sps,  L"",L"", vCaustic_mix,    1,10000,1,10000,        oParam);
    prop.AddParameter( L"bfg_bounces",      CValue::siInt4, sps,  L"",L"", vFg_bounces,     1,20,1,20,              oParam);
    prop.AddParameter( L"bfg_samples",      CValue::siInt4, sps,  L"",L"", vFg_samples,     1,4096,1,4096,          oParam);
    prop.AddParameter( L"bshow_map",        CValue::siBool, sps,  L"",L"", vShow_map,       dft,dft,dft,dft,        oParam);

    //----/ pathtracing settings /----------->
    prop.AddParameter( L"bpathcaus_depth",   CValue::siInt4,    sps,L"",L"", vCaustic_depth,    1,10000,1,10000,		oParam );
    prop.AddParameter( L"bpathcaus_radius",  CValue::siFloat,   sps,L"",L"", vPTCaust_radius,   0,100,0,100,			oParam );
    prop.AddParameter( L"bpathcaus_photons", CValue::siInt4,    sps,L"",L"", vPTCphotons,       1,10000000,1,10000000,	oParam );
    prop.AddParameter( L"tracer_method",     CValue::siInt4,    sps,L"",L"", vTracer_method,    0,10,0,10,				oParam );
    prop.AddParameter( L"bpath_samples",     CValue::siInt4,    sps,L"",L"", vPath_samples,     0,5000,0,5000,			oParam );
    prop.AddParameter( L"bno_recursion",     CValue::siBool,    sps,L"",L"", vNo_recursion,     dft,dft,dft,dft,		oParam );
    prop.AddParameter( L"buseback",          CValue::siBool,    sps,L"",L"", vUse_backg,        dft,dft,dft,dft,		oParam );
    prop.AddParameter( L"bpathcaus_mix",     CValue::siInt4,    sps,L"",L"", vPTCaustic_mix,    1,10000,1,10000,		oParam );
    prop.AddParameter( L"bpath_depth",       CValue::siInt4,    sps,L"",L"", vPath_depth,       0,50,0,50,				oParam );

    //-- sppm
    prop.AddParameter( L"bspphotons",          CValue::siInt4,    sps,L"",L"", vspphotons,       10000,2000000,500000,1000000, oParam );
    prop.AddParameter( L"bsppassNums",         CValue::siInt4,    sps,L"",L"", vsppassNums,      1,1000,500,1000,       oParam );
    prop.AddParameter( L"bspbounces",          CValue::siInt4,    sps,L"",L"", vspbounces,       1,10,4,10,             oParam );
    prop.AddParameter( L"bspdiffuseRadius",    CValue::siFloat,   sps,L"",L"", vspdiffuseRadius, 0.0,10.0,1.0,5.0,      oParam );
    prop.AddParameter( L"bspsearch",           CValue::siInt4,    sps,L"",L"", vspsearch,        1,100,50,100,          oParam );
    prop.AddParameter( L"bsptimes",            CValue::siFloat,   sps,L"",L"", vsptimes,         0.0,1.0,0.1,1.0,       oParam );
    prop.AddParameter( L"bsppmIRE",            CValue::siBool,    sps,L"",L"", vsppmIRE,         dft,dft,dft,dft,       oParam );
    
    //- debug
    prop.AddParameter( L"bshowPN",             CValue::siBool,    sps,L"",L"", vshowPN,         dft,dft,dft,dft,        oParam );
    prop.AddParameter( L"bdebug_method",       CValue::siInt4,    sps,L"",L"", vdebug_method,   0,20,0,20,				oParam );
    //----/ general settings /-------------->
    prop.AddParameter( L"bclay",          CValue::siBool, sps, L"",L"", vClay_render,   dft,dft,dft,dft, oParam );
    prop.AddParameter( L"bclay_red",      CValue::siFloat, sps, L"",L"", vclay_red,     0.0,1.0,0.0,1.0, oParam );
    prop.AddParameter( L"bclay_green",    CValue::siFloat, sps, L"",L"", vclay_green,   0.0,1.0,0.0,1.0, oParam );
    prop.AddParameter( L"bclay_blue",     CValue::siFloat, sps, L"",L"", vclay_blue,    0.0,1.0,0.0,1.0, oParam );
    
    prop.AddParameter( L"bthreads",        CValue::siInt4, sps, L"",L"", vThreads,          0,20,0,20,          oParam );
    prop.AddParameter( L"bz_buffer",       CValue::siBool, sps, L"",L"", vZ_buffer,         dft,dft,dft,dft,    oParam );
    prop.AddParameter( L"braydepth",       CValue::siInt4, sps, L"",L"", vRaydepth,         0,64,0,64,          oParam );
    prop.AddParameter( L"bauto_thread",    CValue::siBool, sps, L"",L"", vAuto_thread,      dft,dft,dft,dft,    oParam );
    prop.AddParameter( L"bshadows_depth",  CValue::siInt4, sps, L"",L"", vShadows_depth,    0,64,0,64,          oParam );
    prop.AddParameter( L"btransp_shadows", CValue::siBool, sps, L"",L"", vTransp_shad,      dft,dft,dft,dft,    oParam );
    prop.AddParameter( L"bshowpix",        CValue::siBool, sps, L"",L"", vshowpix,          dft,dft,dft,dft,    oParam );
    //--
    prop.AddParameter( L"btileorder",      CValue::siInt4, sps, L"",L"", vtileorder,            0,4,0,4,         oParam );
    prop.AddParameter( L"btilesize",       CValue::siInt4, sps, L"",L"", vtilesize,            0,512,0,512,      oParam );

    //----/ output settings /------------->
    prop.AddParameter( L"gamma",        CValue::siFloat, sps,L"",L"", vContrast,    0,10,0,3,	oParam ); // 3
    prop.AddParameter( L"bgamma_in",    CValue::siFloat, sps,L"",L"", vcontrast_in, 0,10,0,3,	oParam ); // 3
    prop.AddParameter( L"bclamp_rgb",   CValue::siBool,  sps,L"",L"", vClamp_rgb,   dft,dft,dft,dft,	oParam );
    prop.AddParameter( L"bpremu_alpha", CValue::siBool,  sps,L"",L"", vPremu_alpha, dft,dft,dft,dft,	oParam );//

    //----/ output method /----->
    prop.AddParameter( L"bdraw_render",   CValue::siBool,   sps, L"",L"", vDraw_render,dft,dft,dft,dft, oParam );
    prop.AddParameter( L"bcustom_string", CValue::siString, sps, L"",L"", vCustom_string, oParam ) ;

    //----/ AA settings /----->
    prop.AddParameter( L"baa_modes",        CValue::siInt4, sps,L"",L"",    vFilter_type,  0,10,0,10,    oParam );
    prop.AddParameter( L"baa_passes",       CValue::siInt4, sps,L"",L"",    vAA_passes,    1,100,1,100,  oParam );
    prop.AddParameter( L"baa_samples",      CValue::siInt4, sps,L"",L"",    vAA_samples,   1,256,1,256,  oParam );
    prop.AddParameter( L"baa_threshold",    CValue::siFloat, sps,L"",L"",   vAA_threshold, 0.0,1.0,0.1,1.0,	oParam ); // 3
    prop.AddParameter( L"baa_inc",          CValue::siInt4, sps,L"",L"",    vAA_inc,       1,64,1,64,    oParam );
    prop.AddParameter( L"baa_pixel",        CValue::siFloat, sps,L"",L"",   vAA_pixel,     0.1,20.0,0.1,10.0,	oParam ); // 3

    //----/ world settings /-------->
    prop.AddParameter(L"setworld",        CValue::siInt4, sps,L"",L"", vSetworl, 0,5,0,5, oParam );

    //-- single color
    prop.AddParameter( L"bsc_red",   CValue::siFloat, sps, L"", L"",    vBack_red,  0.0,1.0,0.0,1.0, oParam );
    prop.AddParameter( L"bsc_green", CValue::siFloat, sps, L"", L"",    vBack_green,0.0,1.0,0.0,1.0, oParam );
    prop.AddParameter( L"bsc_blue",  CValue::siFloat, sps, L"", L"",    vBack_blue, 0.0,1.0,0.0,1.0, oParam );
    prop.AddParameter( L"bsc_alpha", CValue::siFloat, sps, L"", L"",    vBack_alpha,0.0,1.0,0.0,1.0, oParam );

    //----/ ibl and photons /---->
    prop.AddParameter( L"buse_ibl",     CValue::siBool,     sps, L"", L"",		vUse_ibl,		dft,dft,dft,dft,    oParam );
    prop.AddParameter( L"bibl_samples", CValue::siInt4,     sps, L"", L"",		vIbl_samples,	1,512,1,512,		oParam );
    prop.AddParameter( L"bibl_power",	CValue::siFloat,	sps, L"", L"",		vIbl_power,		0,10,0,10,			oParam );

    prop.AddParameter( L"binterp",      CValue::siInt4,        sps, L"", L"",   vUse_interp,	0,2,0,2,    	oParam );
    prop.AddParameter( L"t_exposure",   CValue::siFloat,       sps, L"", L"",   vtexposure,	0.0,1.0,0.1,1.0,	oParam );
    prop.AddParameter( L"bHDRI",        CValue::siString,      sps, L"", L"",   vHDRI,	oParam );
    prop.AddParameter( L"brotation",    CValue::siInt4,        sps, L"", L"",   vrotation,	-180,180,-180,180,	oParam );
    prop.AddParameter( L"bmapworld",    CValue::siInt4,        sps, L"", L"",   vmapworld,	0,5,0,5,			oParam );
    prop.AddParameter( L"bw_caust",     CValue::siBool,        sps, L"", L"",   vW_caust,	dft,dft,dft,dft,    oParam );
    prop.AddParameter( L"bw_diff",      CValue::siBool,        sps, L"", L"",   vW_diff,	dft,dft,dft,dft,    oParam );
    
    //----/ gradient /----/ horizont /----/ color /---->
    prop.AddParameter(L"bhor_red",   CValue::siFloat, sps, L"", L"", vHor_red,   0.0,1.0,0.0,1.0,    oParam );
    prop.AddParameter(L"bhor_green", CValue::siFloat, sps, L"", L"", vHor_green, 0.0,1.0,0.0,1.0,    oParam );
    prop.AddParameter(L"bhor_blue",  CValue::siFloat, sps, L"", L"", vHor_blue,  0.0,1.0,0.0,1.0,    oParam );
    prop.AddParameter(L"bhor_alpha", CValue::siFloat, sps, L"", L"", vHor_alpha, 0.0,1.0,0.0,1.0,    oParam );

    //----/ gradient /----/ zenit /----/ color /------->
    prop.AddParameter( L"bzen_red",   CValue::siFloat, sps, L"", L"", vZen_red,		0.0,1.0,0.0,1.0,    oParam );
    prop.AddParameter( L"bzen_green", CValue::siFloat, sps, L"", L"", vZen_green,	0.0,1.0,0.0,1.0,	oParam );
    prop.AddParameter( L"bzen_blue",  CValue::siFloat, sps, L"", L"", vZen_blue,	0.0,1.0,0.0,1.0,    oParam );
    prop.AddParameter( L"bzen_alpha", CValue::siFloat, sps, L"", L"", vZen_alpha,	0.0,1.0,0.0,1.0,	oParam );

    //----/ gradient /----/ horizont ground /----/ color /---->
    prop.AddParameter( L"bhorgro_red",      CValue::siFloat, sps, L"", L"", vHorgro_red,	0.0,1.0,0.0,1.0,    oParam );
    prop.AddParameter( L"bhorgro_green",    CValue::siFloat, sps, L"", L"", vHorgro_green,	0.0,1.0,0.0,1.0,    oParam );
    prop.AddParameter( L"bhorgro_blue",     CValue::siFloat, sps, L"", L"", vHorgro_blue,	0.0,1.0,0.0,1.0,    oParam );
    prop.AddParameter( L"bhorgro_alpha",    CValue::siFloat, sps, L"", L"", vHorgro_alpha,	0.0,1.0,0.0,1.0,    oParam );

    //----/gradient /----/ zenit ground /----/ color /---->
    prop.AddParameter( L"bzengro_red",      CValue::siFloat, sps, L"", L"", vZengro_red,    0.0,1.0,0.0,1.0,    oParam );
    prop.AddParameter( L"bzengro_green",    CValue::siFloat, sps, L"", L"", vZengro_green,  0.0,1.0,0.0,1.0,    oParam );
    prop.AddParameter( L"bzengro_blue",     CValue::siFloat, sps, L"", L"", vZengro_blue,   0.0,1.0,0.0,1.0,    oParam );
    prop.AddParameter( L"bzengro_alpha",    CValue::siFloat, sps, L"", L"", vZengro_alpha,  0.0,1.0,0.0,1.0,    oParam );

    //----/ sunsky - DarkTide/----------->
    prop.AddParameter( L"bturbidity",   CValue::siFloat, sps, L"", L"", vTurbidity,   1,20,1,20,      oParam );
    prop.AddParameter( L"bA_horbright", CValue::siFloat, sps, L"", L"", vHorbright,   0,10,0,10,      oParam );
    prop.AddParameter( L"bB_horsprd",   CValue::siFloat, sps, L"", L"", vHorsprd,     0,10,0,10,      oParam );
    prop.AddParameter( L"bC_sunbright", CValue::siFloat, sps, L"", L"", vSunbright,   0,10,0,10,      oParam );
    prop.AddParameter( L"bD_sunsize",   CValue::siFloat, sps, L"", L"", vSunsize,     0,10,0,10,      oParam );
    prop.AddParameter( L"bE_backlight", CValue::siFloat, sps, L"", L"", vBacklight,   0,10,0,10,      oParam );
    
    prop.AddParameter( L"bx_vect",      CValue::siFloat, sps, L"", L"", vXvect,       0,1,0,1,        oParam );
    prop.AddParameter( L"by_vect",      CValue::siFloat, sps, L"", L"", vYvect,       0,1,0,1,        oParam );
    prop.AddParameter( L"bz_vect",      CValue::siFloat, sps, L"", L"", vZvect,       0,1,0,1,        oParam );
    
    prop.AddParameter( L"bfrom_angle",  CValue::siBool,  sps, L"", L"", vFrom_angle,	dft,dft,dft,dft,	oParam );
    prop.AddParameter( L"bfrom_pos",    CValue::siBool,  sps, L"", L"", vFrom_pos,	    dft,dft,dft,dft,	oParam );
    prop.AddParameter( L"bfrom_update", CValue::siBool,  sps, L"", L"", vFrom_update,	dft,dft,dft,dft,	oParam );
    //--
    prop.AddParameter( L"b_dsnight",    CValue::siBool,  sps, L"", L"", vdsnight,       dft,dft,dft,dft,    oParam );
    prop.AddParameter( L"b_dsaltitude", CValue::siFloat, sps, L"", L"", vdsaltitude,	-1.0,2.0,0.0,1.0,	oParam );
    
    prop.AddParameter( L"badd_sun",       CValue::siBool,  sps, L"", L"", vAdd_sun,		dft,dft,dft,dft,	oParam );
    prop.AddParameter( L"bsun_power",     CValue::siFloat, sps, L"", L"", vSun_power,   1,10,1,10,		    oParam );
    prop.AddParameter( L"bskylight",      CValue::siBool,  sps, L"", L"", vSkylight,	dft,dft,dft,dft,    oParam );
    prop.AddParameter( L"bsky_power",     CValue::siFloat, sps, L"", L"", vSky_power,   1,10,1,10,		    oParam );
    //
    prop.AddParameter( L"b_exposure",     CValue::siFloat, sps, L"", L"", vexposure,	0.0,1.0,0.1,1.0,	oParam );
    prop.AddParameter( L"b_dsbright",     CValue::siFloat, sps, L"", L"", vdsbright,	0.0,10.0,0.1,10.0,	oParam );
    prop.AddParameter( L"bw_samples",     CValue::siInt4,  sps, L"", L"", vW_samples,	1,512,1,512,        oParam );
    
    prop.AddParameter( L"b_clamp_rgb",    CValue::siBool,  sps, L"", L"", vclamp_rgb,	dft,dft,dft,dft,    oParam );
    prop.AddParameter( L"b_gamma_enc",    CValue::siBool,  sps, L"", L"", vgamma_enc,	dft,dft,dft,dft,    oParam );
    prop.AddParameter( L"b_colorspace",   CValue::siInt2,  sps, L"", L"", vcolorspace,	0,5,0,5,            oParam );
    //-- DarkTide
    
    //----/ lighting  /------>
    prop.AddParameter(L"blighting",     CValue::siInt4, sps,L"",L"", vLighting,    0,5,0,5, oParam);
    
    //----/ volume integrator /-------->
    prop.AddParameter( L"bVintegrator", CValue::siInt4,  sps,L"",L"",    vIntegrator,   0,10,0,10,       oParam);
    prop.AddParameter( L"bstep_size",   CValue::siFloat, sps,L"",L"",    vStep_size,    0.1,100.0,1.0,100.0,     oParam);
    prop.AddParameter( L"badaptive",    CValue::siBool,  sps,L"",L"",    vAdaptive,     dft,dft,dft,dft, oParam);
    prop.AddParameter( L"boptimize",    CValue::siBool,  sps,L"",L"",    vOptimize,     dft,dft,dft,dft, oParam);
    prop.AddParameter( L"batt_grid",    CValue::siInt4,  sps,L"",L"",    vAtt_grid,     1,50,1,50,       oParam);

    //-- set default paths
	// test for use vfile_out_xml ( vfileObjects )
    vfile_out_xml  = app.GetInstallationPath(siProjectPath);   //- for export to .xml file ( scene or material ( future..))
    vfile_out_xml  += L"/yafaray.xml";                         //- default name for exported .xml file  
    //-
    vYafXSIPath   = app.GetInstallationPath(siUserAddonPath); //- path to yafaray-xml.exe
    vYafXSIPath   += L"/YafaRay/Application/bin/";
    //-
    vplugin_path  = app.GetInstallationPath(siUserAddonPath); //- path to plugins folder
    vplugin_path  += L"/YafaRay/Application/bin/plugins";
    //-
    vsave_image   = app.GetInstallationPath(siProjectPath);   //- path to save image for re-render .xml file
    vsave_image   += L"/Render_Pictures";
	//-
    vselect_file  = app.GetInstallationPath(siProjectPath);   //- path to select .xml file for re-render
    
    //-- add CustomProperty for filepath
	prop.AddParameter( L"bselect_file",  CValue::siString, sps, L"",L"",   vselect_file,   oParam );
	prop.AddParameter( L"fObjects",      CValue::siString, sps, L"", L"",  vfile_out_xml,   oParam ); // vfile_out_xml,  oParam );
	prop.AddParameter( L"bYafPath",      CValue::siString, sps, L"", L"",  vYafXSIPath,    oParam );
    prop.AddParameter( L"bsave_image",   CValue::siString, sps, L"",L"",   vsave_image,    oParam );
    prop.AddParameter( L"bplugin_path",  CValue::siString, sps, L"", L"",  vplugin_path,   oParam );

    return CStatus::OK;
}
//--
XSIPLUGINCALLBACK CStatus YafaRayRenderer_PPGEvent( const CRef& in_ctxt )
{
    //--
    PPGEventContext ctxt( in_ctxt ) ;
    PPGEventContext::PPGEvent eventID = ctxt.GetEventID();
    CustomProperty prop = ctxt.GetSource() ; 

    if ( eventID == PPGEventContext::siOnInit )
    {
        params = prop.GetParameters();
        //-- Update values on init
        for (int i=0; i<params.GetCount(); i++)
        {
            Parameter changed = ctxt.GetSource();
            Parameter param(params[i]);
            yafaray_update_values(param.GetScriptName(), param, ctxt );
        }
        ctxt.PutAttribute(L"Refresh",true);
    }
    else if ( eventID == PPGEventContext::siOnClosed )
    {
        // This event meant that the UI was just closed by the user.
		// For this event Source() of the event is the CustomProperty object
		app.LogMessage( L"OnClosed called for " + prop.GetFullName() ) ;
	}
    else if ( eventID == PPGEventContext::siButtonClicked )
    {
        CValue buttonPressed = ctxt.GetAttribute( L"Button" ) ;
        //-- render loaded XML file
        if (buttonPressed.GetAsText() == L"bre_render")
        {
            //--
            vre_render = true;
		    yafaray_execute();
        }
        //-- and view image
        if (buttonPressed.GetAsText() == L"bopen_image")
        {
            //--
            open_image_render();
        }
        //--
        if (buttonPressed.GetAsText() == L"export_xml")
        {
            //out_type = "xml_file";
            // mat_preview = false;
            //--
            yaf_xml();
        }
        if (buttonPressed.GetAsText() == L"render_qtgui")
        {
            out_type = "gui";
            mat_preview = false;
            //--
            yaf_export(); 
        }
        //--
        if (buttonPressed.GetAsText() == L"bpreview")
        {
            //-- test for preview materials..
            out_type = "gui";
            mat_preview = true;
            //--
            yaf_preview();
        }
        if (buttonPressed.GetAsText() == L"bwritexml")
        {
            //-- test for export preview materials.. 
            out_type = "xml_file";
            mat_preview = true;
            //--
            yaf_preview();
        }
        //--
        if ( buttonPressed.GetAsText() == L"Done" )
        {
            // See the scripting documentation for PPG.Close for more info about this technique.
			// Self destruct the property page
            CValueArray args( 1 ) ; 
			args[0] = prop ;
			CValue retval ;
			app.ExecuteCommand( L"DeleteObj", args, retval ) ;

			// Tell the context that we want the the property page closed
			ctxt.PutAttribute( L"Close", true ) ;
        }
        ctxt.PutAttribute(L"Refresh",true);
    }
    else if ( eventID == PPGEventContext::siTabChange )
    {
        CValue tabLabel = ctxt.GetAttribute( L"Tab" ) ;
    }
    else if ( eventID == PPGEventContext::siParameterChange )
    {
        Parameter changed = ctxt.GetSource();
        //CustomProperty prop = changed.GetParent() ;
        prop = changed.GetParent() ;
        CString paramName = changed.GetScriptName() ;
        yafaray_update_values(paramName, changed, ctxt);
        //--
    }

    return CStatus::OK ;
}
//--
XSIPLUGINCALLBACK CStatus YafaRayRenderer_Init( CRef& in_ctxt )
{
    Context ctxt( in_ctxt );
    Menu oMenu;
    oMenu = ctxt.GetSource();
    MenuItem oNewItem;
    oMenu.AddCallbackItem(L"YafaRay Renderer",L"OnYafaRayRenderer_MenuClicked",oNewItem);
    return CStatus::OK;
}
//--
XSIPLUGINCALLBACK CStatus OnYafaRayRenderer_MenuClicked( XSI::CRef& )
{
    //--
    Application app;
    CValueArray addpropArgs(5) ;
    addpropArgs[0] = L"YafaRay Renderer"; // Type of Property
    addpropArgs[3] = L"YafaRay Renderer"; // Name for the Property
    addpropArgs[1] = L"Scene_Root";
    bool vAlreadyThere=false;
    CValue retVal ;
    CStatus st;

    // search for existing interface
    CRefArray vItems = app.GetActiveSceneRoot().GetProperties();
    for (int i=0;i<vItems.GetCount();i++){
        if (SIObject(vItems[i]).GetType()==L"YafaRay Renderer") {
            vAlreadyThere=true;
            st = true;
            break;
        }
    }

    if (!vAlreadyThere){
        st = app.ExecuteCommand( L"SIAddProp", addpropArgs, retVal ) ;
    }

    if ( st.Succeeded() )
    {
        CValueArray args(5) ;

        args[0] = prop ;
        args[2] = "YafaRay Renderer";
        args[3] = siLock;
        args[4] = false;

        app.ExecuteCommand( L"InspectObj", args, retVal ) ;
    }

    return st ;
}
//--
CVector3 convertMatrix(CVector3 v){
    CMatrix3 m2(1.0,0.0,0.0, 0.0,1.0,0.0, 0.0,0.0,1.0);
    return v.MulByMatrix3InPlace (m2);
}
//--
void yafaray_update_values(CString paramName, Parameter changed, PPGEventContext ctxt )
{
    //-- preview mat bselect_file
    if (paramName == L"bselect_file") vselect_file = changed.GetValue();
    if (paramName == L"btype_geo")    vtype_geo    = changed.GetValue();
    if (paramName == L"bsavefile")    vSavefile    = changed.GetValue();
   
    if (paramName == L"blighting")  {   vLighting = changed.GetValue();
    yafaray_dynamic_tab_lighting(changed, ctxt);

    } else if (paramName == L"bDLCphotons")      { vDLCphotons       = changed.GetValue();
    } else if (paramName == L"bDLcaustic_mix")   { vDLCaustic_mix    = changed.GetValue();
    } else if (paramName == L"bcaustic_depth")   { vDLCaust_depth    = changed.GetValue();
    } else if (paramName == L"bDLcaust_radius")  { vCaust_radius     = changed.GetValue();
    } else if (paramName == L"bcaustics")        { vUseCaust         = changed.GetValue();//------>
    yafaray_dynamic_tab_lighting(changed, ctxt);
    
    //-- AO 
    } else if (paramName == L"bUse_AO") { vUse_AO   = changed.GetValue(); //------>
    yafaray_dynamic_tab_lighting(changed, ctxt);

    } else if (paramName == L"bao_samples")      { vAO_samples   = changed.GetValue();
    } else if (paramName == L"bao_distance")     { vAO_distance  = changed.GetValue();
    } else if (paramName == L"AOc_red")          { vAOc_red      = changed.GetValue();
    } else if (paramName == L"AOc_green")        { vAOc_green    = changed.GetValue();
    } else if (paramName == L"AOc_blue")         { vAOc_blue     = changed.GetValue();
    } else if (paramName == L"AOc_alpha")        { vAOc_alpha    = changed.GetValue();

    //-- photon mapping settings
    } else if (paramName == L"bdepth")           { vDepth         = changed.GetValue();
    } else if (paramName == L"bdiff_photons")    { vPMDphotons    = changed.GetValue();
    } else if (paramName == L"bcaust_photons")   { vPMCphotons    = changed.GetValue();
    } else if (paramName == L"bdiff_radius")     { vDiff_radius    = changed.GetValue();
    } else if (paramName == L"bcaust_radius")    { vCausticRadius  = changed.GetValue();
    } else if (paramName == L"bsearch")          { vSearch         = changed.GetValue();
    } else if (paramName == L"bcaustic_mix")     { vCaustic_mix    = changed.GetValue();
    } else if (paramName == L"bfinal_gather")    { vFinal_gather   = changed.GetValue(); //--------->
    yafaray_dynamic_tab_lighting(changed, ctxt);

    } else if (paramName == L"bfg_bounces")      { vFg_bounces     = changed.GetValue();
    } else if (paramName == L"bfg_samples")      { vFg_samples     = changed.GetValue();
    } else if (paramName == L"bshow_map")        { vShow_map       = changed.GetValue();

    //-- pathtracing
    } else if (paramName == L"bpathcaus_photons") { vPTCphotons     = changed.GetValue();
    } else if (paramName == L"bpathcaus_mix")     { vPTCaustic_mix  = changed.GetValue();
    } else if (paramName == L"bpathcaus_depth")   { vCaustic_depth  = changed.GetValue();
    } else if (paramName == L"bpathcaus_radius")  { vPTCaust_radius = changed.GetValue();
    } else if (paramName == L"bpath_depth")       { vPath_depth     = changed.GetValue();
    } else if (paramName == L"bpath_samples")     { vPath_samples   = changed.GetValue();
    } else if (paramName == L"bno_recursion")     { vNo_recursion   = changed.GetValue();
    } else if (paramName == L"buseback")          { vUse_backg      = changed.GetValue();
    } else if (paramName == L"tracer_method")     { vTracer_method  = changed.GetValue(); //-------->
    yafaray_dynamic_tab_lighting(changed, ctxt);

    //-- SPPM
    } else if (paramName == L"bspphotons")          { vspphotons       = changed.GetValue();
    } else if (paramName == L"bsppassNums")         { vsppassNums      = changed.GetValue();
    } else if (paramName == L"bspbounces")          { vspbounces       = changed.GetValue();
    } else if (paramName == L"bspdiffuseRadius")    { vspdiffuseRadius = changed.GetValue();
    } else if (paramName == L"bspsearch")           { vspsearch        = changed.GetValue();
    } else if (paramName == L"bsptimes")            { vsptimes         = changed.GetValue();
    } else if (paramName == L"bsppmIRE")            { vsppmIRE         = changed.GetValue();

    //- debug
    } else if (paramName == L"bdebug_method")       { vdebug_method     = changed.GetValue();
    } else if (paramName == L"bshowPN")             { vshowPN           = changed.GetValue();
    }
    else
    { 
       // app.LogMessage(L" End update 'Lighting' values"); 
        //-- warning; many recursive options
    }

    //-- general settings; not dynamic UI, atm...
    if (paramName == L"braydepth")        { vRaydepth = changed.GetValue();
    } else if (paramName == L"btransp_shadows")  { vTransp_shad     = changed.GetValue();
    } else if (paramName == L"bclay")            { vClay_render     = changed.GetValue();
	} else if (paramName == L"bclay_red")        { vclay_red		= changed.GetValue();
	} else if (paramName == L"bclay_green")      { vclay_green      = changed.GetValue();
	} else if (paramName == L"bclay_blue")       { vclay_blue       = changed.GetValue();
    } else if (paramName == L"bshadows_depth")   { vShadows_depth   = changed.GetValue();
    } else if (paramName == L"bauto_thread")     { vAuto_thread     = changed.GetValue();
    } else if (paramName == L"bz_buffer")        { vZ_buffer        = changed.GetValue();
    } else if (paramName == L"bthreads")         { vThreads         = changed.GetValue();
    //-- gui mode
    } else if (paramName == L"bshowpix")         { vshowpix     = changed.GetValue();
    } else if (paramName == L"btileorder")       { vtileorder   = changed.GetValue();
    } else if (paramName == L"btilesize")        { vtilesize    = changed.GetValue();

    //-- output 
    } else if (paramName == L"gamma")            { vContrast    = changed.GetValue();
    } else if (paramName == L"bgamma_in")        { vcontrast_in = changed.GetValue();
    } else if (paramName == L"bclamp_rgb")       { vClamp_rgb   = changed.GetValue();
    } else if (paramName == L"bpremu_alpha")     { vPremu_alpha = changed.GetValue();

    //-- output method
    } else if (paramName == L"bdraw_render")    { vDraw_render      = changed.GetValue();
    } else if (paramName == L"bcustom_string")  { vCustom_string    = changed.GetValue();

	//-- AA settings
    } else if (paramName == L"baa_passes")      { vAA_passes     = changed.GetValue();
    } else if (paramName == L"baa_samples")     { vAA_samples    = changed.GetValue();
    } else if (paramName == L"baa_threshold")   { vAA_threshold  = changed.GetValue();
    } else if (paramName == L"baa_inc")         { vAA_inc        = changed.GetValue();
    } else if (paramName == L"baa_pixel")       { vAA_pixel      = changed.GetValue();
    } else if (paramName == L"baa_modes")       { vFilter_type   = changed.GetValue();
    }
    else
    {
        //app.LogMessage(L" End update [ General settings ] values");
    }
    //-- setworld 
    if (paramName == L"setworld")   { vSetworl  = changed.GetValue(); //----------->
    //--
    yafaray_dynamic_tab_world(changed, ctxt);

    //-- single color 
    } else if (paramName == L"bsc_red")     { vBack_red     = changed.GetValue();
    } else if (paramName == L"bsc_green")   { vBack_green   = changed.GetValue();
    } else if (paramName == L"bsc_blue")    { vBack_blue    = changed.GetValue();
    } else if (paramName == L"bsc_alpha")   { vBack_alpha   = changed.GetValue();

    //-- gradient; horizont 
    } else if (paramName == L"bhor_red")    { vHor_red      = changed.GetValue();
    } else if (paramName == L"bhor_green")  { vHor_green    = changed.GetValue();
    } else if (paramName == L"bhor_blue")   { vHor_blue     = changed.GetValue();
    } else if (paramName == L"bhor_alpha")  { vHor_alpha    = changed.GetValue();

    //-- gradient; zenit
    } else if (paramName == L"bzen_red")    { vZen_red   = changed.GetValue();
    } else if (paramName == L"bzen_green")  { vZen_green = changed.GetValue();
    } else if (paramName == L"bzen_blue")   { vZen_blue  = changed.GetValue();
    } else if (paramName == L"bzen_alpha")  { vZen_alpha = changed.GetValue();

    //----/ gradient /----/ horizont ground /---->
    } else if (paramName == L"bhorgro_red")   { vHorgro_red   = changed.GetValue();
    } else if (paramName == L"bhorgro_green") { vHorgro_green = changed.GetValue();
    } else if (paramName == L"bhorgro_blue")  { vHorgro_blue  = changed.GetValue();
    } else if (paramName == L"bhorgro_alpha") { vHorgro_alpha = changed.GetValue();

    //----/ gradient /----/ zenit ground /---->
    } else if (paramName == L"bzengro_red")   { vZengro_red   = changed.GetValue();
    } else if (paramName == L"bzengro_green") { vZengro_green = changed.GetValue();
    } else if (paramName == L"bzengro_blue")  { vZengro_blue  = changed.GetValue();
    } else if (paramName == L"bzengro_alpha") { vZengro_alpha = changed.GetValue();

    //----/ texture /---> 
    } else if (paramName == L"bHDRI")         { vHDRI       = changed.GetValue();
    } else if (paramName == L"t_exposure")    { vtexposure  = changed.GetValue();
    } else if (paramName == L"binterp")       { vUse_interp = changed.GetValue();
    } else if (paramName == L"brotation")     { vrotation   = changed.GetValue();
    } else if (paramName == L"bmapworld")     { vmapworld   = changed.GetValue();
    } else if (paramName == L"bw_caust")      { vW_caust    = changed.GetValue();
    } else if (paramName == L"bw_diff")       { vW_diff     = changed.GetValue();

    //----/ sunsky /--------->
    } else if (paramName == L"bturbidity")   { vTurbidity    = changed.GetValue();
    } else if (paramName == L"bA_horbright") { vHorbright    = changed.GetValue();
    } else if (paramName == L"bB_horsprd")   { vHorsprd      = changed.GetValue();
    } else if (paramName == L"bC_sunbright") { vSunbright    = changed.GetValue();
    } else if (paramName == L"bD_sunsize")   { vSunsize      = changed.GetValue();
    } else if (paramName == L"bE_backlight") { vBacklight    = changed.GetValue();
    } else if (paramName == L"bfrom_angle")  { vFrom_angle   = changed.GetValue();
    } else if (paramName == L"bx_vect")      { vXvect        = changed.GetValue();
    } else if (paramName == L"bfrom_pos")    { vFrom_pos     = changed.GetValue();
    } else if (paramName == L"by_vect")      { vYvect        = changed.GetValue();
    } else if (paramName == L"bfrom_update") { vFrom_update  = changed.GetValue();
    } else if (paramName == L"bz_vect")      { vZvect        = changed.GetValue();

    } else if (paramName == L"b_dsnight")    { vdsnight      = changed.GetValue();
    } else if (paramName == L"b_dsaltitude") { vdsaltitude   = changed.GetValue();
    
    } else if (paramName == L"badd_sun")     { vAdd_sun      = changed.GetValue();
    yafaray_dynamic_tab_world(changed, ctxt); //---------------->
    } else if (paramName == L"bsun_power")   { vSun_power    = changed.GetValue();

    } else if (paramName == L"bskylight")    { vSkylight     = changed.GetValue();
    yafaray_dynamic_tab_world(changed, ctxt); //----------------> 
    } else if (paramName == L"bsky_power")   { vSky_power    = changed.GetValue();
    
    } else if (paramName == L"b_exposure")   { vexposure     = changed.GetValue();
    } else if (paramName == L"b_dsbright")   { vdsbright     = changed.GetValue();
    } else if (paramName == L"bw_samples")   { vW_samples    = changed.GetValue();
    } else if (paramName == L"b_clamp_rgb")  { vclamp_rgb    = changed.GetValue();
    } else if (paramName == L"b_gamma_enc")  { vgamma_enc    = changed.GetValue();
    } else if (paramName == L"b_colorspace") { vcolorspace   = changed.GetValue();
    
    //--- IBL
    } else if (paramName == L"buse_ibl")     { vUse_ibl      = changed.GetValue(); //------>
    yafaray_dynamic_tab_world(changed, ctxt);

    } else if (paramName == L"bibl_power")   { vIbl_power    = changed.GetValue();
    } else if (paramName == L"bibl_samples") { vIbl_samples  = changed.GetValue();
    } else {
       // app.LogMessage(L" End update 'World' values");
    }

    //-- vol. integrator 
    if (paramName == L"bVintegrator")  { vIntegrator  = changed.GetValue();
    //--
    yafaray_dynamic_tab_vintegrator(changed, ctxt);

    } else if (paramName == L"bstep_size")  { vStep_size  = changed.GetValue();
    } else if (paramName == L"badaptive")   { vAdaptive   = changed.GetValue();
    } else if (paramName == L"boptimize")   { vOptimize   = changed.GetValue();
    //--
    yafaray_dynamic_tab_vintegrator(changed, ctxt);

    } else if (paramName == L"batt_grid")   { vAtt_grid    = changed.GetValue();
    // } else {
       // app.LogMessage(L" End update 'World' values");
    }
    //--- hidden options
    if (paramName == L"use_hidden_obj")         { vIsHiddenObj      = changed.GetValue();
    } else if (paramName == L"use_hidden_surf") { vIsHiddenSurfaces = changed.GetValue();
    } else if (paramName == L"bhiddenclouds")   { vIsHiddenClouds   = changed.GetValue();
    } else if (paramName == L"use_hidden_cam")  { vIsHiddenCam      = changed.GetValue();
    } else if (paramName == L"bhidden_light")   { vIsHiddenLight    = changed.GetValue();
    } else if (paramName == L"smooth_mesh")     { vSmooth_mesh      = changed.GetValue();
    //-- paths
    } else if (paramName == L"fObjects")        { vfile_out_xml      = changed.GetValue();
    } else if (paramName == L"bplugin_path")    { vplugin_path      = changed.GetValue();

    //-- Image
    } else if (paramName == L"Width")   { vXRes     = changed.GetValue();
    } else if (paramName == L"Height")  { vYRes     = changed.GetValue();

    }
}
//--
void yafaray_dynamic_tab_lighting( Parameter changed, PPGEventContext ctxt)
{
    //--
    CustomProperty prop = changed.GetParent() ;
    //-- create array for all params with lighting modes..
    const char *pLight[]={"bDLCphotons", "bDLcaustic_mix", "bcaustic_depth", "bDLcaust_radius",
        "bao_samples", "bao_distance", "AOc_red", "bcaustics", "bUse_AO", "bdepth", "bdiff_photons",
        "bcaust_photons", "bdiff_radius", "bcaust_radius", "bsearch", "bcaustic_mix", "bfinal_gather",
        "bfg_bounces", "bfg_samples", "bshow_map", "tracer_method", "bpathcaus_photons", "bpathcaus_mix",
        "bpathcaus_depth", "bpathcaus_radius", "bpath_depth", "bpath_samples", "bno_recursion", "buseback",
        "bspphotons", "bsppassNums", "bspbounces", "bspdiffuseRadius", "bspsearch", "bsptimes", "bsppmIRE",
        "bdebug_method", "bshowPN"}; 
    
	//-- ...and create loop for hidden all..
    for ( long xp = 0; xp < 38;)
    {
        Parameter(params.GetItem(pLight[xp])).PutCapabilityFlag( siNotInspectable, true );
        xp++;
    }
    //-- show params for each mode 
	//-------------------
    if ( vLighting == 0 ) 
	//-------------------
    {
        const char *dl_noinsp[]={"bcaustics", "bUse_AO", "bao_samples", "bao_distance", "AOc_red",
            "bDLCphotons", "bcaustic_depth", "bDLcaust_radius", "bDLcaustic_mix"};
		for ( long dlv = 0; dlv < 9;)
        { 
            Parameter(params.GetItem(dl_noinsp[dlv])).PutCapabilityFlag( siNotInspectable, false );
            dlv++;
        }
		//--
		const char *dl_noreadUI[]={"bao_samples", "bao_distance", "AOc_red", "bDLCphotons",
            "bcaustic_depth", "bDLcaust_radius", "bDLcaustic_mix"};
		for ( long dln = 0; dln < 7;)
		{	
            Parameter(params.GetItem(dl_noreadUI[dln])).PutCapabilityFlag( siReadOnly, true );
            dln++;
        }
        //--
        if ( vUse_AO )
        {
            Parameter(params.GetItem(L"bao_samples")).PutCapabilityFlag( siReadOnly, false );
            Parameter(params.GetItem(L"bao_distance")).PutCapabilityFlag( siReadOnly, false );
            Parameter(params.GetItem(L"AOc_red")).PutCapabilityFlag( siReadOnly, false );
        }
        if ( vUseCaust )
        {
            Parameter(params.GetItem(L"bDLCphotons")).PutCapabilityFlag( siReadOnly, false );
            Parameter(params.GetItem(L"bcaustic_depth")).PutCapabilityFlag( siReadOnly, false );
            Parameter(params.GetItem(L"bDLcaust_radius")).PutCapabilityFlag( siReadOnly, false );
            Parameter(params.GetItem(L"bDLcaustic_mix")).PutCapabilityFlag( siReadOnly, false );
        }
        ctxt.PutAttribute(L"Refresh", true );
    }
	//------------------------ 
    else if ( vLighting == 1 ) 
	//------------------------
    {
		//- test; use loop for show all photonmap items  ..
        const char *inspUI[11]={"bdepth", "bdiff_photons", "bcaust_photons", "bdiff_radius", "bcaust_radius",
			"bsearch", "bcaustic_mix", "bfinal_gather", "bfg_bounces", "bfg_samples", "bshow_map"};
        //--
        for (long vi = 0; vi < 11;)
        {
            Parameter(params.GetItem(inspUI[vi])).PutCapabilityFlag( siNotInspectable, false);
            vi++;
        }
        //-- .. and turned readonly some items
        const char *readUI[]={"bfg_bounces", "bfg_samples", "bshow_map"};
        for (long nr = 0; nr < 3;)
        {
            Parameter(params.GetItem(readUI[nr])).PutCapabilityFlag( siReadOnly, true);
            nr++;
        }
        //--
        if ( vFinal_gather )
        {
            Parameter(params.GetItem(L"bfg_bounces")).PutCapabilityFlag( siReadOnly, false );
            Parameter(params.GetItem(L"bfg_samples")).PutCapabilityFlag( siReadOnly, false );
            Parameter(params.GetItem(L"bshow_map")).PutCapabilityFlag( siReadOnly, false );
        }
        ctxt.PutAttribute(L"Refresh", true );
    }
	//------------------------ 
    else if ( vLighting == 2 ) 
	//------------------------
    {
		//-- pathtracing
        Parameter(params.GetItem(L"tracer_method")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"bpath_depth")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"bpath_samples")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"bno_recursion")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"buseback")).PutCapabilityFlag( siNotInspectable, false );
        //--
        if ( vTracer_method > 1 ) //-- path + photon
        {
            Parameter(params.GetItem(L"bpathcaus_photons")).PutCapabilityFlag( siNotInspectable, false );
            Parameter(params.GetItem(L"bpathcaus_mix")).PutCapabilityFlag( siNotInspectable,  false );
            Parameter(params.GetItem(L"bpathcaus_depth")).PutCapabilityFlag( siNotInspectable,  false );
            Parameter(params.GetItem(L"bpathcaus_radius")).PutCapabilityFlag( siNotInspectable,  false );
        }
        ctxt.PutAttribute(L"Refresh", true );
    }
	//------------------------ bidirecctional
    else if ( vLighting == 3 )
	//------------------------
    {
        ctxt.PutAttribute(L"Refresh", true );
    }
    else if ( vLighting == 4 ) //-- SPPM
    {
        Parameter(params.GetItem(L"bspphotons")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"bsppassNums")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"bspbounces")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"bspdiffuseRadius")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"bspsearch")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"bsptimes")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"bsppmIRE")).PutCapabilityFlag( siNotInspectable, false );
        //--
        ctxt.PutAttribute(L"Refresh", true );
    }
    else // debug integrator
    {
         Parameter(params.GetItem(L"bdebug_method")).PutCapabilityFlag( siNotInspectable, false );
         Parameter(params.GetItem(L"bshowPN")).PutCapabilityFlag( siNotInspectable, false );
    }
}
//--
void yafaray_dynamic_tab_world(Parameter changed, PPGEventContext ctxt)
{
    //-- create array and loop, for hidden all params
    const char *ui_world [39] = {"bsc_red", "bhor_red", "bzen_red", "bhorgro_red", "bzengro_red",
        "bHDRI", "binterp", "t_exposure", "brotation", "bmapworld", "bw_caust", "bw_diff", "bturbidity",
        "bA_horbright", "bB_horsprd", "bC_sunbright", "bD_sunsize", "bE_backlight", "bfrom_angle",
        "bx_vect", "bfrom_pos", "by_vect", "bfrom_update", "bz_vect", "badd_sun", "bsun_power", "bskylight",
        "bsky_power", "bw_samples", "buse_ibl", "bibl_power", "bibl_samples", /* 31*/
        "b_dsnight", "b_dsaltitude", "b_exposure", "b_dsbright", "b_clamp_rgb", "b_gamma_enc", "b_colorspace" };
    
    //-- loop
    for ( long w = 0; w < 39;)
    {
        Parameter(params.GetItem(ui_world[w])).PutCapabilityFlag( siNotInspectable, true ); 
        w++; 
    }

    //- specials cases: case IBL
    if ( vSetworl < 3 )
    {
        Parameter(params.GetItem(L"bibl_power")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"bibl_power")).PutCapabilityFlag( siReadOnly, true );
        Parameter(params.GetItem(L"bibl_samples")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"bibl_samples")).PutCapabilityFlag( siReadOnly, true );
        //--
        if ( vUse_ibl )
        {
            Parameter(params.GetItem(L"bibl_power")).PutCapabilityFlag( siReadOnly, false );
            Parameter(params.GetItem(L"bibl_samples")).PutCapabilityFlag( siReadOnly, false );
        }
        ctxt.PutAttribute(L"Refresh", true);
    }
    //-- specials cases: case Background influence
    if ( vSetworl == 2 || vSetworl == 4 )
    {
        //--
        Parameter(params.GetItem(L"bw_caust")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"bw_caust")).PutCapabilityFlag( siReadOnly, true );
        Parameter(params.GetItem(L"bw_diff")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"bw_diff")).PutCapabilityFlag( siReadOnly, true );
    }

    //------------------ 
    if ( vSetworl == 1 ) //-- gradient
	//------------------
    {
        Parameter(params.GetItem(L"bhor_red")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"bzen_red")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"bhorgro_red")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"bzengro_red")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"buse_ibl")).PutCapabilityFlag( siNotInspectable, false );
        //--
        ctxt.PutAttribute(L"Refresh", true);
    }
	//----------------------- 
    else if ( vSetworl == 2 ) //-- texture 
	//-----------------------
    {
        const char *wt_back[]={"bHDRI", "binterp", "t_exposure", "brotation", "buse_ibl", "bmapworld"};
        //-
        for( long wtb = 0; wtb < 6; )
        {
            Parameter(params.GetItem(wt_back[wtb])).PutCapabilityFlag( siNotInspectable, false );
            wtb++;
        }
        //-
        if (vUse_ibl)
        {
            Parameter(params.GetItem(L"bw_caust")).PutCapabilityFlag( siReadOnly, false );
            Parameter(params.GetItem(L"bw_diff")).PutCapabilityFlag( siReadOnly, false );
        }
        ctxt.PutAttribute(L"Refresh", true);
    }
	//---------------------------------------- 
    else if ( vSetworl == 3 || vSetworl == 4 ) //-- Sunsky  and DarkTide Sunsky
	//----------------------------------------
    {
        const char *w_sunsk[]={"bturbidity", "bA_horbright", "bB_horsprd", "bC_sunbright", "bD_sunsize",
            "bE_backlight", "bfrom_angle", "bfrom_update", "bfrom_pos", "badd_sun", "bsun_power", "bskylight",
            "bsky_power", "bw_samples"};  /*"bx_vect", "by_vect", "bz_vect",*/
        //-
		for ( long wsk = 0; wsk < 14;)
		{
            Parameter(params.GetItem(w_sunsk[wsk])).PutCapabilityFlag( siNotInspectable, false ); 
            wsk++; 
        }
        //--
        if ( vAdd_sun ) 
        {
            Parameter(params.GetItem(L"bsun_power")).PutCapabilityFlag( siReadOnly, false );
        }
        if ( vSkylight )
        {
            Parameter(params.GetItem(L"bsky_power")).PutCapabilityFlag( siReadOnly, false );
        }
        //-- darktide sunsky
        if ( vSetworl == 4 )
        {
            const char *w_skdark[]={"b_dsnight", "b_dsaltitude", "b_exposure", "b_dsbright",
                "b_clamp_rgb", "b_gamma_enc", "b_colorspace"};
		    //--
		    for ( long wdk = 0; wdk < 7;)
		    { 
                Parameter(params.GetItem(w_skdark[wdk])).PutCapabilityFlag( siNotInspectable, false );
                wdk++; 
            }
            //--
            if ( vSkylight )
            {
                Parameter(params.GetItem(L"bw_caust")).PutCapabilityFlag( siReadOnly, false );
                Parameter(params.GetItem(L"bw_diff")).PutCapabilityFlag( siReadOnly, false );
            }
        }   
        ctxt.PutAttribute(L"Refresh", true);
    }
	
	//--- color
    else 
	//---
    {
        Parameter(params.GetItem(L"bsc_red")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"buse_ibl")).PutCapabilityFlag( siNotInspectable, false );
        //--
        ctxt.PutAttribute(L"Refresh", true);
    }
}
//--
void yafaray_dynamic_tab_vintegrator(Parameter changed, PPGEventContext ctxt)
{
    //-- params
    const char *volint [4] = {"bstep_size", "badaptive", "boptimize", "batt_grid"};
    for ( long v = 0; v < 4;) 
    {
        Parameter(params.GetItem(volint[v])).PutCapabilityFlag( siNotInspectable, true );
        v++;
    }
    
    //---------------------
    if ( vIntegrator == 1 )
	//---------------------
    {
        Parameter(params.GetItem(L"bstep_size")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"badaptive")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"boptimize")).PutCapabilityFlag( siNotInspectable, false );
        Parameter(params.GetItem(L"batt_grid")).PutCapabilityFlag( siNotInspectable, false );
        //--
        Parameter(params.GetItem(L"batt_grid")).PutCapabilityFlag( siReadOnly, true );
        //-
        if ( vOptimize == true )
        {
            Parameter(params.GetItem(L"batt_grid")).PutCapabilityFlag( siReadOnly, false );
        }
        ctxt.PutAttribute(L"Refresh", true);
    }
	//--
    else
	//--
    {
        //-- only for resize layout
        ctxt.PutAttribute(L"Refresh", true);
    }
}
//--
void yafaray_integrator(yafrayInterface_t *yi)
{
    //-- integrators
    yi->paramsClearAll();
    //-----------------
    if (vLighting == 0)
	//-----------------
    {
        yi->paramsSetString("type", "directlighting");
		yi->paramsSetBool("do_AO", vUse_AO);
        //--
        if (vUse_AO)
        {
            yi->paramsSetInt("AO_samples", vAO_samples);
            yi->paramsSetFloat("AO_distance", vAO_distance);
            yi->paramsSetColor("AO_color", vAOc_red, vAOc_green, vAOc_blue, vAOc_alpha);
        }
        yi->paramsSetBool("caustics", vUseCaust);
        //--
        if (vUseCaust)
        {
            yi->paramsSetInt("photons", vDLCphotons);
            yi->paramsSetInt("caustic_mix", vDLCaustic_mix);
            yi->paramsSetInt("caustic_depth", vCaustic_depth);
            yi->paramsSetFloat("caustic_radius", vCaust_radius);
        }
    }
	//----------------------
    else if (vLighting == 1) //-- photonmap
	//----------------------
    {
        yi->paramsSetInt("bounces", vDepth);
        yi->paramsSetInt("caustic_mix", vCaustic_mix);
        yi->paramsSetInt("photons", vPMDphotons);
        yi->paramsSetInt("cPhotons", vPMCphotons);
        yi->paramsSetFloat("diffuseRadius", vDiff_radius);
        yi->paramsSetFloat("causticRadius", vCausticRadius);
        yi->paramsSetInt("search", vSearch);
        yi->paramsSetBool("finalGather", vFinal_gather); // place here or Yaf used default fg_samples (32)
        //--
        if ( vFinal_gather )
        {
            yi->paramsSetInt("fg_bounces", vFg_bounces);
            yi->paramsSetInt("fg_samples", vFg_samples);
            yi->paramsSetBool("show_map", vShow_map);
        }
        yi->paramsSetString("type", "photonmapping");
    }
	//----------------------
    else if (vLighting == 2) //-- pathtracing
	//----------------------
    {
        //--
        const char *A_method [4] = {"none", "path", "photon", "both" };
        //std::string method(A_method[vTracer_method]);
        //--
        yi->paramsSetInt("bounces", vPath_depth);
        yi->paramsSetBool("no_recursive", vNo_recursion);
        yi->paramsSetInt("path_samples", vPath_samples);
        yi->paramsSetString("caustic_type", A_method[vTracer_method]); //method.c_str());

        if ( vTracer_method > 1 )
        {
            yi->paramsSetInt("photons", vPTCphotons);
            yi->paramsSetInt("caustic_mix", vPTCaustic_mix);
            yi->paramsSetInt("caustic_depth", vCaustic_depth);
            yi->paramsSetFloat("caustic_radius", vPTCaust_radius);
        }
        yi->paramsSetString("type", "pathtracing");
    }
	//-----------------------
    else if ( vLighting == 3)
	//-----------------------
    {
        yi->paramsSetString("type", "bidirectional");
    }
    //----------------------
    else if ( vLighting == 4) //sppm
    {
        yi->paramsSetString("type", "SPPM" );
        yi->paramsSetInt("bounces", vspbounces );
        yi->paramsSetFloat("diffuseRadius", vspdiffuseRadius );
        yi->paramsSetInt("passNums", vsppassNums ); 
        yi->paramsSetInt("photons", vspphotons );
        yi->paramsSetBool("pmIRE", vsppmIRE ); 
        yi->paramsSetInt("search", vspsearch );
        yi->paramsSetFloat("times", vsptimes );
    }
    //----
    else // if ( vLighting == 5 )
	//---
    {
        //------------
        //const char *dbg_type[]={"N", "dPdU", "dPdV", "NU", "NV", "dSdU", "dSdV"};
        //int debugType = vdebug_method;
        //--
        yi->paramsSetString("type", "DebugIntegrator");
        yi->paramsSetInt("debugType", vdebug_method); //dbg_type[vdebug_method]);
        yi->paramsSetBool("showPN", vshowPN);
    }
    //-- commons values
    yi->paramsSetInt("raydepth", vRaydepth);
    yi->paramsSetInt("shadowDepth", vShadows_depth);
    yi->paramsSetBool("transpShad", vTransp_shad);
    //--
    yi->createIntegrator("default");
}
//--
void yafaray_volume_integrator(yafrayInterface_t *yi)    //----/ volume integrator /----->
{
    yi->paramsClearAll();
    //-------------------
    if (vIntegrator == 1)
	//-------------------
    {
        yi->paramsSetString("type", "SingleScatterIntegrator");
        yi->paramsSetFloat("stepSize", vStep_size);
        yi->paramsSetBool("adaptive", vAdaptive);
        yi->paramsSetBool("optimize", vOptimize);
    }
	//---
    else
	//---
    {
        yi->paramsSetString("type", "none");
    }
    yi->createIntegrator("volintegr");
}
//--
void yafaray_write_mapping(yafrayInterface_t *yi, Shader s, string tex_name, string layer_name, string map_name, Texture tex_shader, float factor)
{
	//--
    float red, green, blue, alpha;
	bool is_image = false, is_colored = false; 
    //--
    int n_images(tex_shader.GetImageClips().GetCount()); 
    int proc_textype = tex_shader.GetParameterValue(L"procedural");
    int color_mode = tex_shader.GetParameterValue(L"colormode");// in the future...:) (not implemented yet..)
    //--
    if ( n_images > 0 ) is_image = true;
    if ( is_image || ( proc_textype == 5 && color_mode == 1)) is_colored = true; 
    
    //-------------------
	yi->paramsPushList();
    //-------------------
    
    yi->paramsSetBool("color_input", is_colored);
    s.GetColorParameterValue(L"def_col",red,green,blue,alpha );
    yi->paramsSetColor("def_col", red, green, blue);
    yi->paramsSetFloat("def_val", float(s.GetParameterValue(L"dvar")));
    yi->paramsSetBool("do_color", d_color); 
    yi->paramsSetBool("do_scalar", d_scalar);
	//--
    yi->paramsSetString("element", "shader_node");
    yi->paramsSetString("type", "layer");
    yi->paramsSetString("name", layer_name.c_str());
	yi->paramsSetString("input", map_name.c_str());
    //--
    yi->paramsSetInt("mode", int(s.GetParameterValue(L"bmode")));
	yi->paramsSetBool("stencil", bool(s.GetParameterValue(L"stencil")));
    //--
    bool is_negative = s.GetParameterValue(L"negative");
    if ( factor < 0 )
    {
        factor = factor * -1;
        is_negative = true;
    }
    yi->paramsSetBool("negative", is_negative);
    yi->paramsSetBool("noRGB", bool(s.GetParameterValue(L"nrgb")));

    //! Texture layers is not implemented yet
	// The idea is use 'yafaray_write_layers' for search TextureLayers
    std::string ulayername = ""; 
    if ( ulayername == "")
    {
        if ( d_color )
        {
            s.GetColorParameterValue(L"diffuse_color", red, green, blue, alpha ); // for test, really is color or shader slots..?
            yi->paramsSetColor("upper_color", red, green, blue);
            yi->paramsSetFloat("upper_value", 0);
        }
        else
        {
            yi->paramsSetColor("upper_color", 0, 0, 0, 1); 
            yi->paramsSetFloat("upper_value", 0); // factor no?, search another cases..
        }
    }
    else
    {
        yi->paramsSetString("upper_layer", ulayername.c_str());
    }
    //--
    if ( d_color ) 
    {
        yi->paramsSetFloat("colfac", factor);
    }
    else
    {
        yi->paramsSetFloat("valfac", factor);
    }
    //--
    bool calcAlpha = tex_shader.GetParameterValue(L"calc_alpha");
    bool useAlpha = false; 
    if ( is_image && !calcAlpha )
    {
        useAlpha = tex_shader.GetParameterValue(L"use_alpha");
    }
    yi->paramsSetBool("use_alpha", useAlpha);
    
    //------------------
    yi->paramsEndList(); 
    //------------------

    //- texture coords
    const char *aMap []={"uv", "global", "orco", "window", "normal",
        "reflect", "stick", "stress", "tangent", "transformed"};
    int fMap = tex_shader.GetParameterValue(L"from_map"); //-- for texco value
    
    //-- mapping type
    const char *aType []={"sphere", "cube", "plain", "tube"};
    int map_type = tex_shader.GetParameterValue(L"map_type"); //-- for mapping value

    //-- test for preview materials
    if ( mat_preview )
    {
        fMap = 1; // use global, atm..
        map_type = vtype_geo; 
    }
        
    //-- Transform, translate
    float vOff_x = tex_shader.GetParameterValue(L"ofset_x");
    float vOff_y = tex_shader.GetParameterValue(L"ofset_y");
    float vOff_z = tex_shader.GetParameterValue(L"ofset_z");
    //-- scale
    float vSize_x = tex_shader.GetParameterValue(L"size_x");
    float vSize_y = tex_shader.GetParameterValue(L"size_y");
    float vSize_z = tex_shader.GetParameterValue(L"size_z");
    //-- projection map
    int vPmap_x = tex_shader.GetParameterValue(L"combo_x");
    int vPmap_y = tex_shader.GetParameterValue(L"combo_y");
    int vPmap_z = tex_shader.GetParameterValue(L"combo_z");
    //--
    //float bump_factor = s.GetParameterValue(L"bump_fac"); //- UNUSED!

    //-------------------
    yi->paramsPushList();
    //-------------------
    if ( vNorm )
    {
		yi->paramsSetFloat("bump_strength", factor); 
    }
    yi->paramsSetString("element", "shader_node");
    yi->paramsSetString("type", "texture_mapper");
    yi->paramsSetString("name", map_name.c_str());
    yi->paramsSetString("texture", tex_name.c_str());
    yi->paramsSetString("mapping", aType[map_type]);
    yi->paramsSetPoint("offset", vOff_x, vOff_y, vOff_z);
    yi->paramsSetInt("proj_x", vPmap_x);
    yi->paramsSetInt("proj_y", vPmap_y);
    yi->paramsSetInt("proj_z", vPmap_z);
    yi->paramsSetPoint("scale", vSize_x, vSize_y, vSize_z);
    yi->paramsSetString("texco", aMap[fMap]);
    
    //------------------
    yi->paramsEndList();
    //------------------ 
}
//--
void search_env()
{
	//--
	 // Look if there is an background image for Image Based Lighting (e.g. HDRI)
    CRefArray aEnv = app.GetActiveProject().GetActiveScene().GetActivePass().GetNestedObjects();
    for (int i = 0; i < aEnv.GetCount(); i++)
    {
        if (SIObject(aEnv[i]).GetName()==L"Environment Shader Stack")
        {
            CRefArray aImages = SIObject(aEnv[i]).GetNestedObjects();
            for ( int j = 0; j < aImages.GetCount(); j++)
            {
                app.LogMessage(L"Siobjects name :"+ SIObject(aImages[j]).GetName());
                if (SIObject(aImages[j]).GetType()==L"Shader")
                {
                    Shader s(aImages[j]);
                    CRefArray aEnvImg = s.GetImageClips();
                    for (int k = 0; k < aEnvImg.GetCount(); k++)
                    {
                        ImageClip2 vImgClip( aEnvImg[k]);
                        Source vImgClipSrc(vImgClip.GetSource());
                        CString vFileName = vImgClipSrc.GetParameterValue( L"path");
                        if (vFileName!=L"")//- To DO; only use hdr 
                        {
                            vHDRI=vFileName.GetAsciiString();
                            break;
                        }
                    }
                }
            }
            break;
        }
    }
	
}
//--
void yafaray_world(yafrayInterface_t *yi)
{
    yi->paramsClearAll();

    //--------------
    if (vSetworl==4) // darktide
	//--------------
    {
        const char *cspace []={ "CIE (E)", "CIE (D50)", "sRGB (D65)", "sRGB (D50)"};
       
        yi->paramsSetPoint("from", 1, 1, 10);// TODO
        yi->paramsSetFloat("altitude", vdsaltitude);
        yi->paramsSetFloat("turbidity", vTurbidity);
        yi->paramsSetFloat("a_var", vHorbright);
        yi->paramsSetFloat("b_var", vHorsprd);
        yi->paramsSetFloat("c_var", vSunbright);
        yi->paramsSetFloat("d_var", vSunsize);
        yi->paramsSetFloat("e_var", vBacklight);
        yi->paramsSetBool("add_sun", vAdd_sun);
        //--
        if ( vAdd_sun )
        {
            yi->paramsSetFloat("sun_power", vSun_power);
        }
        yi->paramsSetBool("background_light", vSkylight);
        //--
        if ( vSkylight )
        {
            yi->paramsSetBool("with_caustic", vW_caust);
            yi->paramsSetBool("with_diffuse", vW_diff);
            yi->paramsSetFloat("power", vSky_power);
        }
        yi->paramsSetInt("light_samples", vW_samples);
        yi->paramsSetFloat("bright", vdsbright);
        yi->paramsSetBool("night", vdsnight); // TODO: create menu
        yi->paramsSetFloat("exposure", vexposure);
        yi->paramsSetBool("clamp_rgb", vclamp_rgb);
        yi->paramsSetBool("gamma_enc", vgamma_enc);
        yi->paramsSetString("color_space", cspace[vcolorspace]);
        yi->paramsSetString("type", "darksky");
    }
	//-------------------
    else if (vSetworl==3)  // sunsky
	//-------------------
    {
        //- TO DO; Search sunlight into scene and update 'from' values for 'add sun' option..
        // ..or show message if not have sunlights
        //- need: create a lights array?
        //yi->paramsSetPoint("from", f[0], f[1], f[2]); // not defined /------>

        yi->paramsSetFloat("turbidity", vTurbidity);
        yi->paramsSetFloat("a_var", vHorbright);
        yi->paramsSetFloat("b_var", vHorsprd);
        yi->paramsSetFloat("c_var", vSunbright);
        yi->paramsSetFloat("d_var", vSunsize);
        yi->paramsSetFloat("e_var", vBacklight);
        yi->paramsSetBool("add_sun", vAdd_sun);
        //--
        if ( vAdd_sun )
        {
            yi->paramsSetPoint("from", 1, 1, 10);// TODO
            yi->paramsSetFloat("sun_power", vSun_power);
        }
        yi->paramsSetBool("background_light", vSkylight);
        //--
        if ( vSkylight )
        {
            yi->paramsSetFloat("power", vSky_power);
        }
        //--
        yi->paramsSetInt("light_samples", vW_samples);
        yi->paramsSetString("type", "sunsky");
    }
	//---------------------
    else if (vSetworl == 2) //-- texture
	//---------------------
    {
        const char *A_mapping [2] = {"probe", "sphere"};
        const char *A_interp [2] = {"none", "bilinear"};
       
        //--
        yi->paramsSetFloat("exposure_adjust", vtexposure);
        yi->paramsSetString("filename", "H:/trabajo/hdri/studio021.hdr"); //vHDRI.GetAsciiString());
        yi->paramsSetString("interpolate", A_interp[vUse_interp]);
        yi->paramsSetString("type", "image");
        yi->createTexture("world_texture");

		//-- IBL options
        yi->paramsClearAll();
        yi->paramsSetString("type", "textureback");
        yi->paramsSetString("texture", "world_texture");
        yi->paramsSetBool("ibl", vUse_ibl);
        yi->paramsSetString("mapping", A_mapping[vmapworld]);
        yi->paramsSetBool("with_caustic", vW_caust);
        yi->paramsSetBool("with_diffuse", vW_diff);
        yi->paramsSetFloat("rotation", vrotation);
    }
	//---------------------
    else if (vSetworl == 1) //-- gradient
	//---------------------
    {
        yi->paramsSetColor("horizon_color", vHor_red, vHor_green, vHor_blue, vHor_alpha);
        yi->paramsSetColor("horizon_ground_color", vHorgro_red, vHorgro_green, vHorgro_blue, vHorgro_alpha);
        yi->paramsSetBool("ibl", vUse_ibl);
        yi->paramsSetColor("zenith_color", vZen_red, vZen_green, vZen_blue, vZen_alpha);
        yi->paramsSetColor("zenith_ground_color", vZengro_red, vZengro_green, vZengro_blue, vZengro_alpha);
		yi->paramsSetString("type", "gradientback");    
    }
	//----
    else  //-- constant
	//----
    {
        yi->paramsSetColor("color", vBack_red, vBack_green, vBack_blue, vBack_alpha);
        yi->paramsSetBool("ibl", vUse_ibl);
        yi->paramsSetString("type", "constant");
    }
    if (vUse_ibl == true)
    {
        yi->paramsSetInt("ibl_samples", vIbl_samples);
        yi->paramsSetFloat("power", vIbl_power);
    }
    yi->createBackground("world_background");
}
//--
void yafaray_render(yafrayInterface_t *yi)
{

    // create render -------------------->
    const char *A_tile_order [2] = {"random", "linear"};
    const char *Aa_mode  [4] = { "box", "gauss", "lanczos", "mitchell" };

        yi->paramsClearAll();
        //---
        yi->paramsSetInt("AA_passes", vAA_passes );
        yi->paramsSetInt("AA_minsamples", vAA_samples );
        yi->paramsSetInt("AA_inc_samples", vAA_inc );
        yi->paramsSetFloat("AA_pixelwidth", vAA_pixel );
        yi->paramsSetFloat("AA_threshold", vAA_threshold );
        yi->paramsSetString("filter_type", Aa_mode[vFilter_type] );
        //--
        yi->paramsSetString("background_name", "world_background");
        yi->paramsSetString("camera_name", "camera");
        yi->paramsSetString("integrator_name", "default");
        yi->paramsSetString("volintegrator_name", "volintegr");
        yi->paramsSetString("customString",  vCustom_string.GetAsciiString());
        yi->paramsSetBool("drawParams", vDraw_render);
        yi->paramsSetFloat("gamma", vContrast);
        yi->paramsSetBool("clamp_rgb", vClamp_rgb);
        yi->paramsSetBool("show_sam_pix", vshowpix);
        yi->paramsSetBool("premult", vPremu_alpha);
        yi->paramsSetInt("tile_size", vtilesize);
        yi->paramsSetString("tiles_order", A_tile_order[vtileorder]);
        yi->paramsSetBool("z_channel", vZ_buffer);
        if (vAuto_thread) vThreads = -1;
        yi->paramsSetInt("threads", vThreads );
        yi->paramsSetInt("width", vXRes);
        yi->paramsSetInt("height", vYRes);
        yi->paramsSetInt("xstart", 0);
        yi->paramsSetInt("ystart", 0);

}
//--
int yaf_xml()
{
	//-- test
	xmlInterface_t *yi = new xmlInterface_t();
	//--
	yi->startScene();

    app.LogMessage(L"YAFXSI: Processing Textures.....");
    yafaray_texture( yi );
        
    //-- create materials ------------------
    app.LogMessage(L"YAFXSI: Processing Materials....."); 
    //--
    yafaray_material(yi);
    
    //-- create lights --------------------
    app.LogMessage(L"YAFXSI: Processing Lights..."); 
    //--
    yafaray_light(yi);

    //-- create geometry
    app.LogMessage(L"YAFXSI: Processing Geometry.....");
    //--
    yafaray_object(yi);
 
    //-- create camera
    app.LogMessage(L"YAFXSI: Processing Camera.....");
    //--
    yafaray_cam(yi);

    //-- create background
    app.LogMessage(L"YAFXSI: Processing Background.....");
    //--
    yafaray_world(yi);

    //--
    app.LogMessage(L"YAFXSI: Processing integrators..");
    yafaray_integrator(yi);

    //--
    yafaray_volume_integrator(yi);
	//--
	yafaray_render(yi);
	
	//--
	yi->setOutfile(vfile_out_xml.GetAsciiString());
	//--
	colorOutput_t *outxml = NULL; ;

	//--
	yi->render(*outxml);
    
	//output->flush();
	delete outxml;
    
    yi->clearAll();
    delete yi;
    return 0;
}
//--
int yaf_export()
{
	/*
    if( time == DBL_MAX )
    {
        CRefArray projectProps = Application().GetActiveProject().GetProperties();
        Property playControl = projectProps.GetItem( L"Play Control" );
        time = playControl.GetParameterValue( L"Current" );
    }
    */
    //-- load interface
    yafrayInterface_t *yi;
	yi = new yafrayInterface_t();
    //--
	string p_path(vplugin_path.GetAsciiString());
    yi->loadPlugins(p_path.c_str());
    
    //-- start scene
    
    yi->startScene();

    app.LogMessage(L"YAFXSI: Processing textures....."); 
    yafaray_texture( yi );
        

    //-- create materials ------------------
    app.LogMessage(L"YAFXSI: Processing materials....."); 
    //--
    yafaray_material(yi);
    
    //-- create lights --------------------
    app.LogMessage(L"YAFXSI: Processing lights..."); 
    //--
    yafaray_light(yi);

    //-- create geometry
    app.LogMessage(L"YAFXSI: Processing geometry.....");
    //--
    yafaray_object(yi);
 
    //-- create camera
    app.LogMessage(L"YAFXSI: Processing camera.....");
    //--
    yafaray_cam(yi);

    //-- create background
    app.LogMessage(L"YAFXSI: Processing background.....");
    //--
    yafaray_world(yi);

    //--
    app.LogMessage(L"YAFXSI: Processing integrator..");
	//-
    yafaray_integrator(yi);
	
    //--
	app.LogMessage(L"YAFXSI: Processing volume integrator...");
    yafaray_volume_integrator(yi);
	
	//--
	app.LogMessage(L"YAFXSI: Processing render settings..");
	yafaray_render(yi);
	
	//--    

    //-- settings for Qt4 graphicall interface
    Settings mysettings;
    mysettings.autoSave = false;
    mysettings.autoSaveAlpha = false;
    mysettings.closeAfterFinish = false;
    //mysettings.fileName = ""; // error to msvc 2010
    
	//-- Load..
	initGui();
    createRenderWidget(yi, vXRes, vYRes, 0, 0, mysettings);
        
    //-- clear
    yi->clearAll();
    delete yi;
    return 0;
  }
//--
#if defined(_WIN32) || defined(_WIN64)
    void loader(const char szArgs[])
    {
        //HANDLE hFile ;
        PROCESS_INFORMATION  pi;
        // start a program in windows
        STARTUPINFO  si = { sizeof(si) };
        CreateProcess(NULL, (LPSTR)szArgs, 0, 0, FALSE, 0, 0, 0, LPSTARTUPINFOA(&si), &pi);
    }
#endif    
//--
void yafaray_execute()
{
    //-- for execute stand-alone YafaRay Application
    CString def_exe_path = app.GetInstallationPath(siUserAddonPath);
    def_exe_path += L"/YafaRay/Application/bin/";
    app.LogMessage(L"Default path: "+ CString(def_exe_path));
    vYafXSIPath = def_exe_path ; 
    //-- make default path for save image file
    if ( vsave_image == L"" )
    {
        CString def_save_image = app.GetInstallationPath(siProjectPath);
        def_save_image += L"/Render_Pictures";
        vsave_image = def_save_image;
    }
    //-- re render exported file
    if ( vre_render )
    {
        vfile_out_xml = vselect_file;
        vre_render = false;
      //--
        CString plugin_path = L"plugins";
        pplugins =  vYafXSIPath + plugin_path; //-- defined plugins folder for -pp option
        vYafXSIPath += L"yafaray-xml.exe";
         
        CString exec = vYafXSIPath +" -pp "+ pplugins +" -f "+ file_ext[vSavefile] +" -op \""+ vsave_image +"\" \""+ vfile_out_xml +"\"";
        //--
        loader(exec.GetAsciiString());	
    }
    else
    {
        app.LogMessage(L" Not valid file loaded for  render ",siErrorMsg);
    }
}
//--
void open_image_render()
{
    if ( vsave_image == L"" )
    {
        CString def_save_image = app.GetInstallationPath(siProjectPath);
        def_save_image += L"/Render_Pictures";
        vsave_image = def_save_image;
    }
    //-- TODO: extend code for select image from list
    CString view_image = app.GetInstallationPath(siFactoryPath);
    view_image += L"/Application/bin/imf_disp.exe filename \""+ vsave_image +"/yafray."+ file_ext[vSavefile] +"\"";
    //--
    app.LogMessage(L"Path to image file: " + CString(view_image));
    //--       
    loader(view_image.GetAsciiString());              
}