//window win;
  //  	columnLayout r;
   //	rampColorPort -n ramp1;
     // 	showWindow win;

// copy *.mel files to your script directory
/// copy *.inc to
/// you must load OBJ export plugin
/// add path of megapob bin directory to system path



/// www.geocities.com/ahmetoktar2
////
///   ******  Limitiations:   *****
///   
// material choser v 0.01a

// deleteUI MChoser;
global float $rad_brightness, $rad_count, $rad_dist_max,$rad_error_bound,$rad_gray_tresh;
global float $rad_low_error, $rad_min_reuse, $rad_neares_count, $rad_recursion_limit;
global float $antialias_treshold,$jitter_amount,$antialias_depth;
global string  $antialias, $radiosity,$jitter;
global int $antialiasMethod,$frame;
 int $job_num,$job_num2;
int $render_stop=0;
global int $batch=0;


//struct ayarlar { int a; } asdsa;
global string $RenderOption;


global proc PovBatchRender()
{
global string $image_path;
global int $render_stop,$job_num,$batch,$frame;

string $tirnak = "\"";
//currentTime 
$start = `intFieldGrp -q -v StartTextField`;
$stop = `intFieldGrp -q -v StopTextField`;
$step = `intFieldGrp -q -v StepTextField`;

	$batch=1;
	$frame=$start[0];
		currentTime $frame;

	string $s = $start[0];
	$zero = "";
	for($j=0; $j<4-size($s); $j++) $zero+="0";
	PovRender($zero+$start[0]);
return;

	for($i=$start[0]; $i<=$stop[0]; $i+=$step[0])
	{
	currentTime $i;
	$fname = `textFieldGrp -q -tx file_name`; 
	string $s = $i;
	$zero = "";
	for($j=0; $j<4-size($s); $j++) $zero+="0";
	PovRender($zero+$i);
//	$cmd="copy "+$tirnak+$image_path+$fname+".bmp"+$tirnak+" "+$tirnak+$image_path+$fname+$zero+$i+".bmp"+$tirnak;
//	print($cmd+"\n");
//	system($cmd);
	int $a=`scriptJob -ex $job_num`;

while(`scriptJob -ex $job_num`) ;
	}
}

//////////////////////////////////////////////////
/// DUMMY OBJEYE KAYITLI GLOBAL SETTINGLERI UI NESNELERINE AKTARIR
global proc set_globalSettings_toUI()
{
global int $antialiasMethod;
global string  $antialias, $radiosity,$jitter,$camera,$photons;
global float $antialias_treshold,$jitter_amount,$antialias_depth;
global float $rad_brightness, $rad_count, $rad_dist_max,$rad_error_bound,$rad_gray_tresh,$quality;
global float $rad_low_error, $rad_min_reuse, $rad_neares_count, $rad_recursion_limit;
global float $adc_bailout,$assumed_gamma,$AmbientR,$AmbientG,$AmbientB,$irid1,$irid2,$irid3;
global int $max_intersections,$hf_gray_16,$number_of_waves,$max_trace_level;
global float $photon_spacing,$photon_count;
global float $turb_depth,$omega,$lambda,$octaves,$fog_offset,$fog_alt,$Fog_Up;  
global float $fade_distance,$fade_power,$ior,$dispersion,$dispersion_samples,$interior;
global float $skycolor1R, $skycolor1G, $skycolor1B,$skycolor2R, $skycolor2G, $skycolor2B;
global int $sky_sphere,$fog;
int $a;	

	// GLOBAL SETTINGS DUMMY OBJE YOKSA OLUSTUR
	if (!`objExists Mayaray_global_settings`) 
	{
		save_globalsettings_todummy(); 
		return; 
	}
	// sky
	$skycolor1R = `getAttr Mayaray_sky_sphere.skycolor1R`;
	$skycolor1G = `getAttr Mayaray_sky_sphere.skycolor1G`;
	$skycolor1B = `getAttr Mayaray_sky_sphere.skycolor1B`;
	$skycolor2R = `getAttr Mayaray_sky_sphere.skycolor2R`;
	$skycolor2G = `getAttr Mayaray_sky_sphere.skycolor2G`;
	$skycolor2B = `getAttr Mayaray_sky_sphere.skycolor2B`;
	$sky_sphere = `getAttr Mayaray_sky_sphere.sky_sphere`;
	//fog
	$fog = `getAttr Mayaray_fog.fog`;
	$turb_depth = `getAttr Mayaray_fog.turb_depth`;
	$omega = `getAttr Mayaray_fog.omega`;
	$lambda = `getAttr Mayaray_fog.lambda`;
	$octaves = `getAttr Mayaray_fog.octaves`;
	$fog_offset = `getAttr Mayaray_fog.fog_offset`;
	$fog_alt = `getAttr Mayaray_fog.fog_alt`;
	$Fog_Up = `getAttr Mayaray_fog.Fog_Up`;

	$camera = `getAttr Mayaray_global_settings.camera`;
	$radiosity = `getAttr Mayaray_global_settings.radiosity`;
	$antialias = `getAttr Mayaray_global_settings.antialias`;
	$antialias_treshold = `getAttr  Mayaray_global_settings.antialias_treshold `;
	$jitter_amount = `getAttr   Mayaray_global_settings.jitter_amount `;
	$antialias_depth = `getAttr   Mayaray_global_settings.antialias_depth `;
	$rad_brightness = `getAttr   Mayaray_global_settings.rad_brightness `;
	$rad_count = `getAttr   Mayaray_global_settings.rad_count `;
	$rad_dist_max = `getAttr   Mayaray_global_settings.rad_dist_max `;
	$rad_error_bound = `getAttr   Mayaray_global_settings.rad_error_bound `;
	$rad_gray_tresh = `getAttr   Mayaray_global_settings.rad_gray_tresh `;
	$quality = `getAttr   Mayaray_global_settings.quality `;
	$rad_low_error = `getAttr   Mayaray_global_settings.rad_low_error `;
	$rad_min_reuse = `getAttr   Mayaray_global_settings.rad_min_reuse `;
	$rad_neares_count = `getAttr   Mayaray_global_settings.rad_neares_count `;
	$rad_recursion_limit = `getAttr   Mayaray_global_settings.rad_recursion_limit `;
	$adc_bailout = `getAttr   Mayaray_global_settings.adc_bailout `;
	$assumed_gamma = `getAttr   Mayaray_global_settings.assumed_gamma `;
	$irid1 = `getAttr   Mayaray_global_settings.irid1 `;
	$irid2 = `getAttr   Mayaray_global_settings.irid2 `;
	$irid3 = `getAttr   Mayaray_global_settings.irid3 `;
	$max_intersections = `getAttr   Mayaray_global_settings.max_intersections `;
	$hf_gray_16 = `getAttr   Mayaray_global_settings.hf_gray_16 `;
	$number_of_waves = `getAttr   Mayaray_global_settings.number_of_waves `;
	$max_trace_level = `getAttr   Mayaray_global_settings.max_trace_level `;
	//ambient
	$AmbientR = `getAttr   Mayaray_global_settings.AmbientR `;
	$AmbientG = `getAttr   Mayaray_global_settings.AmbientG `;
	$AmbientB = `getAttr   Mayaray_global_settings.AmbientB `;
	// photons
	$photons = `getAttr   Mayaray_global_settings.use_photons`;
	$photon_spacing = `getAttr   Mayaray_global_settings.photon_spacing `;
	$photon_count = `getAttr   Mayaray_global_settings.photon_count `;


	
	if($radiosity=="on") checkBox -edit -v 1 radiosity; else checkBox -edit -v 0 radiosity;
	if($antialias=="on") checkBox -edit -v 1 Antialias; else checkBox -edit -v 0 Antialias;

	textFieldGrp -edit -tx $camera camera_name;  

	floatSliderGrp -edit -v $quality Quality;
	floatSliderGrp -edit -v $antialias_treshold Threshold;
	floatSliderGrp -edit -v $antialias_depth AntialiasDepth;
	 floatSliderGrp -edit -v $jitter_amount JitterAmount;
	floatSliderGrp -edit -v $rad_brightness Brightness;
	floatSliderGrp -edit -v $rad_count Count;
	floatSliderGrp -edit -v $rad_dist_max Distance;
	floatSliderGrp -edit -v $rad_error_bound Error_Bound;
	floatSliderGrp -edit -v $rad_dist_max Distance;
	floatSliderGrp -edit -v $rad_gray_tresh GrayTreshold;
	floatSliderGrp -edit -v $rad_low_error  Low_Error_Factor;
	floatSliderGrp -edit -v $rad_min_reuse MinimumReuse;
	floatSliderGrp -edit -v $rad_neares_count NearestCount;
	floatSliderGrp -edit -v $rad_recursion_limit RecursionLimit;
	colorSliderGrp -edit -rgb $AmbientR $AmbientG $AmbientB Ambient;
	//sky
	checkBox -edit -v $sky_sphere sky_sphere; 
	colorSliderGrp -edit -rgb $skycolor1R $skycolor1G $skycolor1B skycolor1;
	colorSliderGrp -edit -rgb $skycolor2R $skycolor2G $skycolor2B skycolor2;
	//fog
	checkBox -edit -v $fog fog; 
	floatSliderGrp -edit -v $turb_depth turb_depth;
	floatSliderGrp -edit -v $omega omega;
	floatSliderGrp -edit -v $lambda lambda;
	floatSliderGrp -edit -v $octaves octaves;
	floatSliderGrp -edit -v $fog_offset fog_offset;
	floatSliderGrp -edit -v $fog_alt fog_alt;
	floatSliderGrp -edit -v $Fog_Up Fog_Up;

	floatSliderGrp -edit -v $adc_bailout adc_bailout;
	floatSliderGrp -edit -v $assumed_gamma AssumedGamma;
	checkBox -edit -v $hf_gray_16 hf_gray_16; 
	floatSliderGrp -edit -v $max_intersections max_intersections;
	floatFieldGrp -edit -value1 $irid1 irid_wavelength;
	floatFieldGrp -edit -value2 $irid2 irid_wavelength;
	floatFieldGrp -edit -value3 $irid3 irid_wavelength;
	floatSliderGrp -edit -v $number_of_waves number_of_waves;
	floatSliderGrp -edit -v $max_trace_level max_trace_level;
	if($photons=="on") checkBox -edit -v 1 use_photons; else checkBox -edit -v 0 use_photons;
	floatSliderGrp -edit -v $photon_spacing photon_spacing;
	floatSliderGrp -edit -v $photon_count photon_count;


}

////////////////////////////////////////////////////////////////
//// WINDOW UI NESNELERINDEN GLOBAL DEGISKENLERI OKUR
global proc get_globalSettings_fromUI()
{
global int $antialiasMethod;
global string  $antialias, $radiosity,$jitter,$camera,$photons;
global float $antialias_treshold,$jitter_amount,$antialias_depth;
global float $rad_brightness, $rad_count, $rad_dist_max,$rad_error_bound,$rad_gray_tresh,$quality;
global float $rad_low_error, $rad_min_reuse, $rad_neares_count, $rad_recursion_limit;
global float $adc_bailout,$assumed_gamma,$AmbientR,$AmbientG,$AmbientB,$irid1,$irid2,$irid3;
global int $max_intersections,$hf_gray_16,$number_of_waves,$max_trace_level;
global float $photon_spacing,$photon_count;
global float $turb_depth,$omega,$lambda,$octaves,$fog_offset,$fog_alt,$Fog_Up;  
global float $fade_distance,$fade_power,$ior,$dispersion,$dispersion_samples,$interior;
global float $skycolor1R, $skycolor1G, $skycolor1B,$skycolor2R, $skycolor2G, $skycolor2B;
global int $sky_sphere,$fog;
 
	// SKY SPHERE
	$sky_sphere = `checkBox -q -v sky_sphere`;
	$a = `colorSliderGrp -q -rgb skycolor1`;
	$skycolor1R = $a[0];	$skycolor1G = $a[1];	$skycolor1B = $a[2];
	$a = `colorSliderGrp -q -rgb skycolor2`;
	$skycolor2R = $a[0];	$skycolor2G = $a[1];	$skycolor2B = $a[2];
	// FOG
	$fog = `checkBox -q -v fog`;
	$turb_depth= `floatSliderGrp -q -v turb_depth`; 
	$omega= `floatSliderGrp -q -v omega`; 
	$lambda= `floatSliderGrp -q -v lambda`; 
	$octaves= `floatSliderGrp -q -v octaves`; 
	$fog_offset= `floatSliderGrp -q -v fog_offset`; 
	$fog_alt= `floatSliderGrp -q -v fog_alt`; 
	$Fog_Up= `floatSliderGrp -q -v Fog_Up`; 

	if(`checkBox -q -v radiosity` == 1) $radiosity="on"; else $radiosity="off" ;
	if(`checkBox -q -v Antialias` == 1) $antialias="on"; else $antialias="off" ;
	
	$camera =   `textFieldGrp -q -tx camera_name`;  
	$quality= `floatSliderGrp -q -v Quality`;
	$antialias_treshold= `floatSliderGrp -q -v Threshold`;
	$antialias_depth= int( `floatSliderGrp -q -v AntialiasDepth`);
	$jitter_amount = `floatSliderGrp -q -v JitterAmount`;

	$rad_brightness = `floatSliderGrp -q -v Brightness`;
	$rad_count = `floatSliderGrp -q -v Count`;
	$rad_dist_max = `floatSliderGrp -q -v Distance`;
	$rad_error_bound = `floatSliderGrp -q -v Error_Bound`;
	$rad_dist_max = `floatSliderGrp -q -v Distance`;
	$rad_gray_tresh = `floatSliderGrp -q -v GrayTreshold`;
	$rad_low_error = `floatSliderGrp -q -v Low_Error_Factor`;
	$rad_min_reuse= `floatSliderGrp -q -v MinimumReuse`;
	$rad_neares_count = `floatSliderGrp -q -v NearestCount`;
	$rad_recursion_limit = `floatSliderGrp -q -v RecursionLimit`;
	if(`checkBox -q -v use_photons` == 1) $photons="on"; else $photons="off" ;
	$photon_spacing = `floatSliderGrp -q -v photon_spacing`;
	$photon_count = `floatSliderGrp -q -v photon_count`;

	$a = `colorSliderGrp -q -rgb Ambient`;
	$AmbientR = $a[0];
	$AmbientG = $a[1];
	$AmbientB = $a[2];

	$adc_bailout=`floatSliderGrp -q -v adc_bailout`;
	$assumed_gamma=`floatSliderGrp -q -v AssumedGamma`;
	$hf_gray_16 = `checkBox -q -v hf_gray_16`; 
	$max_intersections=`floatSliderGrp -q -v max_intersections`;
	$irid1=`floatFieldGrp -q -value1 irid_wavelength`;
	$irid2=`floatFieldGrp -q -value2 irid_wavelength`;
	$irid3=`floatFieldGrp -q -value3 irid_wavelength`;
	$number_of_waves=`floatSliderGrp -q -v number_of_waves`;
	$max_trace_level=`floatSliderGrp -q -v max_trace_level`;
	
}

global proc PovRender(string $frame_count)
{
int $fileID;
global int $antialiasMethod;
global string $out_file_tip;
global string  $antialias, $radiosity,$jitter;
global float $antialias_treshold,$jitter_amount,$antialias_depth;
global float $rad_brightness, $rad_count, $rad_dist_max,$rad_error_bound,$rad_gray_tresh,$quality;
global float $rad_low_error, $rad_min_reuse, $rad_neares_count, $rad_recursion_limit;
global string $image_path;
global string $currentProject;
global string $PovExe ;
global string $RenderOption;
global int  $render_time;
string $fname;

 $render_time=1;
	
	get_globalSettings_fromUI();	
		save_globalsettings_todummy();

  int $fileID = fopen( $image_path+"test.ini", "w" );

 //  fprint ($fileID,"All_Console=Off \nAll_File=On \nBounding=On \nBounding_Threshold=3 \nBuffer_Output=Off");
fprint ($fileID,"\nBuffer_Size=0 \nClock=0 \nCreate_Ini= \nCyclic_Animation=Off \nDebug_Console=Off");
fprint ($fileID,"\nDebug_File="+$image_path+"1debug.txt \nDisplay_Gamma=2.2 \nDraw_Vistas=Off \nFatal_Console=Off \nFatal_Error_Command=");
fprint ($fileID,"\nFatal_Error_Return= I \nFatal_File="+$image_path+"fatal.txt \nField_Render=Off \n"); //Output_Alpha=On ");
fprint ($fileID,"\nOutput_File_Name=");
$fname = $image_path+`textFieldGrp -q -tx file_name`+$frame_count; 
fprint ($fileID,$fname+"\n"+"Output_to_File=On \nOutput_File_Type=");
if($out_file_tip=="BMP") fprint ($fileID," S ");
else 
    if($out_file_tip=="TGA") fprint ($fileID," T ");
fprint ($fileID,"\nFinal_Clock=1 \nFinal_Frame=-1 \nHistogram_Name= \Histogram_Grid_Size=0.0 \n");
fprint ($fileID,"\nInitial_Clock=0 \nInitial_Frame=1 ");
fprint ($fileID,"\nLibrary_Path= \nLight_Buffer=On \nOdd_Field=Off \Palette=3 \Post_Frame_Command= ");
$cmd="dir >dir.txt ";
//$cmd = "fcheck ";
fprint ($fileID,"\nPost_Frame_Return= U \nPost_Scene_Command="+$cmd+"\nPost_Scene_Return=U \nPreview_End_Size=1");
fprint ($fileID,"\nPreview_Start_Size=1 \nPre_Frame_Command=\nPre_Frame_Return=U \nPre_Scene_command=");
fprint ($fileID,"\nPre_Scene_Return= I \nQuality="+$quality+" \nRemove_Bounds=On \nRender_Console=Off");
fprint ($fileID,"\nRender_File="+$image_path+"render.txt \nSampling_Method=1 \nSplit_Unions=Off");
fprint ($fileID,"\nStatistic_File="+$image_path+"stat.txt \nSubset_End_Frame=-1 \nSubset_Start_Frame=-1 \nTest_Abort_Count=1");
fprint ($fileID,"\nUser_Abort_Command=\nUser_Abort_Return=F \nVersion=3.1 \nVideo_Mode=0");
fprint ($fileID,"\nVista_Buffer=On \nWarning_Console=Off \nWarning_File="+$image_path+"1warning.txt \nBits_Per_Color=16");

fprint ($fileID,"\nRadiosity = "+$radiosity+"\nWidth = "+getAttr("defaultResolution.width"));
fprint ($fileID,"\nHeight = "+getAttr("defaultResolution.height"));
fprint ($fileID,"\nAntialias = "+ $antialias+" \nAntialias_Threshold = "+$antialias_treshold+" \nJitter="+$jitter+" \nJitter_Amount =     "+$jitter_amount);
fprint ($fileID,"\nAntialias_Depth = "+$antialias_depth+" \nSampling_Method = "+$antialiasMethod+" \nPause_When_Done = Off");
fprint ($fileID,"\nDisplay = On \nVerbose = Off \nContinue_Trace = I");
fprint ($fileID,"\nTest_Abort = On \nInput_File_Name = "+$image_path+"test.pov");
fprint ($fileID,"\nPreview_Start_Size=1 \nPreview_End_Size=1 \n");

fclose($fileID);

/// RENDER KOMUT LINE ILAVE OPTIONLAR
$RenderOption = "";

if($antialias_treshold>0) {
	$RenderOption += "+A"+$antialias_treshold;
	int $d = `optionMenu -q -sl AntialiasMethod`;
	$RenderOption += " +AM"+$d;
	}
if($antialias_depth>0) $RenderOption += " +R"+int($antialias_depth);

$RenderOption += " +FS";
$RenderOption += " +o"+$fname+$frame_count;
if($radiosity=="on") $RenderOption += " +QR";
$RenderOption += " +Q"+$quality;
$RenderOption += " +X5";
$RenderOption += " +GS"+$image_path+"stat.txt ";
$RenderOption += " +GF"+$image_path+"fatal.txt ";

if($jitter=="on") {
	$RenderOption += " +J";
	if($jitter_amount>0) $RenderOption += $jitter_amount;
	}
	
$RenderOption += " +H"+getAttr("defaultResolution.height");
$RenderOption += " +W"+getAttr("defaultResolution.width");

povRender(0,$frame_count);

}

/// INI DOYASI HAZIRLA   /////////////
///
global proc create_ini()
{

}



/////***********************************
//// MAYA MATERIaLS
/// SIMULATION
/// povray malzemesi atanmamışsa kullanılacak

proc material_yaz(int $render_selected)
{
	string $maya_mat[] =`ls -mat`, $ffn,$ext;
	global int $fileID;

	for($mat in $maya_mat) 
	{
	$mm = `nodeType $mat`;
 	  if( $mm== "blinn" || $mm== "lambert" || $mm== "phong" || $mm== "phongE")
	  {
		fprint ($fileID,"////***** material *******////////\n");	
		fprint ($fileID,"#declare "+$mat+" = \n   material {\n      texture\n    {\n");	
		fprint ($fileID,"uv_mapping pigment \n     {\n          ");	
		float $trans[] = getAttr($mat+".transparency");
		float $color[] = eval("getAttr "+$mat+".color");
		float $tran = ($trans[0]+$trans[1]+$trans[2])/(3);
		

	    string $cc = $mat+".color"; string $color_texture[] = `listConnections -type "file" $cc`;
	    $ext="";
	  if($color_texture[0]!="")  // image_map kullanılmişsa
	  { 
		$a = $color_texture[0]+".fileTextureName";
		$ffn = `getAttr $a`;
		$size = size($ffn); $s1=$size-2;  $ext = `substring $ffn $s1 $size`;
		$ext = tolower($ext);
		if($ext=="jpg") $ext="jpeg";
	  }
	  if($ext=="gif" || $ext=="tga" || $ext=="iff" || $ext=="ppm" || $ext=="pgm" 
		|| $ext=="png"|| $ext=="jpeg"|| $ext=="tiff"|| $ext=="sys")
	   {

		fprint ($fileID,"image_map { "+$ext+" \""+$ffn+"\" map_type 0 }\n scale 1 \n");
	
  	   }
	   else
	   {
		if($tran>0)  ////image_map yoksa
		{
			fprint ($fileID,"color rgbft <"+$color[0]+", "+$color[1]+", "+$color[2]+", "+$tran+", "+$tran+">\n");
		}
		else
		  {
			fprint ($fileID,"color rgb <"+$color[0]+", "+$color[1]+", "+$color[2]+">\n");
			}
	   }
		fprint ($fileID,"       }\n ");


		if($mm == "blinn" || $mm == "phong" || $mm == "phongE")
			{
			////////// BUMP TEXTURE
		string $bump[] = `listConnections -type "bump2d" $mat`;
		if($bump[0]!="") 
		{
		    $c = $bump[0]+".bumpDepth";
			float $bump_size = `getAttr $c`;
		    string $bump_texture[] = `listConnections -type "file" $bump[0]`;

			if($bump_texture[0]!="")  // BUMP image_map kullanılmişsa
			  {
			  $a = $bump_texture[0]+".fileTextureName";
			   string $ffn = `getAttr $a`;
			  $size = size($ffn); $s1=$size-2;  string $ext = `substring $ffn $s1 $size`;
			  $ext = tolower($ext);
			  if($ext=="jpg") $ext="jpeg";
			  fprint ($fileID,"normal \n { \n bump_map { "+$ext+" \""+$ffn+"\" map_type 0  \n interpolate 1}\n ");
			  fprint ($fileID,"bump_size "+10*$bump_size+" scale 1 \n } \n");
			  }

		}
			fprint ($fileID,"finish {\n          ");	
			fprint ($fileID,"reflection "+getAttr($mat+".reflectivity")+"\n");
			fprint ($fileID,"reflection_exponent "+".5"+"\n");
			
			fprint ($fileID,"diffuse "+getAttr($mat+".diffuse")+"\n");
			if($mm=="blinn") 
			{
				float $ee = getAttr($mat+".eccentricity");
				fprint ($fileID,"roughness "+(log10($ee*100+1)/10+.00001)+"\n");
				fprint ($fileID,"specular "+getAttr($mat+".specularRollOff")+"\n");
				}
			if($mm=="phong")
			{
				float $color[] = eval("getAttr "+$mat+".specularColor");
				float $cospwr = getAttr($mat+".cosinePower");
				fprint ($fileID,"phong "+$cospwr*($color[0]+$color[1]+$color[2])/(300)+"\n");		
				fprint ($fileID,"phong_size "+$cospwr+"\n");
				fprint ($fileID,"specular "+($color[0]+$color[1]+$color[2])/(3)+"\n");

			//	float $aa[] = eval("getAttr "+$mat+".specularColor");
			//	fprint ($fileID,"specular rgb < "+$aa[0]+", "+$aa[1]+", "+$aa[2]+" >\n");
				//fprint ($fileID,"roughness "+getAttr($mat+".cosinePower")/100+"\n");
				}
			$aa = getAttr($mat+".ambientColor");
			fprint ($fileID,"ambient rgb <"+$aa[0]+" "+$aa[1]+" "+$aa[2]+">\n");
			fprint ($fileID,"       }\n ");
			}
			fprint ($fileID,"        }\n   ");
		if($tran>0)
		{
			float $refract = getAttr($mat+".refractions");
			if($refract>0)
			{
			float $refract_index = getAttr($mat+".refractiveIndex");
			fprint ($fileID,"interior { ior "+$refract_index+"}\n");
			}
		}
			
			fprint ($fileID,"        }\n   ");
	    }
          }
		
	fprint ($fileID,"////***** material section end *******////////\n");	
}




///**************************** lights
//// LIGHTS DATASINI POV DOKUMANINA YAZ
////**************************************
proc lights_yaz()
{
	global int $fileID;
	 string $lights[] = `ls -lt -ni`;
	float		$radius,$penumbraAngle ,$dropoff,	$falloff ;
		float $vv[3],$lightRot[3];
	
	fprint ($fileID,"//********** LIGHTS SECTION   ***************\n");

	for ( $light in $lights ) {
	//fprint ($fileID,"light_source { <50, 50, -50> \n  color rgb<1, 1, 1> \n");
		select -r $light;
		float $intensity = getAttr ($light + ".intensity");
		float $colorR = getAttr($light + ".colorR");	
		float $colorG = getAttr($light + ".colorG");	
		float $colorB = getAttr($light + ".colorB");
		float $center = getAttr($light + ".centerOfIllumination"); 
		$ltip = `nodeType $light`; 

		if( $ltip ==  "spotLight" ) {
			$radius = getAttr($light + ".coneAngle");
			$dropoff = getAttr($light + ".dropoff");
			$penumbraAngle = getAttr($light + ".penumbraAngle");
			$falloff = $radius+$penumbraAngle;
		}
		string $lightname[] = `pickWalk -d up`;
		float $lightx = getAttr($lightname[0] + ".translateX");
		float $lighty = getAttr($lightname[0] + ".translateY");
		float $lightz = getAttr($lightname[0] + ".translateZ");
		float $lightscalex = getAttr($lightname[0] + ".scaleX");
		float $lightscaley = getAttr($lightname[0] + ".scaleY");
		float $lightscalez = getAttr($lightname[0] + ".scaleZ");
		float $intens = getAttr($lightname[0] + ".intensity");
 

	if( $ltip !=  "areaLight" )
	{
		fprint ($fileID,"  light_source { <" + $lightx + ", "+ $lighty + ", " + $lightz +"> \n");
	}
	else 	
	{
	fprint ($fileID,"  light_source { <0,0,0> \n");
	}

	fprint ($fileID,"  color rgb<"+ $colorR*$intensity  +", "+ $colorG*$intensity  +", "+ $colorB*$intensity  +">*"+$intens+" \n");
		fprint ($fileID,"  photons {\n  refraction ");
		fprint ($fileID,"  on \n reflection ");
		fprint ($fileID,"  on \n } \n");

		 $lightRot[0] = getAttr($lightname[0] + ".rotateX");
		 $lightRot[1] = getAttr($lightname[0] + ".rotateY");
		 $lightRot[2] = getAttr($lightname[0] + ".rotateZ");
		vector $lookat = look_at($lightx, $lighty, $lightz,  $lightRot[0],  $lightRot[1],  $lightRot[2], 1);
		$vv[0] = $lookat.x - $lightx;
		$vv[1] = $lookat.y - $lighty;
		$vv[2] = $lookat.z - $lightz;
		normalize($vv);

		if( $ltip ==  "directionalLight" ) {
 		fprint ($fileID,"parallel \n");
 		fprint ($fileID,"point_at < "+$lookat.x +", "+ $lookat.y+", "+$lookat.z+" >\n");
		}

		if( $ltip ==  "areaLight" ) {
		fprint ($fileID,"area_light <2, 0, 0>" + "<0,2,0> " + 3+ ", "+3+ "\n");
		fprint ($fileID,"scale <"+$lightscalex+", "+$lightscaley+", "+$lightscalez+">\n"  );
//		fprint ($fileID,"rotate "+($lightRot[0]-90)+"*x "+$lightRot[1]+"*y "+$lightRot[2]+"*z \n");
		fprint ($fileID,"rotate <"+($lightRot[0]-90)+", "+$lightRot[1]+", "+$lightRot[2]+"> \n");
		fprint ($fileID,"translate <"+$lightx+", "+$lighty+", "+$lightz+"> \n");
		fprint ($fileID,"adaptive 1 \n  jitter \n orient circular\n"  );

		}

		if( $ltip ==  "spotLight" ) {
			vector $lookat = look_at($lightx, $lighty, $lightz, $lightRot[0],  $lightRot[1],  $lightRot[2], $center);
			$lightlookX = $lookat.x;
			$lightlookY = $lookat.y;
			$lightlookZ = $lookat.z;
		fprint ($fileID,"spotlight \n point_at <" + $lightlookX +", "+$lightlookY+", "+$lightlookZ+">\n"); 
 		fprint ($fileID,"radius "+$radius+" \n");
 		fprint ($fileID,"falloff "+$falloff+" \n");
 		fprint ($fileID,"tightness "+$dropoff+" \n");
		}
		 
		if(getAttr($lightname[0] + ".decayRate")) {
 			fprint ($fileID,"  fade_distance 5 \n");
			fprint ($fileID,"	fade_power "+ getAttr($lightname[0] + ".decayRate") + " \n");
		}


		int $shadow = eval("getAttr "+$light+".useRayTraceShadows");
		if($ltip != "ambientLight") $shadow += eval("getAttr "+$light+".useDepthMapShadows"); 
		if(!$shadow) fprint ($fileID,"	shadowless  \n");
		fprint ($fileID,"  }\n\n");
	}


}

/////*************************************************************

proc camera_yaz()
{
	global int $fileID;
	 string $cameras[] = `ls -dag -type "camera" -ni`;
	string $cam_name = `textFieldGrp -q -tx camera_name`; 
	int $cam_non=0;
	float $cam_fov;


///**************************** camera
	

	for ( $camera in $cameras ) {
		$cc = eval("pickWalk -d up "+$camera);

		if($cam_name==$cc[0]) $cam_non=1;
	}
	if($cam_non==0) $cam_name = "persp";

	$cam_fov = eval("camera -q -hfv "+ $cam_name);

	select -r $cam_name;
	$camx = getAttr($cam_name + ".translateX");
	$camy = getAttr($cam_name + ".translateY");
	$camz = getAttr($cam_name + ".translateZ");
	$camrotx = getAttr($cam_name + ".rotateX");
	$camroty = getAttr($cam_name + ".rotateY");
	$camrotz = getAttr($cam_name + ".rotateZ");
	string $camshape[] = `pickWalk -d down`;
	$camlen = getAttr($camshape[0] + ".centerOfInterest");

	vector $camlook = look_at($camx, $camy, $camz, $camrotx, $camroty, $camrotz, $camlen);
	/// KAMERA TANIMLAMASINI POV DOSYASINA YAZ
	fprint ($fileID,"camera {\n");
	fprint ($fileID,"location <" + $camx + ", " + $camy + ", " + $camz + ">\n");
	fprint ($fileID,"   right <-1.33, 0, 0> \n  up     <0,1,0> \n");
	fprint ($fileID,"   angle "+$cam_fov+"\n");

	fprint ($fileID,"look_at <" + $camlook.x + ", " + $camlook.y + ", " + $camlook.z + "0> \n } \n");


}
/*
global proc string get_parent(string $name)
{
string $a[],$b[];

$b[0]=$name;
	while($a[0]!=$b[0])
	{
	$a =  eval("pickWalk -d up");
	print(">>"+$a[0]);

	if($a[0]==$b[0])
	{
	select $name;
	print("\n");
	return $a[0];
	}
	$b[0]=$a[0];	
	}
}
*/


global proc PovRenderSelected()
{
	povRender(1,"");
}

/////////////////////////////////////////////////////////////
///******* RENDER RENDER RENDER RENDER RENDER RENDER RENDER RENDER RENDER RENDER RENDER 
/////*****
///***************************************************************************************
global proc povRender(int $render_selected,string $frame_count)
{
global float $rad_brightness, $rad_count, $rad_dist_max,$rad_error_bound,$rad_gray_tresh;
global float $rad_low_error, $rad_min_reuse, $rad_neares_count, $rad_recursion_limit;
global string $out_file_tip,$photons;
global string $genel_malzeme = " yellowmat",$mayaray_path;
global float $timer;
global int $fileID,$job_num,$job_num2,$render_time;
global string $image_path, $PovExe, $RenderOption;
global float $adc_bailout,$assumed_gamma,$AmbientR,$AmbientG,$AmbientB,$irid1,$irid2,$irid3;
global int $max_intersections,$hf_gray_16,$number_of_waves,$max_trace_level;
global float $photon_spacing,$photon_count;
string $tirnak = "\"";
float $VertexList[], $NormalList[];
int $numTriangles=0;
string $meshes[] = `ls -type "mesh" -ni`;
string $nurbs[] = `ls -type "nurbsSurface" -ni`;
string $subdivs[] = `ls -type "subdiv" -ni`;
string $objects[];
 int $ttt[];

	$selection_save = `ls -sl`;
	
	 if($render_selected)  $objects = `ls -sl -v -dag -s`;
	 else $objects = `ls -g -ni -v`;
	int $fileID = fopen( $image_path+"test.pov", "w+" );


///*************** camera datasi

//	$cam_lookx = `getAttr camera1_view.translateX`;
//	$cam_looky = `getAttr camera1_view.translateY`;
//	$cam_lookz = `getAttr camera1_view.translateZ`;

string $PovExe = `textFieldGrp -q -tx PovExe`; 
if(`checkBox -q -v RenderBackCheck`) fprint ($fileID,"#version unofficial MegaPov 0.7\n");  

fprint ($fileID,"#include "+$tirnak+$mayaray_path+"includes\\"+"material_maya.inc "+$tirnak+"\n");
fprint ($fileID,"#include "+$tirnak+"colors.inc"+$tirnak+"\n");
fprint ($fileID,"#include "+$tirnak+"skies.inc"+$tirnak+"\n");
//////////////////////////////////////////

	camera_yaz();
	lights_yaz();
	material_yaz($render_selected);

////---------------------------------------------------------------------


  $startTime = `timerX`;



	fclose $fileID;
	select $selection_save;

	$cmd =  "MayaPovExport "+$tirnak+$image_path+"test.pov"+$tirnak+" "+$render_selected;
	eval($cmd);

	string $fname = `textFieldGrp -q -tx file_name`; 
	
	$render_fname2 = $image_path+$fname+$frame_count+"."+$out_file_tip;
	system("del "+$render_fname2);
	int $w = getAttr("defaultResolution.width");  int $h = getAttr("defaultResolution.height");

	$tt = `window -exists ShowRenderWindow`;
print($tt);
	if ($tt==0) 
	{
	//deleteUI -window ShowRenderWindow;
	window -w $w -h $h ShowRenderWindow;
	windowPref -edit -w $w -h $h ShowRenderWindow;
	paneLayout;
	}

 float  $totalTime = `timerX -startTime $startTime`;
	showWindow ShowRenderWindow;
	setParent ShowRenderWindow;
print("export time : "+$totalTime );

	$c=$image_path+"fatal.txt";	sysFile -delete $c;
	$c=$image_path+"stat.txt";	sysFile -delete $c;

//return;
	$tt = `image -q -ex ShowRenderImage`;
	print($tt);
	if($tt==0) {
		image ShowRenderImage; 
		}

	$chk = `checkBox -q -v RenderBackCheck`; 
	if($chk)
	{
	system("start megapov /render /rerun "+$image_path+"test.ini");
	//image -edit -image $render_fname2 ShowRenderImage; 
	}
	else
	{
	string $cmd ="start "+$PovExe+" /render /exit "+$image_path+"test.ini";
	system($cmd);
//	image -edit -image $render_fname2 ShowRenderImage; 
	}
  		 $s = $image_path+"fatal.txt";
		int $ret2=0;
		while($ret2==0)
		{
		$ret2 = `filetest -w $s`;
		}

		$s = "Renderprogress("+$w+","+$h+",\""+$render_fname2+"\")";
		$job_num = `scriptJob -ie $s`;
}

////////////////////////////////////////////////////////////////////
/// FILE'IN KULLANIMDA MI YOKSA KAPATILMIŞMI TESTINI YAPAR
global proc int file_test(string $fname)
{
int $c=0,$fileID;

	$r = `filetest -w $fname`;
	if($r==0) return 0;

	int $fileID = fopen( $fname, "rt" );
	if($fileID==0) return 0;
	string $nextWord = `fgetword $fileID`;
	if($nextWord==""){    fclose $fileID;  return 0; }

   while ( !`feof $fileID` ) {
	//if($nextWord!="Statistics" && $c==0) return 0;
    	//print ( $nextWord + "\n" );
    	$nextWord = `fgetword $fileID`;
	$c++;
    }
    if($c<2) return 0;
    fclose $fileID;

	return 1;
}

//////////////////////////////////////////////////////////
/// POVRAY render yaparken mayanın back process ile renderin bitip bitmediğini kontrol etmesini sağlar
//// scriptJob idle time back processi kullanır
/// TEK ÇAGIRMALIK IDLE TIME PROCESS KULLANILIR
global proc Renderprogress (int $w,int $h,string $fname2)

  {
global string $image_path;
global int $batch,$frame;
int $ret=0,$ret2=0;
int $amount = 0;
int $fileID=0;
string $delf,$s;

	$ret2=1;

          $amount += 5;
	   $startTime1 = `timerX`;
	  $startTime2 = `timerX`;
  	$c=$image_path+"fatal.txt";	sysFile -delete $c;
	   $ret2 = `filetest -w $c`;

	  $ret = file_test( $image_path+"stat.txt");

	if($ret==1 || ($batch==0 && $ret2==0)) {
		$render_stop=1;
		$r = `filetest -w $fname2`;
		if($r) image -edit -image $fname2 ShowRenderImage; 

		 //  progressWindow -endProgress;

		$s="EndProgres2()";
		$job_num2 = `scriptJob -ro 1 -ie $s`;    
		}
	else  {
    /*     progressWindow -edit
              -progress $amount
              -status ("Sleeping: "+"%");
*/
		if($ret2==0) $batch=0;
	  image -edit -image $fname2 ShowRenderImage; 
	  $amount++;
	$render_stop=0;
	pause -sec 1;
	}

  }


////////////////////////////////////////
///  BATCH RENDER ÇAGIRILMIŞSA RENDERI BIR SONRAKI FRAME GETIRIP DEVAM ETTIRIR

global proc NextFrame()
{
global int $job_num,$render_stop;
global int $batch,$frame;
global string $image_path;

		$c=$image_path+"stat.txt";  sysFile -delete $c;
		$c=$image_path+"fatal.txt";  sysFile -delete $c;

		if($batch==1) {
		$stop = `intFieldGrp -q -v StopTextField`;
		$step = `intFieldGrp -q -v StepTextField`;
		$frame+=$step[0];
		print("batch"+$frame);
		if($frame<=$stop[0]) {
			currentTime $frame;
			string $s = $frame;
			$zero = "";
			for($j=0; $j<4-size($s); $j++) $zero+="0";
			PovRender($zero+$frame);
			}
		else $batch=0;
		}
		$render_time=0;
}

/////////////////////////////////////////////////////////
//// FRAME RENDER BITTIĞINDE IDLE PROCESI SONLANDIRAN, TEK SEFER IŞLEYEN PROCESS
global proc EndProgres2()
{
global int $job_num,$render_stop;
global int $batch,$frame,$render_time;
	
	scriptJob -kill $job_num -force;
	 $render_time=0;
	 getObject_InfoActivite();
	NextFrame();

}

global proc getObject_InfoActivite()
{
global int $select_job_num;
$select_job_num = `scriptJob -ro 1 -e "SelectionChanged" "getObject_Info()"`;

}
// //////////////////////////////////////////////////////////////
//  rootNode
//
// Description: Strips the dot-suffix of the specified string.
//  e.g. "object.attribute" is returned as "object"

proc string rootNode( string $object )
{
  string $buffer[];
  tokenize $object "." $buffer;
  return $buffer[0];
}


proc string[] getSGsFromShape( string $shape )
{
  string $shadingEngines[];

  if ( `objExists $shape` )
  {
    string $dest[] = `listConnections -destination true -source false
      -plugs false -type "shadingEngine" $shape`;

    // listConnections can return duplicates within its list.
    // The select below is a quick trick to avoid dupes in the 
    // returned array.
    if ( size( $dest ) )
    {
      string $select[] = `ls -sl`;
      select -r -ne $dest;
      $shadingEngines = `ls -sl`;
      select -r $select;
    }
  }

  return $shadingEngines;
}


 
  // ////////////////////////////////////////////////////////////////////
//  getMaterialFromSG
//
// Description: Returns the Material node feeing the '.surfaceShader'
//  attribute of the specified Shading Group node (shadingEngine).

proc string getMaterialFromSG( string $SG )
{
  string $material = "";

  if ( "shadingEngine" == `nodeType $SG` &&
    `connectionInfo -id ( $SG + ".surfaceShader" )` )
  {
    $material = rootNode( `connectionInfo -sfd
      ( $SG + ".surfaceShader" )` );
  }

  return $material;
}

//////////////////////////////////////////////////////////////////////////////

global proc vector look_at(float $x,float $y,float $z, float $rotx,float $roty,float $rotz,float $len) 
{
	float $retz = $z - $len * cos(deg_to_rad($rotx))  * cos(deg_to_rad($roty));

	float $retx= $x - $len* sin(deg_to_rad($roty)) 	* cos(deg_to_rad($rotx))  *  cos(deg_to_rad($rotz));

	float $rety= $y + $len * sin(deg_to_rad($rotx)) * cos(deg_to_rad($rotz));

	vector $retvec = <<$retx, $rety, $retz>>;
	return $retvec;
}




 
  // ////////////////////////////////////////////////////////////////////
//  getSGsFromShape
//
// Description: Returns an array of the Shading Groups (shadingEngine 
//  nodes) responsible for shading the specified shape node.

//////////////////////////////////
///// HERHANGI BIR OBJE SECILDIĞINDE TASIDIĞI POV OZELLIKLERINI LISTELER

global proc getObject_Info()
{
global int $render_time;

		if($render_time==1) return;
		textFieldGrp -edit -text "" Matname;  
		textScrollList -edit -da MaterialListBox;
		
		string $obje[] = `listRelatives -f -ni -s`;
		setObject_AttribToUI($obje[0]);

		getObject_InfoActivite();
		if($obje[0]=="") return;
		string $q = "attributeQuery -n "+$obje[0]+"-ex pov_material";
		string $q2 = "attributeQuery -n "+$obje[0]+"-ex pov_mattip";
	if(eval($q)) 
		{
		string $s = getAttr($obje[0]+".pov_material");
		string $s2 = getAttr($obje[0]+".pov_mattip");
		string $a = $s+" ("+$s2+")";
		textScrollList -edit -selectItem $s MaterialListBox;
		textFieldGrp -edit -text $a Matname;  
		Mat_ListBox_selected();
		}
		save_globalsettings_todummy();
}

global proc setObject_AttribToUI(string $objename)
{
string $kontrol[]={"photons","hollow","no_image","no_reflection","double_illuminate","inverse"};

	for($i=0;$i<size($kontrol);$i++)
	{
		if($objename=="") 
		  {
		    checkBox -edit -v 0 $kontrol[$i]; 
		    }
		else
		  {
			string $s = "attributeQuery -n "+$objename+"-ex "+$kontrol[$i];
			//$s= `attributeExists $kontrol[$i] $objename`;
			if(eval($s)) 
			{
			int $q = getAttr($objename+"."+$kontrol[$i]);
			checkBox -edit -v $q $kontrol[$i];
			}
			else checkBox -edit -v 0 $kontrol[$i]; 
		    }
	}


}

global proc string AddAttribute(string $node, string $attr, string $type, int $keyable)
{
    string $nm = ($node + "." + $attr);
    string $result[] = `listAttr -r -st $attr $node`;
    if ( 0 == size($result))
    {
	addAttr -at $type -ln $attr $node;
	if( $keyable )
	{
	    setAttr -e -keyable true $nm;
	}
    }
    return $nm;
}

global proc string AddStringAttribute(string $node, string $attr, string $value)
{
    string $nm = ($node + "." + $attr);
    string $result[] = `listAttr -r -st $attr $node`;
    if (0 == size($result))
    {
	addAttr -dt "string" -ln $attr $node;
    }
    setAttr $nm -type "string" $value;
    return $nm;
}