/* this file has been autogenerated by vtkNodeJsWrap */
/* editing this might proof futile */

#define VTK_WRAPPING_CXX
#define VTK_STREAMS_FWD_ONLY
#include <nan.h>

#include "vtkObjectWrap.h"
#include "vtkLightKitWrap.h"
#include "vtkRendererWrap.h"
#include "../../plus/plus.h"

using namespace v8;

extern Nan::Persistent<v8::Object> vtkNodeJsNoWrap;
Nan::Persistent<v8::FunctionTemplate> VtkLightKitWrap::ptpl;

VtkLightKitWrap::VtkLightKitWrap()
{ }

VtkLightKitWrap::VtkLightKitWrap(vtkSmartPointer<vtkLightKit> _native)
{ native = _native; }

VtkLightKitWrap::~VtkLightKitWrap()
{ }

void VtkLightKitWrap::Init(v8::Local<v8::Object> exports)
{
	Nan::SetAccessor(exports, Nan::New("vtkLightKit").ToLocalChecked(), ConstructorGetter);
	Nan::SetAccessor(exports, Nan::New("LightKit").ToLocalChecked(), ConstructorGetter);
}

void VtkLightKitWrap::ConstructorGetter(
	v8::Local<v8::String> property,
	const Nan::PropertyCallbackInfo<v8::Value>& info)
{
	InitPtpl();
	info.GetReturnValue().Set(Nan::New(ptpl)->GetFunction());
}

void VtkLightKitWrap::InitPtpl()
{
	if (!ptpl.IsEmpty()) return;
	v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
	VtkObjectWrap::InitPtpl( );
	tpl->Inherit(Nan::New<FunctionTemplate>(VtkObjectWrap::ptpl));
	tpl->SetClassName(Nan::New("VtkLightKitWrap").ToLocalChecked());
	tpl->InstanceTemplate()->SetInternalFieldCount(1);

	Nan::SetPrototypeMethod(tpl, "AddLightsToRenderer", AddLightsToRenderer);
	Nan::SetPrototypeMethod(tpl, "addLightsToRenderer", AddLightsToRenderer);

	Nan::SetPrototypeMethod(tpl, "DeepCopy", DeepCopy);
	Nan::SetPrototypeMethod(tpl, "deepCopy", DeepCopy);

	Nan::SetPrototypeMethod(tpl, "GetBackLightAngle", GetBackLightAngle);
	Nan::SetPrototypeMethod(tpl, "getBackLightAngle", GetBackLightAngle);

	Nan::SetPrototypeMethod(tpl, "GetBackLightAzimuth", GetBackLightAzimuth);
	Nan::SetPrototypeMethod(tpl, "getBackLightAzimuth", GetBackLightAzimuth);

	Nan::SetPrototypeMethod(tpl, "GetBackLightColor", GetBackLightColor);
	Nan::SetPrototypeMethod(tpl, "getBackLightColor", GetBackLightColor);

	Nan::SetPrototypeMethod(tpl, "GetBackLightElevation", GetBackLightElevation);
	Nan::SetPrototypeMethod(tpl, "getBackLightElevation", GetBackLightElevation);

	Nan::SetPrototypeMethod(tpl, "GetBackLightWarmth", GetBackLightWarmth);
	Nan::SetPrototypeMethod(tpl, "getBackLightWarmth", GetBackLightWarmth);

	Nan::SetPrototypeMethod(tpl, "GetClassName", GetClassName);
	Nan::SetPrototypeMethod(tpl, "getClassName", GetClassName);

	Nan::SetPrototypeMethod(tpl, "GetFillLightAngle", GetFillLightAngle);
	Nan::SetPrototypeMethod(tpl, "getFillLightAngle", GetFillLightAngle);

	Nan::SetPrototypeMethod(tpl, "GetFillLightAzimuth", GetFillLightAzimuth);
	Nan::SetPrototypeMethod(tpl, "getFillLightAzimuth", GetFillLightAzimuth);

	Nan::SetPrototypeMethod(tpl, "GetFillLightColor", GetFillLightColor);
	Nan::SetPrototypeMethod(tpl, "getFillLightColor", GetFillLightColor);

	Nan::SetPrototypeMethod(tpl, "GetFillLightElevation", GetFillLightElevation);
	Nan::SetPrototypeMethod(tpl, "getFillLightElevation", GetFillLightElevation);

	Nan::SetPrototypeMethod(tpl, "GetFillLightWarmth", GetFillLightWarmth);
	Nan::SetPrototypeMethod(tpl, "getFillLightWarmth", GetFillLightWarmth);

	Nan::SetPrototypeMethod(tpl, "GetHeadLightColor", GetHeadLightColor);
	Nan::SetPrototypeMethod(tpl, "getHeadLightColor", GetHeadLightColor);

	Nan::SetPrototypeMethod(tpl, "GetHeadLightWarmth", GetHeadLightWarmth);
	Nan::SetPrototypeMethod(tpl, "getHeadLightWarmth", GetHeadLightWarmth);

	Nan::SetPrototypeMethod(tpl, "GetKeyLightAngle", GetKeyLightAngle);
	Nan::SetPrototypeMethod(tpl, "getKeyLightAngle", GetKeyLightAngle);

	Nan::SetPrototypeMethod(tpl, "GetKeyLightAzimuth", GetKeyLightAzimuth);
	Nan::SetPrototypeMethod(tpl, "getKeyLightAzimuth", GetKeyLightAzimuth);

	Nan::SetPrototypeMethod(tpl, "GetKeyLightColor", GetKeyLightColor);
	Nan::SetPrototypeMethod(tpl, "getKeyLightColor", GetKeyLightColor);

	Nan::SetPrototypeMethod(tpl, "GetKeyLightElevation", GetKeyLightElevation);
	Nan::SetPrototypeMethod(tpl, "getKeyLightElevation", GetKeyLightElevation);

	Nan::SetPrototypeMethod(tpl, "GetKeyLightIntensity", GetKeyLightIntensity);
	Nan::SetPrototypeMethod(tpl, "getKeyLightIntensity", GetKeyLightIntensity);

	Nan::SetPrototypeMethod(tpl, "GetKeyLightWarmth", GetKeyLightWarmth);
	Nan::SetPrototypeMethod(tpl, "getKeyLightWarmth", GetKeyLightWarmth);

	Nan::SetPrototypeMethod(tpl, "GetKeyToBackRatio", GetKeyToBackRatio);
	Nan::SetPrototypeMethod(tpl, "getKeyToBackRatio", GetKeyToBackRatio);

	Nan::SetPrototypeMethod(tpl, "GetKeyToBackRatioMaxValue", GetKeyToBackRatioMaxValue);
	Nan::SetPrototypeMethod(tpl, "getKeyToBackRatioMaxValue", GetKeyToBackRatioMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetKeyToBackRatioMinValue", GetKeyToBackRatioMinValue);
	Nan::SetPrototypeMethod(tpl, "getKeyToBackRatioMinValue", GetKeyToBackRatioMinValue);

	Nan::SetPrototypeMethod(tpl, "GetKeyToFillRatio", GetKeyToFillRatio);
	Nan::SetPrototypeMethod(tpl, "getKeyToFillRatio", GetKeyToFillRatio);

	Nan::SetPrototypeMethod(tpl, "GetKeyToFillRatioMaxValue", GetKeyToFillRatioMaxValue);
	Nan::SetPrototypeMethod(tpl, "getKeyToFillRatioMaxValue", GetKeyToFillRatioMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetKeyToFillRatioMinValue", GetKeyToFillRatioMinValue);
	Nan::SetPrototypeMethod(tpl, "getKeyToFillRatioMinValue", GetKeyToFillRatioMinValue);

	Nan::SetPrototypeMethod(tpl, "GetKeyToHeadRatio", GetKeyToHeadRatio);
	Nan::SetPrototypeMethod(tpl, "getKeyToHeadRatio", GetKeyToHeadRatio);

	Nan::SetPrototypeMethod(tpl, "GetKeyToHeadRatioMaxValue", GetKeyToHeadRatioMaxValue);
	Nan::SetPrototypeMethod(tpl, "getKeyToHeadRatioMaxValue", GetKeyToHeadRatioMaxValue);

	Nan::SetPrototypeMethod(tpl, "GetKeyToHeadRatioMinValue", GetKeyToHeadRatioMinValue);
	Nan::SetPrototypeMethod(tpl, "getKeyToHeadRatioMinValue", GetKeyToHeadRatioMinValue);

	Nan::SetPrototypeMethod(tpl, "GetMaintainLuminance", GetMaintainLuminance);
	Nan::SetPrototypeMethod(tpl, "getMaintainLuminance", GetMaintainLuminance);

	Nan::SetPrototypeMethod(tpl, "GetShortStringFromSubType", GetShortStringFromSubType);
	Nan::SetPrototypeMethod(tpl, "getShortStringFromSubType", GetShortStringFromSubType);

	Nan::SetPrototypeMethod(tpl, "GetStringFromSubType", GetStringFromSubType);
	Nan::SetPrototypeMethod(tpl, "getStringFromSubType", GetStringFromSubType);

	Nan::SetPrototypeMethod(tpl, "GetStringFromType", GetStringFromType);
	Nan::SetPrototypeMethod(tpl, "getStringFromType", GetStringFromType);

	Nan::SetPrototypeMethod(tpl, "IsA", IsA);
	Nan::SetPrototypeMethod(tpl, "isA", IsA);

	Nan::SetPrototypeMethod(tpl, "MaintainLuminanceOff", MaintainLuminanceOff);
	Nan::SetPrototypeMethod(tpl, "maintainLuminanceOff", MaintainLuminanceOff);

	Nan::SetPrototypeMethod(tpl, "MaintainLuminanceOn", MaintainLuminanceOn);
	Nan::SetPrototypeMethod(tpl, "maintainLuminanceOn", MaintainLuminanceOn);

	Nan::SetPrototypeMethod(tpl, "Modified", Modified);
	Nan::SetPrototypeMethod(tpl, "modified", Modified);

	Nan::SetPrototypeMethod(tpl, "NewInstance", NewInstance);
	Nan::SetPrototypeMethod(tpl, "newInstance", NewInstance);

	Nan::SetPrototypeMethod(tpl, "RemoveLightsFromRenderer", RemoveLightsFromRenderer);
	Nan::SetPrototypeMethod(tpl, "removeLightsFromRenderer", RemoveLightsFromRenderer);

	Nan::SetPrototypeMethod(tpl, "SafeDownCast", SafeDownCast);
	Nan::SetPrototypeMethod(tpl, "safeDownCast", SafeDownCast);

	Nan::SetPrototypeMethod(tpl, "SetBackLightAngle", SetBackLightAngle);
	Nan::SetPrototypeMethod(tpl, "setBackLightAngle", SetBackLightAngle);

	Nan::SetPrototypeMethod(tpl, "SetBackLightAzimuth", SetBackLightAzimuth);
	Nan::SetPrototypeMethod(tpl, "setBackLightAzimuth", SetBackLightAzimuth);

	Nan::SetPrototypeMethod(tpl, "SetBackLightElevation", SetBackLightElevation);
	Nan::SetPrototypeMethod(tpl, "setBackLightElevation", SetBackLightElevation);

	Nan::SetPrototypeMethod(tpl, "SetBackLightWarmth", SetBackLightWarmth);
	Nan::SetPrototypeMethod(tpl, "setBackLightWarmth", SetBackLightWarmth);

	Nan::SetPrototypeMethod(tpl, "SetFillLightAngle", SetFillLightAngle);
	Nan::SetPrototypeMethod(tpl, "setFillLightAngle", SetFillLightAngle);

	Nan::SetPrototypeMethod(tpl, "SetFillLightAzimuth", SetFillLightAzimuth);
	Nan::SetPrototypeMethod(tpl, "setFillLightAzimuth", SetFillLightAzimuth);

	Nan::SetPrototypeMethod(tpl, "SetFillLightElevation", SetFillLightElevation);
	Nan::SetPrototypeMethod(tpl, "setFillLightElevation", SetFillLightElevation);

	Nan::SetPrototypeMethod(tpl, "SetFillLightWarmth", SetFillLightWarmth);
	Nan::SetPrototypeMethod(tpl, "setFillLightWarmth", SetFillLightWarmth);

	Nan::SetPrototypeMethod(tpl, "SetHeadLightWarmth", SetHeadLightWarmth);
	Nan::SetPrototypeMethod(tpl, "setHeadLightWarmth", SetHeadLightWarmth);

	Nan::SetPrototypeMethod(tpl, "SetKeyLightAngle", SetKeyLightAngle);
	Nan::SetPrototypeMethod(tpl, "setKeyLightAngle", SetKeyLightAngle);

	Nan::SetPrototypeMethod(tpl, "SetKeyLightAzimuth", SetKeyLightAzimuth);
	Nan::SetPrototypeMethod(tpl, "setKeyLightAzimuth", SetKeyLightAzimuth);

	Nan::SetPrototypeMethod(tpl, "SetKeyLightElevation", SetKeyLightElevation);
	Nan::SetPrototypeMethod(tpl, "setKeyLightElevation", SetKeyLightElevation);

	Nan::SetPrototypeMethod(tpl, "SetKeyLightIntensity", SetKeyLightIntensity);
	Nan::SetPrototypeMethod(tpl, "setKeyLightIntensity", SetKeyLightIntensity);

	Nan::SetPrototypeMethod(tpl, "SetKeyLightWarmth", SetKeyLightWarmth);
	Nan::SetPrototypeMethod(tpl, "setKeyLightWarmth", SetKeyLightWarmth);

	Nan::SetPrototypeMethod(tpl, "SetKeyToBackRatio", SetKeyToBackRatio);
	Nan::SetPrototypeMethod(tpl, "setKeyToBackRatio", SetKeyToBackRatio);

	Nan::SetPrototypeMethod(tpl, "SetKeyToFillRatio", SetKeyToFillRatio);
	Nan::SetPrototypeMethod(tpl, "setKeyToFillRatio", SetKeyToFillRatio);

	Nan::SetPrototypeMethod(tpl, "SetKeyToHeadRatio", SetKeyToHeadRatio);
	Nan::SetPrototypeMethod(tpl, "setKeyToHeadRatio", SetKeyToHeadRatio);

	Nan::SetPrototypeMethod(tpl, "SetMaintainLuminance", SetMaintainLuminance);
	Nan::SetPrototypeMethod(tpl, "setMaintainLuminance", SetMaintainLuminance);

	Nan::SetPrototypeMethod(tpl, "Update", Update);
	Nan::SetPrototypeMethod(tpl, "update", Update);

#ifdef VTK_NODE_PLUS_VTKLIGHTKITWRAP_INITPTPL
	VTK_NODE_PLUS_VTKLIGHTKITWRAP_INITPTPL
#endif
	ptpl.Reset( tpl );
}

void VtkLightKitWrap::New(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	if(!info.IsConstructCall())
	{
		Nan::ThrowError("Constructor not called in a construct call.");
		return;
	}

	if(info.Length() == 0)
	{
		vtkSmartPointer<vtkLightKit> native = vtkSmartPointer<vtkLightKit>::New();
		VtkLightKitWrap* obj = new VtkLightKitWrap(native);
		obj->Wrap(info.This());
	}
	else
	{
		if(info[0]->ToObject() != vtkNodeJsNoWrap )
		{
			Nan::ThrowError("Parameter Error");
			return;
		}
	}

	info.GetReturnValue().Set(info.This());
}

void VtkLightKitWrap::AddLightsToRenderer(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkRendererWrap::ptpl))->HasInstance(info[0]))
	{
		VtkRendererWrap *a0 = ObjectWrap::Unwrap<VtkRendererWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->AddLightsToRenderer(
			(vtkRenderer *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::DeepCopy(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkLightKitWrap::ptpl))->HasInstance(info[0]))
	{
		VtkLightKitWrap *a0 = ObjectWrap::Unwrap<VtkLightKitWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->DeepCopy(
			(vtkLightKit *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::GetBackLightAngle(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetBackLightAngle();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 2 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 2);
	memcpy(ab->GetContents().Data(), r, 2 * sizeof(double));
	info.GetReturnValue().Set(at);
}

void VtkLightKitWrap::GetBackLightAzimuth(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetBackLightAzimuth();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetBackLightColor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetBackLightColor();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 3 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 3);
	memcpy(ab->GetContents().Data(), r, 3 * sizeof(double));
	info.GetReturnValue().Set(at);
}

void VtkLightKitWrap::GetBackLightElevation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetBackLightElevation();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetBackLightWarmth(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetBackLightWarmth();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetClassName(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	char const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetClassName();
	info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
}

void VtkLightKitWrap::GetFillLightAngle(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetFillLightAngle();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 2 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 2);
	memcpy(ab->GetContents().Data(), r, 2 * sizeof(double));
	info.GetReturnValue().Set(at);
}

void VtkLightKitWrap::GetFillLightAzimuth(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetFillLightAzimuth();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetFillLightColor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetFillLightColor();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 3 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 3);
	memcpy(ab->GetContents().Data(), r, 3 * sizeof(double));
	info.GetReturnValue().Set(at);
}

void VtkLightKitWrap::GetFillLightElevation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetFillLightElevation();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetFillLightWarmth(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetFillLightWarmth();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetHeadLightColor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetHeadLightColor();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 3 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 3);
	memcpy(ab->GetContents().Data(), r, 3 * sizeof(double));
	info.GetReturnValue().Set(at);
}

void VtkLightKitWrap::GetHeadLightWarmth(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetHeadLightWarmth();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetKeyLightAngle(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetKeyLightAngle();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 2 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 2);
	memcpy(ab->GetContents().Data(), r, 2 * sizeof(double));
	info.GetReturnValue().Set(at);
}

void VtkLightKitWrap::GetKeyLightAzimuth(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetKeyLightAzimuth();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetKeyLightColor(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double const * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetKeyLightColor();
	Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(v8::Isolate::GetCurrent(), 3 * sizeof(double));
	Local<v8::Float64Array> at = v8::Float64Array::New(ab, 0, 3);
	memcpy(ab->GetContents().Data(), r, 3 * sizeof(double));
	info.GetReturnValue().Set(at);
}

void VtkLightKitWrap::GetKeyLightElevation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetKeyLightElevation();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetKeyLightIntensity(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetKeyLightIntensity();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetKeyLightWarmth(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetKeyLightWarmth();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetKeyToBackRatio(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetKeyToBackRatio();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetKeyToBackRatioMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetKeyToBackRatioMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetKeyToBackRatioMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetKeyToBackRatioMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetKeyToFillRatio(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetKeyToFillRatio();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetKeyToFillRatioMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetKeyToFillRatioMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetKeyToFillRatioMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetKeyToFillRatioMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetKeyToHeadRatio(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetKeyToHeadRatio();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetKeyToHeadRatioMaxValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetKeyToHeadRatioMaxValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetKeyToHeadRatioMinValue(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	double r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetKeyToHeadRatioMinValue();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetMaintainLuminance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	int r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->GetMaintainLuminance();
	info.GetReturnValue().Set(Nan::New(r));
}

void VtkLightKitWrap::GetShortStringFromSubType(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetShortStringFromSubType(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::GetStringFromSubType(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetStringFromSubType(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::GetStringFromType(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
		char const * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->GetStringFromType(
			info[0]->Int32Value()
		);
		info.GetReturnValue().Set(Nan::New(r).ToLocalChecked());
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::IsA(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsString())
	{
		Nan::Utf8String a0(info[0]);
		int r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->IsA(
			*a0
		);
		info.GetReturnValue().Set(Nan::New(r));
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::MaintainLuminanceOff(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->MaintainLuminanceOff();
}

void VtkLightKitWrap::MaintainLuminanceOn(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->MaintainLuminanceOn();
}

void VtkLightKitWrap::Modified(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->Modified();
}

void VtkLightKitWrap::NewInstance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	vtkLightKit * r;
	if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	r = native->NewInstance();
	VtkLightKitWrap::InitPtpl();
	v8::Local<v8::Value> argv[1] =
		{ Nan::New(vtkNodeJsNoWrap) };
	v8::Local<v8::Function> cons =
		Nan::New<v8::FunctionTemplate>(VtkLightKitWrap::ptpl)->GetFunction();
	v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
	VtkLightKitWrap *w = new VtkLightKitWrap();
	w->native = r;
	w->Wrap(wo);
	info.GetReturnValue().Set(wo);
}

void VtkLightKitWrap::RemoveLightsFromRenderer(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkRendererWrap::ptpl))->HasInstance(info[0]))
	{
		VtkRendererWrap *a0 = ObjectWrap::Unwrap<VtkRendererWrap>(info[0]->ToObject());
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->RemoveLightsFromRenderer(
			(vtkRenderer *) a0->native.GetPointer()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SafeDownCast(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsObject() && (Nan::New(VtkObjectWrap::ptpl))->HasInstance(info[0]))
	{
		VtkObjectWrap *a0 = ObjectWrap::Unwrap<VtkObjectWrap>(info[0]->ToObject());
		vtkLightKit * r;
		if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		r = native->SafeDownCast(
			(vtkObject *) a0->native.GetPointer()
		);
		VtkLightKitWrap::InitPtpl();
		v8::Local<v8::Value> argv[1] =
			{ Nan::New(vtkNodeJsNoWrap) };
		v8::Local<v8::Function> cons =
			Nan::New<v8::FunctionTemplate>(VtkLightKitWrap::ptpl)->GetFunction();
		v8::Local<v8::Object> wo = cons->NewInstance(1, argv);
		VtkLightKitWrap *w = new VtkLightKitWrap();
		w->native = r;
		w->Wrap(wo);
		info.GetReturnValue().Set(wo);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetBackLightAngle(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetBackLightAngle(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[2];
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 2; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetBackLightAngle(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetBackLightAngle(
				info[0]->NumberValue(),
				info[1]->NumberValue()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetBackLightAzimuth(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetBackLightAzimuth(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetBackLightElevation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetBackLightElevation(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetBackLightWarmth(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetBackLightWarmth(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetFillLightAngle(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetFillLightAngle(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[2];
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 2; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetFillLightAngle(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetFillLightAngle(
				info[0]->NumberValue(),
				info[1]->NumberValue()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetFillLightAzimuth(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetFillLightAzimuth(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetFillLightElevation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetFillLightElevation(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetFillLightWarmth(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetFillLightWarmth(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetHeadLightWarmth(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetHeadLightWarmth(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetKeyLightAngle(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	size_t i;
	if(info.Length() > 0 && info[0]->IsFloat64Array())
	{
		v8::Local<v8::Float64Array>a0(v8::Local<v8::Float64Array>::Cast(info[0]->ToObject()));
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetKeyLightAngle(
			(double *)(a0->Buffer()->GetContents().Data())
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsArray())
	{
		v8::Local<v8::Array>a0(v8::Local<v8::Array>::Cast(info[0]->ToObject()));
		double b0[2];
		if( a0->Length() < 2 )
		{
			Nan::ThrowError("Array too short.");
			return;
		}

		for( i = 0; i < 2; i++ )
		{
			if( !a0->Get(i)->IsNumber() )
			{
				Nan::ThrowError("Array contents invalid.");
				return;
			}
			b0[i] = a0->Get(i)->NumberValue();
		}
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetKeyLightAngle(
			b0
		);
		return;
	}
	else if(info.Length() > 0 && info[0]->IsNumber())
	{
		if(info.Length() > 1 && info[1]->IsNumber())
		{
						if(info.Length() != 2)
			{
				Nan::ThrowError("Too many parameters.");
				return;
			}
			native->SetKeyLightAngle(
				info[0]->NumberValue(),
				info[1]->NumberValue()
			);
			return;
		}
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetKeyLightAzimuth(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetKeyLightAzimuth(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetKeyLightElevation(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetKeyLightElevation(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetKeyLightIntensity(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetKeyLightIntensity(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetKeyLightWarmth(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetKeyLightWarmth(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetKeyToBackRatio(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetKeyToBackRatio(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetKeyToFillRatio(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetKeyToFillRatio(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetKeyToHeadRatio(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsNumber())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetKeyToHeadRatio(
			info[0]->NumberValue()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::SetMaintainLuminance(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
	if(info.Length() > 0 && info[0]->IsInt32())
	{
				if(info.Length() != 1)
		{
			Nan::ThrowError("Too many parameters.");
			return;
		}
		native->SetMaintainLuminance(
			info[0]->Int32Value()
		);
		return;
	}
	Nan::ThrowError("Parameter mismatch");
}

void VtkLightKitWrap::Update(const Nan::FunctionCallbackInfo<v8::Value>& info)
{
	VtkLightKitWrap *wrapper = ObjectWrap::Unwrap<VtkLightKitWrap>(info.Holder());
	vtkLightKit *native = (vtkLightKit *)wrapper->native.GetPointer();
		if(info.Length() != 0)
	{
		Nan::ThrowError("Too many parameters.");
		return;
	}
	native->Update();
}